PWG1/TRD/AliTRDcheckESD.cxx

   1 /**************************************************************************
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15
  16 /////////////////////////////////////////////////////
  17 //
  18 // Check basic detector results at ESD level
  19 //   - Geometrical efficiency
  20 //   - Tracking efficiency
  21 //   - PID efficiency
  22 //   - Refit efficiency
  23 //
  24 // Author
  25 //   Alex Bercuci <A.Bercuci@gsi.de>
  26 //
  27 //////////////////////////////////////////////////////
  28
  29 #include <TClonesArray.h>
  30 #include <TCanvas.h>
  31 #include <TObjArray.h>
  32 #include <TPad.h>
  33 #include <TLegend.h>
  34 #include <TLatex.h>
  35 #include <TLine.h>
  36 #include <TF1.h>
  37 #include <TH1D.h>
  38 #include <TH2D.h>
  39 #include <TH3D.h>
  40 #include <TH2I.h>
  41 #include <TH2F.h>
  42 #include <TH3S.h>
  43 #include <TH3F.h>
  44 #include <TProfile2D.h>
  45 #include <TProfile.h>
  46 #include <TGraphErrors.h>
  47 #include <TGraphAsymmErrors.h>
  48 #include <TFile.h>
  49 #include <TTree.h>
  50 #include <TROOT.h>
  51 #include <TChain.h>
  52 #include <TParticle.h>
  53 #include <TTimeStamp.h>
  54 #include <TRandom.h>
  55
  56 #include "AliLog.h"
  57 #include "AliAnalysisManager.h"
  58 #include "AliAnalysisCuts.h"
  59 #include "AliESDEvent.h"
  60 #include "AliESDkink.h"
  61 #include "AliMCEvent.h"
  62 #include "AliESDInputHandler.h"
  63 #include "AliMCEventHandler.h"
  64 #include "AliESDpid.h"
  65
  66 #include "AliESDtrack.h"
  67 #include "AliMCParticle.h"
  68 #include "AliPID.h"
  69 #include "AliStack.h"
  70 #include "AliTrackReference.h"
  71 //#include "AliESDCentrality.h"
  72 #include "AliMultiplicity.h"
  73 #include "AliCFContainer.h"
  74
  75 #include "AliTRDcheckESD.h"
  76 #include <iostream>
  77 using namespace std;
  78
  79 ClassImp(AliTRDcheckESD)
  80
  81 const Float_t AliTRDcheckESD::fgkxTPC = 290.;
  82 const Float_t AliTRDcheckESD::fgkxTOF = 365.;
  83 const UChar_t AliTRDcheckESD::fgkNgraph[AliTRDcheckESD::kNrefs] ={
  84 8, 4, 2, 20};
  85 FILE* AliTRDcheckESD::fgFile = NULL;
  86
  87 const Float_t AliTRDcheckESD::fgkEvVertexZ = 15.;
  88 const Int_t   AliTRDcheckESD::fgkEvVertexN = 1;
  89 const Float_t AliTRDcheckESD::fgkTrkDCAxy  = 40.;
  90 const Float_t AliTRDcheckESD::fgkTrkDCAz   = 15.;
  91 const Int_t   AliTRDcheckESD::fgkNclTPC    = 100;
  92 const Float_t AliTRDcheckESD::fgkPt        = 0.2;
  93 const Float_t AliTRDcheckESD::fgkEta       = 0.9;
  94 const Float_t AliTRDcheckESD::fgkQs        = 0.002;
  95
  96 //____________________________________________________________________
  97 AliTRDcheckESD::AliTRDcheckESD():
  98   AliAnalysisTaskSE()
  99   ,fStatus(0)
 100   ,fNRefFigures(0)
 101   ,fESD(NULL)
 102   ,fMC(NULL)
 103   ,fESDpid(new AliESDpid)
 104   ,fHistos(NULL)
 105   ,fResults(NULL)
 106   ,fCfContainer(NULL)
 107   ,fReferenceTrackFilter(NULL)
 108 {
 109   //
 110   // Default constructor
 111   //
 112   SetNameTitle("TRDcheckESD", "Check TRD @ ESD level");
 113   SetMC(kTRUE);
 114 }
 115
 116 //____________________________________________________________________
 117 AliTRDcheckESD::AliTRDcheckESD(char* name):
 118   AliAnalysisTaskSE(name)
 119   ,fStatus(0)
 120   ,fNRefFigures(0)
 121   ,fESD(NULL)
 122   ,fMC(NULL)
 123   ,fESDpid(new AliESDpid)
 124   ,fHistos(NULL)
 125   ,fResults(NULL)
 126   ,fCfContainer(NULL)
 127   ,fReferenceTrackFilter(NULL)
 128 {
 129   //
 130   // Default constructor
 131   //
 132   SetMC(kTRUE);
 133   SetTitle("Check TRD @ ESD level");
 134   DefineOutput(1, TObjArray::Class());
 135 }
 136
 137 //____________________________________________________________________
 138 AliTRDcheckESD::~AliTRDcheckESD()
 139 {
 140 // Destructor
 141   if(fHistos){
 142     //fHistos->Delete();
 143     delete fHistos;
 144   }
 145   if(fResults){
 146     fResults->Delete();
 147     delete fResults;
 148   }
 149 }
 150
 151 //____________________________________________________________________
 152 void AliTRDcheckESD::UserCreateOutputObjects()
 153 {
 154   //
 155   // Create Output Containers (TObjectArray containing 1D histograms)
 156   //
 157   Histos();
 158   PostData(1, fHistos);
 159 }
 160
 161 //____________________________________________________________________
 162 void AliTRDcheckESD::MakeSummaryFromCF(Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc){
 163   //
 164   // Draw summary plots for the ESDcheck task using the CF container
 165   //
 166
 167   cout << "Make summary from CF" << endl;
 168   TCanvas *cOut=0x0;
 169   if(gROOT->FindObject("trackingSummary")) delete gROOT->FindObject("trackingSummary");
 170   cOut = new TCanvas("trackingSummary", "Tracking summary for the ESD task", 1600, 1200);
 171   cOut->cd();
 172   PlotTrackingSummaryFromCF(0, trendValues, useIsolatedBC, cutTOFbc);
 173   cOut->SaveAs("trackingSummary.gif");
 174
 175   if(gROOT->FindObject("pidSummary")) delete gROOT->FindObject("pidSummary");
 176   cOut = new TCanvas("pidSummary", "PID summary for the ESD task", 1600, 1200);
 177   cOut->cd();
 178   //GetRefFigure(6);
 179   PlotPidSummaryFromCF(0, trendValues, useIsolatedBC, cutTOFbc);
 180   cOut->SaveAs("pidSummary.gif");
 181
 182   if(gROOT->FindObject("centSummary")) delete gROOT->FindObject("centSummary");
 183   cOut = new TCanvas("centSummary", "Centrality summary for the ESD task", 1600, 1200);
 184   cOut->cd();
 185   //GetRefFigure(7);
 186   PlotCentSummaryFromCF(trendValues, useIsolatedBC, cutTOFbc);
 187   cOut->SaveAs("centSummary.gif");
 188
 189 }
 190
 191
 192 //____________________________________________________________________
 193 void AliTRDcheckESD::MakeSummary(Double_t* trendValues){
 194   //
 195   // Draw summary plots for the ESDcheck task
 196   //
 197   // Old method to draw summary pictures from histograms. Use the MakeSummaryFromCF() when CF container is present
 198
 199   cout << "Make summary" << endl;
 200   TCanvas *cTracking=0x0;
 201   if(gROOT->FindObject("trackingSummary")) delete gROOT->FindObject("trackingSummary");
 202   cTracking = new TCanvas("trackingSummary", "Tracking summary for the ESD task", 1600, 1200);
 203   cTracking->cd();
 204   //GetRefFigure(5);
 205   if(PlotTrackingSummary(0, trendValues))
 206     cTracking->SaveAs("trackingSummary.gif");
 207
 208   TCanvas* cPid = 0x0;
 209   if(gROOT->FindObject("pidSummary")) delete gROOT->FindObject("pidSummary");
 210   cPid = new TCanvas("pidSummary", "PID summary for the ESD task", 1600, 1200);
 211   cPid->cd();
 212   //GetRefFigure(6);
 213   if(PlotPidSummary(0, trendValues))
 214     cPid->SaveAs("pidSummary.gif");
 215
 216   TCanvas* cCent=0x0;
 217   if(gROOT->FindObject("centSummary")) delete gROOT->FindObject("centSummary");
 218   cCent = new TCanvas("centSummary", "Centrality summary for the ESD task", 1600, 1200);
 219   cCent->cd();
 220   //GetRefFigure(7);
 221   if(PlotCentSummary(trendValues))
 222     cCent->SaveAs("centSummary.gif");
 223 }
 224
 225 //____________________________________________________________________
 226 Bool_t AliTRDcheckESD::GetRefFigure(Int_t ifig)
 227 {
 228   //
 229   // Produce reference Plots during PostProcessing
 230   //
 231   if(ifig>=fNRefFigures){
 232     AliWarning(Form("Ref plot %d not available. Valid only up to %d", ifig, fNRefFigures));
 233     return kFALSE;
 234   }
 235   if(!gPad){
 236     AliWarning("Please provide a canvas to draw results.");
 237     return kFALSE;
 238   } else {
 239     gPad->SetLogx(0);gPad->SetLogy(0);
 240     gPad->SetMargin(0.125, 0.015, 0.1, 0.015);
 241   }
 242
 243   const Char_t *title[20];
 244   TH1 *hF(NULL);
 245   if((hF=(TH1S*)gROOT->FindObject("hFcheckESD"))) delete hF;
 246   TLegend *leg(NULL);
 247   TList *l(NULL); TVirtualPad *pad(NULL);
 248   TGraphErrors *g(NULL);TGraphAsymmErrors *ga(NULL);
 249   TObjArray *arr(NULL);
 250   TLatex *lat=new TLatex();
 251   lat->SetTextSize(0.07);
 252   lat->SetTextColor(2);
 253   TLine line;
 254   TTimeStamp now;
 255   switch(ifig){
 256   case kNCl: // number of clusters/track
 257     if(!(arr = (TObjArray*)fResults->At(kNCl))) return kFALSE;
 258
 259     leg = new TLegend(.83, .7, .99, .96);
 260     leg->SetHeader("Species");
 261     leg->SetBorderSize(0); leg->SetFillStyle(0);
 262     for(Int_t ig(0); ig<fgkNgraph[kNCl-1]; ig++){
 263       if(!(g = (TGraphErrors*)arr->At(ig))) return kFALSE;
 264       if(!g->GetN()) continue;
 265       g->Draw(ig?"pc":"apc"); leg->AddEntry(g, g->GetTitle(), "pl");
 266       if(ig) continue;
 267       hF=g->GetHistogram();
 268       hF->SetXTitle("no of clusters");
 269       hF->SetYTitle("entries");
 270       hF->GetYaxis()->CenterTitle(1);
 271       hF->GetYaxis()->SetTitleOffset(1.2);
 272       hF->SetMinimum(5);
 273     }
 274     leg->Draw(); gPad->SetLogy();
 275     break;
 276   case kTRDstat: // Efficiency
 277     if(!(arr = (TObjArray*)fResults->At(kTRDstat))) return kFALSE;
 278     leg = new TLegend(.62, .77, .98, .98);
 279     leg->SetHeader("TRD Efficiency");
 280     leg->SetBorderSize(0); leg->SetFillStyle(0);
 281     title[0] = "Geometrical (TRDin/TPCout)";
 282     title[1] = "Tracking (TRDout/TRDin)";
 283     title[2] = "PID (TRDpid/TRDin)";
 284     title[3] = "Refit (TRDrefit/TRDin)";
 285     hF = new TH1S("hFcheckESD", ";p [GeV/c];Efficiency", 10, 0.1, 10.);
 286     hF->SetMaximum(1.4);
 287     hF->GetXaxis()->SetMoreLogLabels();
 288     hF->GetYaxis()->CenterTitle(1);
 289     hF->Draw("p");
 290     for(Int_t ig(0); ig<fgkNgraph[kTRDstat-1]; ig++){
 291       if(!(g = (TGraphErrors*)arr->At(ig))) return kFALSE;
 292       g->Draw("pl"); leg->AddEntry(g, title[ig], "pl");
 293       //PutTrendValue(name[id], g->GetMean(2));
 294       //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2));
 295     }
 296     leg->Draw(); gPad->SetLogx();
 297     break;
 298   case kTRDmom: // Energy loss
 299     if(!(arr = (TObjArray*)fResults->At(kTRDmom))) return kFALSE;
 300     leg = new TLegend(.65, .7, .95, .99);
 301     leg->SetHeader("Energy Loss");
 302     leg->SetBorderSize(1); leg->SetFillColor(0);
 303     title[0] = "Max & 90% quantile";
 304     title[1] = "Mean & 60% quantile";
 305     hF = new TH1S("hFcheckESD", ";layer;#Delta E", 6, -0.5, 5.5);
 306     hF->SetMaximum(1.3);hF->SetMinimum(-.3);
 307     hF->Draw("p");
 308     for(Int_t ig(0); ig<fgkNgraph[kTRDmom-1]; ig++){
 309       if(!(ga = (TGraphAsymmErrors*)arr->At(ig))) return kFALSE;
 310       ga->Draw("pl"); leg->AddEntry(ga, title[ig], "pl");
 311       //PutTrendValue(name[id], g->GetMean(2));
 312       //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2));
 313     }
 314     leg->Draw();gPad->SetLogx(kFALSE);
 315     break;
 316   case kPtRes: // Pt resolution @ vertex
 317     if(!(arr = (TObjArray*)fResults->At(kPtRes))) return kFALSE;
 318     gPad->Divide(2, 1, 1.e-5, 1.e-5); l=gPad->GetListOfPrimitives();
 319     pad = ((TVirtualPad*)l->At(0)); pad->cd(); pad->SetLogx();
 320     pad->SetMargin(0.1, 0.022, 0.1, 0.023);
 321     hF = new TH1S("hFcheckESD", "ITS+TPC+TRD;p_{t} [GeV/c];#Delta p_{t} / p_{t} [%]", 10, 0.2, 10.);
 322     hF->SetMaximum(10.);hF->SetMinimum(-3.);
 323     hF->GetXaxis()->SetMoreLogLabels();
 324     hF->GetXaxis()->SetTitleOffset(1.2);
 325     hF->GetYaxis()->CenterTitle();
 326     hF->Draw("p");
 327     //for(Int_t ig(0); ig<fgkNgraph[kPtRes-1]/2; ig++){
 328     for(Int_t ig(2); ig<6; ig++){
 329       if(!(g = (TGraphErrors*)arr->At(ig))) continue;
 330       if(!g->GetN()) continue;
 331       g->Draw("pl");
 332       //PutTrendValue(name[id], g->GetMean(2));
 333       //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2));
 334     }
 335     pad = ((TVirtualPad*)l->At(1)); pad->cd(); pad->SetLogx();
 336     pad->SetMargin(0.1, 0.22, 0.1, 0.023);
 337     hF = (TH1*)hF->Clone("hFcheckESD1");
 338     hF->SetTitle("ITS+TPC");
 339     hF->SetMaximum(10.);hF->SetMinimum(-3.);
 340     hF->Draw("p");
 341     leg = new TLegend(.78, .1, .99, .98);
 342     leg->SetHeader("P_{t} @ DCA");
 343     leg->SetBorderSize(1); leg->SetFillColor(0);
 344     leg->SetTextAlign(22);
 345     leg->SetTextFont(12);
 346     leg->SetTextSize(0.03813559);
 347     {
 348       Int_t nPlots(0);
 349       //for(Int_t ig(fgkNgraph[kPtRes-1]/2); ig<fgkNgraph[kPtRes-1]; ig++){
 350       for(Int_t ig(12); ig<16; ig++){
 351         if(!(g = (TGraphErrors*)arr->At(ig))) continue;
 352         if(!g->GetN()) continue;
 353         nPlots++;
 354         g->Draw("pl"); leg->AddEntry(g, g->GetTitle(), "pl");
 355         //PutTrendValue(name[id], g->GetMean(2));
 356         //PutTrendValue(Form("%sRMS", name[id]), g->GetRMS(2));
 357       }
 358       if(nPlots) leg->Draw();
 359     }
 360     break;
 361   case 5: // plot a 3x3 canvas with tracking related histograms
 362     PlotTrackingSummary(0);
 363     break;
 364
 365   case 6: // plot a 3x3 canvas with PID related histograms
 366     PlotPidSummary(0);
 367     break;
 368
 369   case 7: // plot a 3x3 canvas with centrality dependence histograms
 370     PlotCentSummary();
 371     break;
 372
 373   }
 374   return kTRUE;
 375 }
 376
 377 //____________________________________________________________________
 378 void AliTRDcheckESD::UserExec(Option_t *){
 379   //
 380   // Run the Analysis
 381   //
 382   fESD = dynamic_cast<AliESDEvent*>(InputEvent());
 383   fMC = MCEvent();
 384
 385   if(!fESD){
 386     AliError("ESD event missing.");
 387     return;
 388   }
 389
 390   // Get MC information if available
 391   AliStack * fStack = NULL;
 392   if(HasMC()){
 393     if(!fMC){
 394       AliWarning("MC event missing");
 395       SetMC(kFALSE);
 396     } else {
 397       if(!(fStack = fMC->Stack())){
 398         AliWarning("MC stack missing");
 399         SetMC(kFALSE);
 400       }
 401     }
 402   }
 403   TH1 *h(NULL);
 404
 405   Double_t values[kNTrdCfVariables];      // array where the CF container variables are stored
 406   values[kEventVtxZ] = fESD->GetPrimaryVertex()->GetZv();
 407   values[kEventBC] = fESD->GetBunchCrossNumber();
 408
 409   const AliMultiplicity* mult=fESD->GetMultiplicity();
 410   Double_t itsNTracklets = mult->GetNumberOfTracklets();
 411   if(itsNTracklets<1) return;
 412   Int_t multLimits[6] = {0, 700, 1400, 2100, 2800, 3500};
 413   Int_t centralityClass = 0;
 414   for(Int_t iCent=0; iCent<5; ++iCent) {
 415     if(itsNTracklets>=multLimits[iCent] && itsNTracklets<multLimits[iCent+1])
 416       centralityClass=iCent+1;
 417   }
 418   values[kEventMult] = itsNTracklets;
 419   if(centralityClass == 0) return;
 420
 421   AliESDtrack *esdTrack(NULL);
 422   for(Int_t itrk = 0; itrk < fESD->GetNumberOfTracks(); itrk++){
 423     esdTrack = fESD->GetTrack(itrk);
 424     if(!fReferenceTrackFilter->IsSelected(esdTrack)) continue;
 425
 426     ULong_t status = esdTrack->GetStatus(); //PrintStatus(status);
 427
 428     // pid quality
 429     Bool_t kBarrel = Bool_t(status & AliESDtrack::kTRDin);
 430
 431     // find position and momentum of the track at entrance in TRD
 432     Double_t localCoord[3] = {0., 0., 0.};
 433     Bool_t localCoordGood = esdTrack->GetXYZAt(298., fESD->GetMagneticField(), localCoord);
 434     Double_t localMom[3] = {0., 0., 0.};
 435     Bool_t localMomGood = esdTrack->GetPxPyPzAt(298., fESD->GetMagneticField(), localMom);
 436     //Double_t localPhi = (localMomGood ? TMath::ATan2(localMom[1], localMom[0]) : 0.0);
 437     Double_t localSagitaPhi = (localCoordGood ? TMath::ATan2(localCoord[1], localCoord[0]) : 0.0);
 438
 439     values[kTrackTOFdeltaBC] = esdTrack->GetTOFDeltaBC();
 440     values[kTrackTOFBC]      = esdTrack->GetTOFBunchCrossing(fESD->GetMagneticField());
 441     Float_t dcaXY=0.0; Float_t dcaZ=0.0;
 442     esdTrack->GetImpactParameters(dcaXY, dcaZ);
 443     values[kTrackDCAxy]  = dcaXY;
 444     values[kTrackDCAz]   = dcaZ;
 445     values[kTrackCharge] = esdTrack->Charge();
 446     values[kTrackPhi]    = localSagitaPhi;
 447     values[kTrackEta]    = esdTrack->Eta();
 448     values[kTrackPt]     = esdTrack->Pt();
 449     values[kTrackP]      = esdTrack->P();
 450     values[kTrackTrdTracklets] = esdTrack->GetTRDntracklets();
 451     values[kTrackTrdClusters] = esdTrack->GetTRDncls();
 452     for(Int_t i=0; i<6; ++i) values[kTrackQtot+i] = 0.0;
 453
 454     if(localCoordGood && localMomGood) fCfContainer->Fill(values, 0);      // fill the TPC reference step
 455
 456     // TRD reference tracks
 457     if(esdTrack->GetTRDntracklets()>=1) {
 458       // (slicePH,sliceNo) distribution and Qtot from slices
 459       for(Int_t iPlane=0; iPlane<6; iPlane++) {
 460         Float_t qtot=esdTrack->GetTRDslice(iPlane, 0);
 461         for(Int_t iSlice=0; iSlice<8; iSlice++) {
 462           if(esdTrack->GetTRDslice(iPlane, iSlice)>20.) {
 463             h = (TH2F*)fHistos->At(kPHSlice); h->Fill(iSlice, esdTrack->GetTRDslice(iPlane, iSlice));
 464             h = (TH2F*)fHistos->At(kPHSlice+centralityClass); h->Fill(iSlice, esdTrack->GetTRDslice(iPlane, iSlice));
 465           }
 466         }
 467         values[kTrackQtot+iPlane] = fgkQs*qtot;
 468       }
 469
 470       if(localCoordGood && localMomGood) {
 471         fCfContainer->Fill(values, 1);
 472         if(Bool_t(status & AliESDtrack::kTOFpid)) fCfContainer->Fill(values, 2);
 473       }
 474     }  // end if nTRDtrkl>=1
 475
 476     // look at external track param
 477     const AliExternalTrackParam *op = esdTrack->GetOuterParam();
 478     const AliExternalTrackParam *ip = esdTrack->GetInnerParam();
 479
 480     Double_t pt(0.), pt0(0.), ptTRD(0.);
 481     // read MC info if available
 482     Bool_t kFOUND(kFALSE), kPhysPrim(kFALSE);
 483     AliMCParticle *mcParticle(NULL);
 484     if(HasMC()){
 485       AliTrackReference *ref(NULL);
 486       Int_t fLabel(esdTrack->GetLabel());
 487       Int_t fIdx(TMath::Abs(fLabel));
 488       if(!fStack || fIdx > fStack->GetNtrack()) continue;
 489
 490       // read MC particle
 491       if(!(mcParticle = (AliMCParticle*) fMC->GetTrack(fIdx))) {
 492         AliWarning(Form("MC particle missing. Label[ %d].", fLabel));
 493         continue;
 494       }
 495
 496       pt   = esdTrack->Pt();
 497       pt0  = mcParticle->Pt();
 498       //Double_t eta0 = mcParticle->Eta();
 499       //Double_t phi0 = mcParticle->Phi();
 500       kPhysPrim = fMC->IsPhysicalPrimary(fIdx);
 501
 502       // read track references
 503       Int_t nRefs = mcParticle->GetNumberOfTrackReferences();
 504       if(!nRefs){
 505         AliWarning(Form("No TR found for track @ Label[%d].", fLabel));
 506         continue;
 507       }
 508       Int_t iref = 0;
 509       while(iref<nRefs){
 510         ref = mcParticle->GetTrackReference(iref);
 511         if(ref->LocalX() > fgkxTPC) break;
 512         ref=NULL; iref++;
 513       }
 514       if(ref){
 515         if(ref->LocalX() > fgkxTOF){ // track skipping TRD fiducial volume
 516           ref = mcParticle->GetTrackReference(TMath::Max(iref-1, 0));
 517         }
 518       } else { // track stopped in TPC
 519         ref = mcParticle->GetTrackReference(TMath::Max(iref-1, 0));
 520       }
 521       ptTRD = ref->Pt();kFOUND=kTRUE;
 522     } else { // use reconstructed values
 523       if(op){
 524         Double_t x(op->GetX());
 525         if(x<fgkxTOF && x>fgkxTPC){
 526           ptTRD=op->Pt();
 527           kFOUND=kTRUE;
 528         }
 529       }
 530
 531       if(!kFOUND && ip){
 532         ptTRD=ip->Pt();
 533         kFOUND=kTRUE;
 534       }
 535     }     // end if(HasMC())
 536
 537     if(kFOUND){
 538       h = (TH2I*)fHistos->At(kTRDstat);
 539       if(status & AliESDtrack::kTPCout) h->Fill(ptTRD, kTPCout);
 540       if(status & AliESDtrack::kTRDin) h->Fill(ptTRD, kTRDin);
 541       if(kBarrel && (status & AliESDtrack::kTRDout)) h->Fill(ptTRD, kTRDout);
 542       if(kBarrel && (status & AliESDtrack::kTRDpid)) h->Fill(ptTRD, kTRDpid);
 543       if(kBarrel && (status & AliESDtrack::kTRDrefit)) h->Fill(ptTRD, kTRDref);
 544     }
 545     Int_t idx(HasMC() ? Pdg2Idx(TMath::Abs(mcParticle->PdgCode())): 0)
 546          ,sgn(esdTrack->Charge()<0?0:1);
 547     if(kBarrel && kPhysPrim) {
 548       TH3 *h3 = (TH3S*)fHistos->At(kPtRes);
 549       Int_t offset = (status & AliESDtrack::kTRDrefit) ? 0 : 10;
 550       h3->Fill(pt0, 1.e2*(pt/pt0-1.),
 551         offset + 2*idx + sgn);
 552     }
 553     ((TH1*)fHistos->At(kNCl))->Fill(esdTrack->GetTRDncls(), 2*idx + sgn);
 554     if(ip){
 555       h = (TH2I*)fHistos->At(kTRDmom);
 556       Float_t pTRD(0.);
 557       for(Int_t ily=6; ily--;){
 558         if((pTRD=esdTrack->GetTRDmomentum(ily))<0.) continue;
 559         h->Fill(ip->GetP()-pTRD, ily);
 560       }
 561     }
 562   }  // end loop over tracks
 563
 564   // fill the number of tracks histograms
 565   //h = (TH1I*)fHistos->At(kNTracksAcc);
 566   //h->Fill(nTracksAcc);
 567   //h = (TH1I*)fHistos->At(kNTracksTPC);
 568   //h->Fill(nTracksTPC);
 569   PostData(1, fHistos);
 570 }
 571
 572 //____________________________________________________________________
 573 TObjArray* AliTRDcheckESD::Histos()
 574 {
 575 // Retrieve histograms array if already build or build it
 576
 577   if(fHistos) return fHistos;
 578
 579   fHistos = new TObjArray(kNhistos+1);
 580   fHistos->SetOwner(kTRUE);
 581
 582   TH1 *h = NULL;
 583
 584   // clusters per track
 585   const Int_t kNpt(30);
 586   Float_t pt(0.2);
 587   Float_t binsPt[kNpt+1];
 588   for(Int_t i=0;i<kNpt+1; i++,pt+=(TMath::Exp(i*i*.001)-1.)) binsPt[i]=pt;
 589   if(!(h = (TH2S*)gROOT->FindObject("hNCl"))){
 590     h = new TH2S("hNCl", "Clusters per TRD track;N_{cl}^{TRD};SPECIES;entries", 60, 0., 180., 10, -0.5, 9.5);
 591     TAxis *ay(h->GetYaxis());
 592     ay->SetLabelOffset(0.015);
 593     for(Int_t i(0); i<AliPID::kSPECIES; i++){
 594       ay->SetBinLabel(2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i)));
 595       ay->SetBinLabel(2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i)));
 596     }
 597   } else h->Reset();
 598   fHistos->AddAt(h, kNCl); fNRefFigures++;
 599
 600   // status bits histogram
 601   const Int_t kNbits(5);
 602   Float_t bits(.5);
 603   Float_t binsBits[kNbits+1];
 604   for(Int_t i=0; i<kNbits+1; i++,bits+=1.) binsBits[i]=bits;
 605   if(!(h = (TH2I*)gROOT->FindObject("hTRDstat"))){
 606     h = new TH2I("hTRDstat", "TRD status bits;p_{t} @ TRD [GeV/c];status;entries", kNpt, binsPt, kNbits, binsBits);
 607     TAxis *ay(h->GetYaxis());
 608     ay->SetBinLabel(1, "kTPCout");
 609     ay->SetBinLabel(2, "kTRDin");
 610     ay->SetBinLabel(3, "kTRDout");
 611     ay->SetBinLabel(4, "kTRDpid");
 612     ay->SetBinLabel(5, "kTRDrefit");
 613   } else h->Reset();
 614   fHistos->AddAt(h, kTRDstat);
 615
 616   // energy loss
 617   if(!(h = (TH2I*)gROOT->FindObject("hTRDmom"))){
 618     h = new TH2I("hTRDmom", "TRD energy loss;p_{inner} - p_{ly} [GeV/c];ly;entries", 100, -1., 2., 6, -0.5, 5.5);
 619   } else h->Reset();
 620   fHistos->AddAt(h, kTRDmom);
 621   //if(!HasMC()) return fHistos;
 622
 623   // pt resolution
 624   const Int_t kNdpt(100), kNspec(4*AliPID::kSPECIES);
 625   Float_t dpt(-3.), spec(-0.5);
 626   Float_t binsDPt[kNdpt+1], binsSpec[kNspec+1];
 627   for(Int_t i=0; i<kNdpt+1; i++,dpt+=6.e-2) binsDPt[i]=dpt;
 628   for(Int_t i=0; i<kNspec+1; i++,spec+=1.) binsSpec[i]=spec;
 629   if(!(h = (TH3S*)gROOT->FindObject("hPtRes"))){
 630     h = new TH3S("hPtRes", "P_{t} resolution @ DCA;p_{t}^{MC} [GeV/c];#Delta p_{t}/p_{t}^{MC} [%];SPECIES", kNpt, binsPt, kNdpt, binsDPt, kNspec, binsSpec);
 631     TAxis *az(h->GetZaxis());
 632     az->SetLabelOffset(0.015);
 633     for(Int_t i(0); i<AliPID::kSPECIES; i++){
 634       az->SetBinLabel(2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i)));
 635       az->SetBinLabel(2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i)));
 636       az->SetBinLabel(10+2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i)));
 637       az->SetBinLabel(10+2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i)));
 638     }
 639   } else h->Reset();
 640   fHistos->AddAt(h, kPtRes);
 641
 642   // TPC event vertex distribution
 643   if(!(h = (TH1F*)gROOT->FindObject("hTPCVertex"))){
 644     h = new TH1F("hTPCVertex", "Event vertex Z coord. from TPC tracks", 100, -25., 25.);
 645   } else h->Reset();
 646   fHistos->AddAt(h, kTPCVertex);
 647
 648   // Event vertex
 649   if(!(h = (TH1F*)gROOT->FindObject("hEventVertex"))){
 650     h = new TH1F("hEventVertex", "Event vertex Z coord.", 100, -25., 25.);
 651   } else h->Reset();
 652   fHistos->AddAt(h, kEventVertex);
 653
 654   // Number of all tracks
 655   if(!(h = (TH1I*)gROOT->FindObject("hNTracksAll"))){
 656     h = new TH1I("hNTracksAll", "Number of tracks per event, event vertex cuts", 5000, 0, 5000);
 657   } else h->Reset();
 658   fHistos->AddAt(h, kNTracksAll);
 659
 660   // Number of tracks in acceptance and DCA cut
 661   if(!(h = (TH1I*)gROOT->FindObject("hNTracksAcc"))){
 662     h = new TH1I("hNTracksAcc", Form("Number of tracks per event, |#eta|<%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
 663                                      fgkEta, fgkTrkDCAxy, fgkTrkDCAz), 5000, 0, 5000);
 664   } else h->Reset();
 665   fHistos->AddAt(h, kNTracksAcc);
 666
 667   // Number of tracks in TPC (Ncls>10)
 668   if(!(h = (TH1I*)gROOT->FindObject("hNTracksTPC"))){
 669     h = new TH1I("hNTracksTPC", Form("Number of tracks per event, |#eta|<%.1f, pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 670                                      fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 5000, 0, 5000);
 671   } else h->Reset();
 672   fHistos->AddAt(h, kNTracksTPC);
 673
 674   // Distribution of DCA-xy
 675   if(!(h = (TH1F*)gROOT->FindObject("hDCAxy"))){
 676     h = new TH1F("hDCAxy", "Distribution of transverse DCA", 100, -100., 100.);
 677   } else h->Reset();
 678   fHistos->AddAt(h, kDCAxy);
 679
 680   // Distribution of DCA-z
 681   if(!(h = (TH1F*)gROOT->FindObject("hDCAz"))){
 682     h = new TH1F("hDCAz", "Distribution of longitudinal DCA", 100, -100., 100.);
 683   } else h->Reset();
 684   fHistos->AddAt(h, kDCAz);
 685
 686   Double_t binPtLimits[33] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
 687                              1.0, 1.1, 1.2, 1.3, 1.4,
 688                              1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0,
 689                              3.4, 3.8, 4.2, 4.6, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
 690   // Pt distributions
 691   if(!(h = (TH1F*)gROOT->FindObject("hPt1"))){
 692     h = new TH1F("hPt1", Form("dN/dpt, |#eta|<%.1f and pt>%.1f", fgkEta, fgkPt), 32, binPtLimits);
 693   } else h->Reset();
 694   fHistos->AddAt(h, kPt1);
 695
 696   if(!(h = (TH1F*)gROOT->FindObject("hPt2"))){
 697     h = new TH1F("hPt2", Form("dN/dpt, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
 698                               fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 32, binPtLimits);
 699   } else h->Reset();
 700   fHistos->AddAt(h, kPt2);
 701
 702   if(!(h = (TH1F*)gROOT->FindObject("hPt3pos"))){
 703     h = new TH1F("hPt3pos", Form("dN/dpt (positives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 704                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 705   } else h->Reset();
 706   fHistos->AddAt(h, kPt3pos);
 707
 708   if(!(h = (TH1F*)gROOT->FindObject("hPt3neg"))){
 709     h = new TH1F("hPt3neg", Form("dN/dpt (negatives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 710                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 711   } else h->Reset();
 712   fHistos->AddAt(h, kPt3neg);
 713
 714   if(!(h = (TH1F*)gROOT->FindObject("hPt4pos"))){
 715     h = new TH1F("hPt4pos", Form("dN/dpt (positives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 716                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 717   } else h->Reset();
 718   fHistos->AddAt(h, kPt4pos);
 719
 720   if(!(h = (TH1F*)gROOT->FindObject("hPt4neg"))){
 721     h = new TH1F("hPt4pos", Form("dN/dpt (negatives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 722                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 723   } else h->Reset();
 724   fHistos->AddAt(h, kPt4neg);
 725
 726   // theta distribution of TRD tracks
 727   if(!(h = (TH1F*)gROOT->FindObject("hTheta"))){
 728     h = new TH1F("hTheta", Form("dN/d#theta, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 729                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 220,.5,2.7);
 730   } else h->Reset();
 731   fHistos->AddAt(h, kTheta);
 732
 733   // phi distribution of TRD tracks
 734   if(!(h = (TH1F*)gROOT->FindObject("hPhi"))){
 735     h = new TH1F("hPhi", Form("dN/d#varphi, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 736                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 157,0,6.28);
 737   } else h->Reset();
 738   fHistos->AddAt(h, kPhi);
 739
 740   // TPC cluster distribution
 741   if(!(h = (TH1F*)gROOT->FindObject("hNTPCCl"))){
 742     h = new TH1I("hNTPCCl", Form("Number of TPC clusters/track, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
 743                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 160, 0, 160);
 744   } else h->Reset();
 745   fHistos->AddAt(h, kNTPCCl);
 746
 747   if(!(h = (TH1I*)gROOT->FindObject("hNTPCCl2"))){
 748     h = new TH1F("hNTPCCl2", Form("Number of TPC clusters/track, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, pt>1.0 GeV/c",
 749                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 160, 0, 160);
 750   } else h->Reset();
 751   fHistos->AddAt(h, kNTPCCl2);
 752
 753   // dE/dx vs P for TPC reference tracks
 754   if(!(h = (TH2F*)gROOT->FindObject("hTPCDedx"))){
 755     h = new TH2F("hTPCDedx", Form("TPC dE/dx vs P, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 756                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 150, 0, 150.);
 757   } else h->Reset();
 758   fHistos->AddAt(h, kTPCDedx);
 759
 760   // eta,phi distribution of TPC reference tracks
 761   if(!(h = (TH2F*)gROOT->FindObject("hEtaPhi"))){
 762     h = new TH2F("hEtaPhi", Form("TPC (#eta,#varphi), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 763                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 50, -1, 1, 157, 0, 6.28);
 764   } else h->Reset();
 765   fHistos->AddAt(h, kEtaPhi);
 766
 767   // Nclusters vs eta distribution for TPC tracks
 768   if(!(h = (TH2F*)gROOT->FindObject("hEtaNclsTPC"))){
 769     h = new TH2F("hEtaNclsTPC", Form("TPC Nclusters vs. #eta, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
 770                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 50, -1, 1, 160, 0, 160.);
 771   } else h->Reset();
 772   fHistos->AddAt(h, kEtaNclsTPC);
 773
 774   // Nclusters vs phi distribution for TPC reference tracks
 775   if(!(h = (TH2F*)gROOT->FindObject("hPhiNclsTPC"))){
 776     h = new TH2F("hPhiNclsTPC", Form("TPC Nclusters vs. #varphi, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
 777                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 157, 0, 6.28, 160, 0, 160.);
 778   } else h->Reset();
 779   fHistos->AddAt(h, kPhiNclsTPC);
 780
 781   // SPD multiplicity distribution
 782   if(!(h = (TH1F*)gROOT->FindObject("hSPDMult"))){
 783     h = new TH1F("hSPDMult", "SPD multiplicity", 10000, -0.5, 9999.5);
 784   } else h->Reset();
 785   fHistos->AddAt(h, kSPDMult);
 786
 787   // Ntracklets/track vs P for TRD reference tracks
 788   Double_t binsP[19] = {0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.7, 2.0,
 789                         2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 9.0, 12.0};
 790   for(Int_t iCent=0; iCent<=5; ++iCent) {
 791     if(!(h = (TH2F*)gROOT->FindObject(Form("hNTrackletsTRD_cent%d",iCent+1)))){
 792       h = new TH2F(Form("hNTrackletsTRD_cent%d",iCent+1), Form("TRD Ntracklets/track vs. P, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 793                                                                iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 7, -0.5, 6.5);
 794     } else h->Reset();
 795     fHistos->AddAt(h, kNTrackletsTRD+iCent);
 796   }
 797
 798   // Nclusters/track vs P for TRD reference tracks
 799   for(Int_t iCent=0; iCent<=5; ++iCent) {
 800     if(!(h = (TH2F*)gROOT->FindObject(Form("hNClsTrackTRD_cent%d",iCent+1)))){
 801       h = new TH2F(Form("hNClsTrackTRD_cent%d",iCent+1), Form("TRD Nclusters/track vs. P, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 802                                                               iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 300, 0., 300.);
 803     } else h->Reset();
 804     fHistos->AddAt(h, kNClsTrackTRD+iCent);
 805   }
 806
 807   // <PH> vs slice number for TRD reference tracklets
 808   for(Int_t iCent=0; iCent<=5; ++iCent) {
 809     if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSlice_cent%d",iCent+1)))){
 810       h = new TH2F(Form("hPHSlice_cent%d",iCent+1), Form("<PH> vs sliceNo, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 811                                     iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 200, 0., 2000.);
 812     } else h->Reset();
 813     fHistos->AddAt(h, kPHSlice+iCent);
 814   }
 815
 816   // <PH> vs slice number for TRD reference tracklets, from TPC pions
 817   for(Int_t iCent=0; iCent<=5; ++iCent) {
 818     if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSliceTPCpions_cent%d",iCent+1)))){
 819       h = new TH2F(Form("hPHSliceTPCpions_cent%d",iCent+1), Form("<PH> vs sliceNo, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, TPC pions",
 820                                                                  iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 100, 0., 2000.);
 821     } else h->Reset();
 822     fHistos->AddAt(h, kPHSliceTPCpions+iCent);
 823   }
 824
 825   // TPC dE/dx vs P for TRD reference tracks, pions
 826   for(Int_t iCent=0; iCent<=5; ++iCent) {
 827     if(!(h = (TH2F*)gROOT->FindObject(Form("hTPCdedxPions_cent%d",iCent+1)))){
 828       h = new TH2F(Form("hTPCdedxPions_cent%d",iCent+1), Form("TPC dE/dx vs P, TPC pions, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 829                                          iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 100, 0,100.);
 830     } else h->Reset();
 831     fHistos->AddAt(h, kTPCdedxPions+iCent);
 832   }
 833
 834   // <PH> vs slice number for TRD reference tracklets, from TPC electrons
 835   for(Int_t iCent=0; iCent<=5; ++iCent) {
 836     if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSliceTPCelectrons_cent%d",iCent+1)))){
 837       h = new TH2F(Form("hPHSliceTPCelectrons_cent%d",iCent+1), Form("<PH> vs sliceNo, centrality %d,|#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, TPC electrons",
 838                                                 iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 100, 0., 2000.);
 839     } else h->Reset();
 840     fHistos->AddAt(h, kPHSliceTPCelectrons+iCent);
 841   }
 842
 843   // TPC dE/dx vs P for TRD reference tracks, electrons
 844   for(Int_t iCent=0; iCent<=5; ++iCent) {
 845     if(!(h = (TH2F*)gROOT->FindObject(Form("hTPCdedxElectrons_cent%d",iCent+1)))){
 846       h = new TH2F(Form("hTPCdedxElectrons_cent%d",iCent+1), Form("TPC dE/dx vs P, TPC electrons, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 847                                              iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 100, 0,100.);
 848     } else h->Reset();
 849     fHistos->AddAt(h, kTPCdedxElectrons+iCent);
 850   }
 851
 852   // Qtot vs P for TRD reference tracklets
 853   for(Int_t iCent=0; iCent<=5; ++iCent) {
 854     if(!(h = (TH2F*)gROOT->FindObject(Form("hQtotP_cent%d",iCent+1)))){
 855       h = new TH2F(Form("hQtotP_cent%d",iCent+1), Form("Qtot(from slices) vs P, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 856                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 400, 0., 20);
 857     } else h->Reset();
 858     fHistos->AddAt(h, kQtotP+iCent);
 859   }
 860
 861   // (X,Y,momentum) distribution after AliESDtrack::PropagateTo(r=300.)
 862   if(!(h = (TH3F*)gROOT->FindObject("hPropagXYvsP"))){
 863     h = new TH3F("hPropagXYvsP", Form("(x,y) vs P after AliESDtrack::PropagateTo(r=300.), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 864                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100,-500,500, 100,-500,500, 10, 0.,10.);
 865   } else h->Reset();
 866   fHistos->AddAt(h, kPropagXYvsP);
 867
 868   // (R,Z,momentum) distribution after AliESDtrack::PropagateTo(r=300.)
 869   if(!(h = (TH3F*)gROOT->FindObject("hPropagRZvsP"))){
 870     h = new TH3F("hPropagRZvsP", Form("(r,z) vs P after AliESDtrack::PropagateTo(r=300.), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 871                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100,-350., 350., 100,0.,500., 10, 0.,10.);
 872   } else h->Reset();
 873   fHistos->AddAt(h, kPropagRZvsP);
 874
 875   Double_t etaBinLimits[101];
 876   for(Int_t i=0; i<101; i++) etaBinLimits[i] = -1.0 + i*2.0/100.;
 877   Double_t phiBinLimits[151];
 878   for(Int_t i=0; i<151; i++) phiBinLimits[i] = -1.1*TMath::Pi() + i*2.2*TMath::Pi()/150.;
 879   // (eta,detector phi,P) distribution of reference TPC positive tracks
 880   for(Int_t iCent=0; iCent<=5; ++iCent) {
 881     if(!(h = (TH3F*)gROOT->FindObject(Form("hTPCRefTracksPos_cent%d",iCent+1)))){
 882       h = new TH3F(Form("hTPCRefTracksPos_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TPC positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 883                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 884     } else h->Reset();
 885     fHistos->AddAt(h, kTPCRefTracksPos+iCent);
 886   }
 887
 888   // (eta,detector phi,P) distribution of reference TPC negative tracks
 889   for(Int_t iCent=0; iCent<=5; ++iCent) {
 890     if(!(h = (TH3F*)gROOT->FindObject(Form("hTPCRefTracksNeg_cent%d",iCent+1)))){
 891       h = new TH3F(Form("hTPCRefTracksNeg_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TPC negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 892                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 893     } else h->Reset();
 894     fHistos->AddAt(h, kTPCRefTracksNeg+iCent);
 895   }
 896
 897   // (eta,detector phi,P) distribution of reference TRD positive tracks
 898   for(Int_t iCent=0; iCent<=5; ++iCent) {
 899     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos_cent%d",iCent+1)))){
 900       h = new TH3F(Form("hTRDRefTracksPos_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 901                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 902     } else h->Reset();
 903     fHistos->AddAt(h, kTRDRefTracksPos+iCent);
 904   }
 905
 906   // (eta,detector phi,P) distribution of reference TRD negative tracks
 907   for(Int_t iCent=0; iCent<=5; ++iCent) {
 908     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg_cent%d",iCent+1)))){
 909       h = new TH3F(Form("hTRDRefTracksNeg_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 910                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 911     } else h->Reset();
 912     fHistos->AddAt(h, kTRDRefTracksNeg+iCent);
 913   }
 914
 915   // (eta,detector phi,P) distribution of reference TRD positive tracks with 4 tracklets
 916   for(Int_t iCent=0; iCent<=5; ++iCent) {
 917     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos4_cent%d",iCent+1)))){
 918       h = new TH3F(Form("hTRDRefTracksPos4_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 919                                                                  iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 920     } else h->Reset();
 921     fHistos->AddAt(h, kTRDRefTracksPos4+iCent);
 922   }
 923
 924   // (eta,detector phi,P) distribution of reference TRD positive tracks with 5 tracklets
 925   for(Int_t iCent=0; iCent<=5; ++iCent) {
 926     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos5_cent%d",iCent+1)))){
 927       h = new TH3F(Form("hTRDRefTracksPos5_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 928                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 929     } else h->Reset();
 930     fHistos->AddAt(h, kTRDRefTracksPos5+iCent);
 931   }
 932
 933   // (eta,detector phi,P) distribution of reference TRD positive tracks with 6 tracklets
 934   for(Int_t iCent=0; iCent<=5; ++iCent) {
 935     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos6_cent%d",iCent+1)))){
 936       h = new TH3F(Form("hTRDRefTracksPos6_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD positive reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 937                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 938     } else h->Reset();
 939     fHistos->AddAt(h, kTRDRefTracksPos6+iCent);
 940   }
 941
 942   // (eta,detector phi,P) distribution of reference TRD negative tracks with 4 tracklets
 943   for(Int_t iCent=0; iCent<=5; ++iCent) {
 944     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg4_cent%d",iCent+1)))){
 945       h = new TH3F(Form("hTRDRefTracksNeg4_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 946                                                                  iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 947     } else h->Reset();
 948     fHistos->AddAt(h, kTRDRefTracksNeg4+iCent);
 949   }
 950
 951   // (eta,detector phi,P) distribution of reference TRD negative tracks with 5 tracklets
 952   for(Int_t iCent=0; iCent<=5; ++iCent) {
 953     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg5_cent%d",iCent+1)))){
 954       h = new TH3F(Form("hTRDRefTracksNeg5_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 955                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 956     } else h->Reset();
 957     fHistos->AddAt(h, kTRDRefTracksNeg5+iCent);
 958   }
 959
 960   // (eta,detector phi,P) distribution of reference TRD negative tracks with 6 tracklets
 961   for(Int_t iCent=0; iCent<=5; ++iCent) {
 962     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg6_cent%d",iCent+1)))){
 963       h = new TH3F(Form("hTRDRefTracksNeg6_cent%d",iCent+1), Form("(#eta,detector #varphi,p) for TRD negative reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 964                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
 965     } else h->Reset();
 966     fHistos->AddAt(h, kTRDRefTracksNeg6+iCent);
 967   }
 968
 969
 970   // (eta,detector phi) profile of average number of TRD tracklets/track
 971   for(Int_t iCent=0; iCent<=5; ++iCent) {
 972     if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaPhiAvNtrkl_cent%d",iCent+1)))){
 973       h = new TProfile2D(Form("hTRDEtaPhiAvNtrkl_cent%d",iCent+1), Form("<Ntracklets/track> vs (#eta,detector #varphi) for TRD reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 974                                                    iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 150, -1.1*TMath::Pi(), 1.1*TMath::Pi());
 975     } else h->Reset();
 976     fHistos->AddAt(h, kTRDEtaPhiAvNtrkl+iCent);
 977   }
 978
 979   // (eta,delta phi) profile of average number of TRD tracklets/track
 980   for(Int_t iCent=0; iCent<=5; ++iCent) {
 981     if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaDeltaPhiAvNtrkl_cent%d",iCent+1)))){
 982       h = new TProfile2D(Form("hTRDEtaDeltaPhiAvNtrkl_cent%d",iCent+1), Form("<Ntracklets/track> vs (#eta, #Delta#varphi) for TRD reference tracks, centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 983                                                         iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 50, -0.4*TMath::Pi(), 0.4*TMath::Pi());
 984     } else h->Reset();
 985     fHistos->AddAt(h, kTRDEtaDeltaPhiAvNtrkl+iCent);
 986   }
 987
 988   // (eta, detector phi) profile of average tracklet Qtot from slices
 989   for(Int_t iCent=0; iCent<=5; ++iCent) {
 990     for(Int_t iLayer=0;iLayer<6;iLayer++) {
 991       if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaPhiAvQtot_Layer%d_cent%d",iLayer,iCent+1)))) {
 992         h = new TProfile2D(Form("hTRDEtaPhiAvQtot_Layer%d_cent%d",iLayer,iCent+1),
 993                            Form("<Q_{tot}> vs (#eta, detector #varphi) for TRD reference tracks (layer %d), centrality %d, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq1",
 994                                 iLayer, iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 150, -1.1*TMath::Pi(), 1.1*TMath::Pi());
 995       } else h->Reset();
 996       fHistos->AddAt(h, kTRDEtaPhiAvQtot+iCent*6+iLayer);
 997     }
 998   }
 999
1000   // create a CF container and add it to the list of histograms
1001   Int_t nbinsCf[kNTrdCfVariables];
1002   for(Int_t i=0;i<kNTrdCfVariables;++i) nbinsCf[i]=0;
1003   nbinsCf[kEventVtxZ]         =   12;
1004   nbinsCf[kEventMult]         =    5;
1005   nbinsCf[kEventBC]           = 3500;
1006   nbinsCf[kTrackTOFdeltaBC]   = 2001;
1007   nbinsCf[kTrackTOFBC]        =  201;
1008   nbinsCf[kTrackDCAxy]        =   26;
1009   nbinsCf[kTrackDCAz]         =  101;
1010   nbinsCf[kTrackCharge]       =    2;
1011   nbinsCf[kTrackPhi]          =  150;
1012   nbinsCf[kTrackEta]          =  100;
1013   nbinsCf[kTrackPt]           =   32;
1014   nbinsCf[kTrackP]            =   18;
1015   nbinsCf[kTrackTrdTracklets] =    7;
1016   nbinsCf[kTrackTrdClusters]  =  200;
1017   for(Int_t i=0;i<6;++i) nbinsCf[kTrackQtot+i] = 100;
1018   Double_t evVtxLims[2]      = {-12.,+12.};
1019   Double_t evMultLims[6]     = {0.0, 700., 1400., 2100., 2800., 3500.};
1020   Double_t evBCLims[2]       = {-0.5, +3499.5};
1021   Double_t trkTOFdeltaBClims[2] = {-1000.5, 1000.5};
1022   Double_t trkTOFBClims[2]   = {-100.5, 100.5};
1023   Double_t trkDCAxyLims[27]  = {-50.0, -40.0, -30.0, -25.0, -20.0,
1024                                 -15.0, -10.0,  -8.0,  -6.0,  -4.0,
1025                                  -3.0,  -2.0,  -1.0,   0.0,  +1.0,
1026                                  +2.0,  +3.0,  +4.0,  +6.0,  +8.0,
1027                                 +10.0, +15.0, +20.0, +25.0, +30.0,
1028                                 +40.0, +50.0};
1029   Double_t trkDCAzLims[2]    = {-50.5, +50.5};
1030   Double_t trkChargeLims[2]  = {-1.5, +1.5};
1031   Double_t trkPhiLims[2]     = {-1.1*TMath::Pi(), +1.1*TMath::Pi()};
1032   Double_t trkEtaLims[2]     = {-1.0, +1.0};
1033   Double_t trkPtLims[33]     = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
1034                                 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4,
1035                                 2.6, 2.8, 3.0, 3.4, 3.8, 4.2, 4.6, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
1036   Double_t trkPLims[19]      = {0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.7, 2.0,
1037                                 2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 9.0, 12.0};
1038   Double_t trkTrdNLims[2]    = {-0.5, 6.5};
1039   Double_t trkTrdNclsLims[2] = {-0.5, 199.5};
1040   Double_t trkQtotLims[2]    = {0.0, 20.};
1041   fCfContainer = new AliCFContainer("TrdCfContainer", "TRD ESD CF container", 3, kNTrdCfVariables, nbinsCf);
1042   fCfContainer->SetBinLimits(kEventVtxZ, evVtxLims[0], evVtxLims[1]);
1043   fCfContainer->SetBinLimits(kEventMult, evMultLims);
1044   fCfContainer->SetBinLimits(kEventBC, evBCLims[0], evBCLims[1]);
1045   fCfContainer->SetBinLimits(kTrackTOFdeltaBC, trkTOFdeltaBClims[0], trkTOFdeltaBClims[1]);
1046   fCfContainer->SetBinLimits(kTrackTOFBC, trkTOFBClims[0], trkTOFBClims[1]);
1047   fCfContainer->SetBinLimits(kTrackDCAxy, trkDCAxyLims);
1048   fCfContainer->SetBinLimits(kTrackDCAz, trkDCAzLims[0], trkDCAzLims[1]);
1049   fCfContainer->SetBinLimits(kTrackCharge, trkChargeLims[0], trkChargeLims[1]);
1050   fCfContainer->SetBinLimits(kTrackPhi, trkPhiLims[0], trkPhiLims[1]);
1051   fCfContainer->SetBinLimits(kTrackEta, trkEtaLims[0], trkEtaLims[1]);
1052   fCfContainer->SetBinLimits(kTrackPt, trkPtLims);
1053   fCfContainer->SetBinLimits(kTrackP, trkPLims);
1054   fCfContainer->SetBinLimits(kTrackTrdTracklets, trkTrdNLims[0], trkTrdNLims[1]);
1055   fCfContainer->SetBinLimits(kTrackTrdClusters, trkTrdNclsLims[0], trkTrdNclsLims[1]);
1056   for(Int_t i=0; i<6; ++i) fCfContainer->SetBinLimits(kTrackQtot+i, trkQtotLims[0], trkQtotLims[1]);
1057   fCfContainer->SetVarTitle(kEventVtxZ, "vtxZ");
1058   fCfContainer->SetVarTitle(kEventMult, "multiplicity");
1059   fCfContainer->SetVarTitle(kEventBC, "BC");
1060   fCfContainer->SetVarTitle(kTrackTOFdeltaBC, "TOFdeltaBC");
1061   fCfContainer->SetVarTitle(kTrackTOFBC, "TOFBC");
1062   fCfContainer->SetVarTitle(kTrackDCAxy, "DCAxy");
1063   fCfContainer->SetVarTitle(kTrackDCAz, "DCAz");
1064   fCfContainer->SetVarTitle(kTrackCharge, "charge");
1065   fCfContainer->SetVarTitle(kTrackPhi, "phi");
1066   fCfContainer->SetVarTitle(kTrackEta, "eta");
1067   fCfContainer->SetVarTitle(kTrackPt, "pt");
1068   fCfContainer->SetVarTitle(kTrackP, "P");
1069   fCfContainer->SetVarTitle(kTrackTrdTracklets, "tracklets");
1070   fCfContainer->SetVarTitle(kTrackTrdClusters, "clusters");
1071   for(Int_t i=0; i<6; ++i) fCfContainer->SetVarTitle(kTrackQtot+i, Form("Qtot%d",i));
1072
1073   fCfContainer->SetStepTitle(0, "TPC reference");
1074   fCfContainer->SetStepTitle(1, "TRD");
1075   fCfContainer->SetStepTitle(2, "TOF");
1076
1077   fHistos->AddAt(fCfContainer, kNhistos);
1078
1079   return fHistos;
1080 }
1081
1082 //____________________________________________________________________
1083 Bool_t AliTRDcheckESD::Load(const Char_t *file, const Char_t *dir, const Char_t *name)
1084 {
1085 // Load data from performance file
1086
1087   if(!TFile::Open(file)){
1088     AliWarning(Form("Couldn't open file %s.", file));
1089     return kFALSE;
1090   }
1091   if(dir){
1092     if(!gFile->cd(dir)){
1093       AliWarning(Form("Couldn't cd to %s in %s.", dir, file));
1094       return kFALSE;
1095     }
1096   }
1097   TObjArray *o(NULL);
1098   const Char_t *tn=(name ? name : GetName());
1099   if(!(o = (TObjArray*)gDirectory->Get(tn))){
1100     AliWarning(Form("Missing histogram container %s.", tn));
1101     return kFALSE;
1102   }
1103   fHistos = (TObjArray*)o->Clone(GetName());
1104   fCfContainer = (AliCFContainer*)fHistos->At(fHistos->GetEntries());
1105   gFile->Close();
1106   return kTRUE;
1107 }
1108
1109 //_______________________________________________________
1110 Bool_t AliTRDcheckESD::PutTrendValue(const Char_t *name, Double_t val)
1111 {
1112 // Dump trending value to default file
1113
1114   if(!fgFile){
1115     fgFile = fopen("TRD.Performance.txt", "at");
1116   }
1117   fprintf(fgFile, "%s_%s %f\n", GetName(), name, val);
1118   return kTRUE;
1119 }
1120
1121 //____________________________________________________________________
1122 void AliTRDcheckESD::Terminate(Option_t *)
1123 {
1124   // Steer post-processing
1125   if(!fHistos){
1126     fHistos = dynamic_cast<TObjArray *>(GetOutputData(1));
1127     if(!fHistos){
1128       AliError("Histogram container not found in output");
1129       return;
1130     }
1131   }
1132
1133   //  fNRefFigures = 15;
1134   //  return;
1135
1136   const Char_t *name[kNrefs] = {
1137     "Ncl", "Eff", "Eloss", "PtResDCA"
1138   };
1139
1140   TObjArray *arr(NULL); TGraph *g(NULL);
1141   if(!fResults){
1142     fResults = new TObjArray(kNrefs);
1143     fResults->SetOwner();
1144     fResults->SetName("results");
1145     for(Int_t iref(0); iref<kNrefs; iref++){
1146       fResults->AddAt(arr = new TObjArray(fgkNgraph[iref]), iref);
1147       arr->SetName(name[iref]);  arr->SetOwner();
1148       switch(iref+1){
1149       case kNCl:
1150         for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){
1151           arr->AddAt(g = new TGraphErrors(), ig);
1152           g->SetLineColor(ig+1);
1153           g->SetMarkerColor(ig+1);
1154           g->SetMarkerStyle(ig+20);
1155           g->SetName(Form("s%d", ig));
1156           switch(ig){
1157           case 0: g->SetTitle("ALL"); break;
1158           case 1: g->SetTitle("NEG"); break;
1159           case 2: g->SetTitle("POS"); break;
1160           default: g->SetTitle(AliPID::ParticleLatexName(ig-3)); break;
1161           };
1162         }
1163         break;
1164       case kTRDmom:
1165         for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){
1166           arr->AddAt(g = new TGraphAsymmErrors(), ig);
1167           g->SetLineColor(ig+1);
1168           g->SetMarkerColor(ig+1);
1169           g->SetMarkerStyle(ig+20);
1170         }
1171         break;
1172       case kPtRes:
1173         for(Int_t idx(0); idx<AliPID::kSPECIES; idx++){
1174           Int_t ig(2*idx);
1175           arr->AddAt(g = new TGraphErrors(), ig);
1176           g->SetLineColor(kRed-idx);
1177           g->SetMarkerColor(kRed-idx);
1178           g->SetMarkerStyle(20+idx);
1179           g->SetNameTitle(Form("s%d", ig), Form("res %s", AliPID::ParticleLatexName(idx)));
1180           arr->AddAt(g = new TGraphErrors(), ig+1);
1181           g->SetLineColor(kBlue-idx);
1182           g->SetMarkerColor(kBlue-idx);
1183           g->SetMarkerStyle(20+idx);
1184           g->SetNameTitle(Form("m%d", ig+1), Form("sys %s", AliPID::ParticleLatexName(idx)));
1185
1186           ig+=10;
1187           arr->AddAt(g = new TGraphErrors(), ig);
1188           g->SetLineColor(kRed-idx);
1189           g->SetMarkerColor(kRed-idx);
1190           g->SetMarkerStyle(20+idx);
1191           g->SetNameTitle(Form("s%d", ig), Form("sigma %s", AliPID::ParticleLatexName(idx)));
1192           arr->AddAt(g = new TGraphErrors(), ig+1);
1193           g->SetLineColor(kBlue-idx);
1194           g->SetMarkerColor(kBlue-idx);
1195           g->SetMarkerStyle(20+idx);
1196           g->SetNameTitle(Form("m%d", ig+1), Form("mean %s", AliPID::ParticleLatexName(idx)));
1197         }
1198         break;
1199       default:
1200         for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){
1201           arr->AddAt(g = new TGraphErrors(), ig);
1202           g->SetLineColor(ig+1);
1203           g->SetMarkerColor(ig+1);
1204           g->SetMarkerStyle(ig+20);
1205         }
1206         break;
1207       }
1208     }
1209   }
1210   TH1 *h1[2] = {NULL, NULL};
1211   TH2I *h2(NULL);
1212   TAxis *ax(NULL);
1213
1214   // No of clusters
1215   if(!(h2 = (TH2I*)fHistos->At(kNCl))) return;
1216   ax = h2->GetXaxis();
1217   arr = (TObjArray*)fResults->At(kNCl);
1218
1219   // All tracks
1220   h1[0] = h2->ProjectionX("Ncl_px");
1221   TGraphErrors *ge=(TGraphErrors*)arr->At(0);
1222   for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1223     ge->SetPoint(ib-2, ax->GetBinCenter(ib), h1[0]->GetBinContent(ib));
1224   }
1225
1226   // All charged tracks
1227   TH1 *hNclCh[2] = {(TH1D*)h1[0]->Clone("NEG"), (TH1D*)h1[0]->Clone("POS")};
1228   hNclCh[0]->Reset();hNclCh[1]->Reset();
1229   for(Int_t is(1); is<=AliPID::kSPECIES; is++){
1230     hNclCh[0]->Add(h2->ProjectionX("Ncl_px", 2*is-1, 2*is-1)); // neg
1231     hNclCh[1]->Add(h2->ProjectionX("Ncl_px", 2*is, 2*is));     // pos
1232   }
1233   if(Int_t(hNclCh[0]->GetEntries())){
1234     ge=(TGraphErrors*)arr->At(1);
1235     for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1236       ge->SetPoint(ib-2, ax->GetBinCenter(ib), hNclCh[0]->GetBinContent(ib));
1237     }
1238   }
1239
1240   if(Int_t(hNclCh[1]->GetEntries())){
1241     ge=(TGraphErrors*)arr->At(2);
1242     for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1243       ge->SetPoint(ib-2, ax->GetBinCenter(ib), hNclCh[1]->GetBinContent(ib));
1244     }
1245   }
1246   // Species wise
1247   for(Int_t is(1); is<=AliPID::kSPECIES; is++){
1248     h1[0] = h2->ProjectionX("Ncl_px", 2*is-1, 2*is);
1249     if(!Int_t(h1[0]->GetEntries())) continue;
1250     ge=(TGraphErrors*)arr->At(2+is);
1251     for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1252       ge->SetPoint(ib-2, ax->GetBinCenter(ib), h1[0]->GetBinContent(ib));
1253     }
1254   }
1255
1256   fNRefFigures = 1;
1257
1258   // EFFICIENCY
1259   // geometrical efficiency
1260   if(!(h2 = (TH2I*)fHistos->At(kTRDstat))) return;
1261   arr = (TObjArray*)fResults->At(kTRDstat-1);
1262   h1[0] = h2->ProjectionX("checkESDx0", kTPCout, kTPCout);
1263   h1[1] = h2->ProjectionX("checkESDx1", kTRDin, kTRDin);
1264   Process(h1, (TGraphErrors*)arr->At(0));
1265   delete h1[0];delete h1[1];
1266   // tracking efficiency
1267   h1[0] = h2->ProjectionX("checkESDx0", kTRDin, kTRDin);
1268   h1[1] = h2->ProjectionX("checkESDx1", kTRDout, kTRDout);
1269   Process(h1, (TGraphErrors*)arr->At(1));
1270   delete h1[1];
1271   // PID efficiency
1272   h1[1] = h2->ProjectionX("checkESDx1", kTRDpid, kTRDpid);
1273   Process(h1, (TGraphErrors*)arr->At(2));
1274   delete h1[1];
1275   // Refit efficiency
1276   h1[1] = h2->ProjectionX("checkESDx1", kTRDref, kTRDref);
1277   Process(h1, (TGraphErrors*)arr->At(3));
1278   delete h1[1];
1279   fNRefFigures++;
1280
1281   // ENERGY LOSS
1282   if(!(h2 = dynamic_cast<TH2I*>(fHistos->At(kTRDmom)))) return;
1283   arr = (TObjArray*)fResults->At(kTRDmom-1);
1284   TGraphAsymmErrors *g06 = (TGraphAsymmErrors*)arr->At(0), *g09 = (TGraphAsymmErrors*)arr->At(1);
1285   ax=h2->GetXaxis();
1286   const Int_t nq(4);
1287   const Double_t xq[nq] = {0.05, 0.2, 0.8, 0.95};
1288   Double_t yq[nq];
1289   for(Int_t ily=6; ily--;){
1290     h1[0] = h2->ProjectionX("checkESDp0", ily+1, ily+1);
1291     h1[0]->GetQuantiles(nq,yq,xq);
1292     g06->SetPoint(ily, Float_t(ily), ax->GetBinCenter(h1[0]->GetMaximumBin()));
1293     g06->SetPointError(ily, 0., 0., TMath::Abs(yq[0]), yq[3]);
1294     g09->SetPoint(ily, Float_t(ily), h1[0]->GetMean());
1295     g09->SetPointError(ily, 0., 0., TMath::Abs(yq[1]), yq[2]);
1296
1297     //printf(" max[%f] mean[%f] q[%f %f %f %f]\n", ax->GetBinCenter(h1[0]->GetMaximumBin()), h1[0]->GetMean(), yq[0], yq[1], yq[2], yq[3]);
1298     delete h1[0];
1299   }
1300   fNRefFigures++;
1301 //  if(!HasMC()) return;
1302
1303   // Pt RESOLUTION @ DCA
1304   TH3S* h3(NULL); TGraphErrors *gg[2] = {NULL,NULL};
1305   if(!(h3 = dynamic_cast<TH3S*>(fHistos->At(kPtRes)))) return;
1306   arr = (TObjArray*)fResults->At(kPtRes-1);
1307   TAxis *az(h3->GetZaxis());
1308   for(Int_t i(0); i<AliPID::kSPECIES; i++){
1309     Int_t idx(2*i);
1310     az->SetRange(idx+1, idx+2);
1311     gg[1] = (TGraphErrors*)arr->At(idx);
1312     gg[0] = (TGraphErrors*)arr->At(idx+1);
1313     Process2D((TH2*)h3->Project3D("yx"), gg);
1314
1315     idx+=10;
1316     az->SetRange(idx+1, idx+2);
1317     gg[1] = (TGraphErrors*)arr->At(idx);
1318     gg[0] = (TGraphErrors*)arr->At(idx+1);
1319     Process2D((TH2*)h3->Project3D("yx"), gg);
1320   }
1321   fNRefFigures++;
1322
1323   fNRefFigures++;
1324   // 3x3 tracking summary canvases for every centrality class
1325   fNRefFigures++;
1326   // 3x3 PID summary canvases for every centrality class
1327   fNRefFigures++;
1328   // 3x3 for centrality dependent pictures
1329   fNRefFigures++;
1330
1331   //DoTrending();
1332 }
1333
1334 //____________________________________________________________________
1335 Int_t AliTRDcheckESD::Pdg2Idx(Int_t pdg) const
1336 {
1337   //
1338   // Helper function converting PDG code into AliPID index
1339   //
1340   switch(pdg){
1341   case kElectron:
1342   case kPositron: return AliPID::kElectron;
1343   case kMuonPlus:
1344   case kMuonMinus: return AliPID::kMuon;
1345   case kPiPlus:
1346   case kPiMinus: return AliPID::kPion;
1347   case kKPlus:
1348   case kKMinus: return AliPID::kKaon;
1349   case kProton:
1350   case kProtonBar: return AliPID::kProton;
1351   }
1352   return -1;
1353 }
1354
1355 //____________________________________________________________________
1356 void AliTRDcheckESD::Process(TH1 **h1, TGraphErrors *g)
1357 {
1358 // Generic function to process one reference plot
1359
1360   Int_t n1 = 0, n2 = 0, ip=0;
1361   Double_t eff = 0.;
1362
1363   TAxis *ax = h1[0]->GetXaxis();
1364   for(Int_t ib=1; ib<=ax->GetNbins(); ib++){
1365     if(!(n1 = (Int_t)h1[0]->GetBinContent(ib))) continue;
1366     n2 = (Int_t)h1[1]->GetBinContent(ib);
1367     eff = n2/Float_t(n1);
1368
1369     ip=g->GetN();
1370     g->SetPoint(ip, ax->GetBinCenter(ib), eff);
1371     g->SetPointError(ip, 0., n2 ? eff*TMath::Sqrt(1./n1+1./n2) : 0.);
1372   }
1373 }
1374 //________________________________________________________
1375 void AliTRDcheckESD::Process2D(TH2 * const h2, TGraphErrors **g)
1376 {
1377   //
1378   // Do the processing
1379   //
1380
1381   Int_t n = 0;
1382   if((n=g[0]->GetN())) for(;n--;) g[0]->RemovePoint(n);
1383   if((n=g[1]->GetN())) for(;n--;) g[1]->RemovePoint(n);
1384   TF1 f("fg", "gaus", -3.,3.);
1385   for(Int_t ibin = 1; ibin <= h2->GetNbinsX(); ibin++){
1386     Double_t x = h2->GetXaxis()->GetBinCenter(ibin);
1387     TH1D *h = h2->ProjectionY("py", ibin, ibin);
1388     if(h->GetEntries()<100) continue;
1389     //AdjustF1(h, f);
1390
1391     h->Fit(&f, "QN");
1392     Int_t ip = g[0]->GetN();
1393     g[0]->SetPoint(ip, x, f.GetParameter(1));
1394     g[0]->SetPointError(ip, 0., f.GetParError(1));
1395     g[1]->SetPoint(ip, x, f.GetParameter(2));
1396     g[1]->SetPointError(ip, 0., f.GetParError(2));
1397   }
1398   return;
1399 }
1400 //____________________________________________________________________
1401 void AliTRDcheckESD::PrintStatus(ULong_t status)
1402 {
1403 // Dump track status to stdout
1404
1405   printf("ITS[i(%d) o(%d) r(%d)] TPC[i(%d) o(%d) r(%d) p(%d)] TRD[i(%d) o(%d) r(%d) p(%d) s(%d)] HMPID[o(%d) p(%d)]\n"
1406     ,Bool_t(status & AliESDtrack::kITSin)
1407     ,Bool_t(status & AliESDtrack::kITSout)
1408     ,Bool_t(status & AliESDtrack::kITSrefit)
1409     ,Bool_t(status & AliESDtrack::kTPCin)
1410     ,Bool_t(status & AliESDtrack::kTPCout)
1411     ,Bool_t(status & AliESDtrack::kTPCrefit)
1412     ,Bool_t(status & AliESDtrack::kTPCpid)
1413     ,Bool_t(status & AliESDtrack::kTRDin)
1414     ,Bool_t(status & AliESDtrack::kTRDout)
1415     ,Bool_t(status & AliESDtrack::kTRDrefit)
1416     ,Bool_t(status & AliESDtrack::kTRDpid)
1417     ,Bool_t(status & AliESDtrack::kTRDStop)
1418     ,Bool_t(status & AliESDtrack::kHMPIDout)
1419     ,Bool_t(status & AliESDtrack::kHMPIDpid)
1420   );
1421 }
1422
1423 //____________________________________________________________________
1424 TH1D* AliTRDcheckESD::Proj2D(TH2* hist) {
1425   //
1426   // project the PH vs Slice 2D-histo into a 1D histo
1427   //
1428   /*TH1D* hProjection = new TH1F("hProjection","", hist->GetXaxis()->GetXbins()->GetSize()-1,
1429                                hist->GetXaxis()->GetXbins()->GetArray());*/
1430   TH1D* hProjection = (TH1D*)hist->ProjectionX(Form("hProjection_%f", gRandom->Rndm()));
1431   hProjection->Reset();
1432   //cout << "Proj2D: nbins = " << hist->GetXaxis()->GetXbins()->GetSize()-1 << endl;
1433   TF1* fitLandau = new TF1("landauFunc","landau",0.,2000.);
1434   TH1D *hD;
1435   for(Int_t iBin=1;iBin<=hist->GetXaxis()->GetNbins();iBin++) {
1436     if(gROOT->FindObject("projection"))
1437       delete gROOT->FindObject("projection");
1438     hD = (TH1D*)hist->ProjectionY("projection",iBin,iBin);
1439     hD->Rebin(4);
1440     if(hD->Integral()>10) {
1441       fitLandau->SetParameter(1, hD->GetBinCenter(hD->GetMaximumBin()));
1442       fitLandau->SetParLimits(1, 0.2*hD->GetBinCenter(hD->GetMaximumBin()), 3.0*hD->GetBinCenter(hD->GetMaximumBin()));
1443       fitLandau->SetParameter(0, 1000.);
1444       fitLandau->SetParLimits(0, 1., 10000000.);
1445       fitLandau->SetParameter(2, 0.5*hD->GetBinCenter(hD->GetMaximumBin()));
1446       fitLandau->SetParLimits(2, 0.01*hD->GetBinCenter(hD->GetMaximumBin()), 1.0*hD->GetBinCenter(hD->GetMaximumBin()));
1447       hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
1448       hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
1449       hProjection->SetBinContent(iBin, fitLandau->GetParameter(1));
1450       hProjection->SetBinError(iBin, fitLandau->GetParameter(2));
1451     }
1452     else{
1453       hProjection->SetBinContent(iBin, 0);
1454       hProjection->SetBinError(iBin, 0);
1455     }
1456   }
1457   return hProjection;
1458 }
1459
1460 //____________________________________________________________________
1461 TH2F* AliTRDcheckESD::Proj3D(TH3* hist, TH2* accMap, Int_t zbinLow, Int_t zbinHigh, Float_t &entries) {
1462   //
1463   //  Project a 3D histogram to a 2D histogram in the Z axis interval [zbinLow,zbinHigh]
1464   //  Return the 2D histogram and also the number of entries into this projection (entries)
1465
1466   Int_t nBinsX = hist->GetXaxis()->GetNbins();   // X and Y axis bins are assumed to be all equal
1467   Float_t minX = hist->GetXaxis()->GetXmin();
1468   Float_t maxX = hist->GetXaxis()->GetXmax();
1469   Int_t nBinsY = hist->GetYaxis()->GetNbins();
1470   Float_t minY = hist->GetYaxis()->GetXmin();
1471   Float_t maxY = hist->GetYaxis()->GetXmax();
1472   Int_t nBinsZ = hist->GetZaxis()->GetNbins();  // Z axis bins (pt) might have different widths
1473
1474   TH2F* projHisto = (TH2F*)gROOT->FindObject("projHisto");
1475   if(projHisto)
1476     projHisto->Reset();
1477   else
1478     projHisto = new TH2F("projHisto", "projection", nBinsX, minX, maxX, nBinsY, minY, maxY);
1479
1480   for(Int_t iZ=1; iZ<=nBinsZ; iZ++) {
1481     if(iZ<zbinLow) continue;
1482     if(iZ>zbinHigh) continue;
1483     for(Int_t iX=1; iX<=nBinsX; iX++) {
1484       for(Int_t iY=1; iY<=nBinsY; iY++) {
1485         if(accMap) {
1486           if(accMap->GetBinContent(iX,iY)>0.1)
1487             projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
1488         }
1489         else    // no acc. cut
1490           projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
1491         // count only the entries which are inside the acceptance map
1492         if(accMap) {
1493           if(accMap->GetBinContent(iX,iY)>0.1)
1494             entries+=hist->GetBinContent(iX,iY,iZ);
1495         }
1496         else    // no acc. cut
1497           entries+=hist->GetBinContent(iX,iY,iZ);
1498       }
1499     }
1500   }
1501   return projHisto;
1502 }
1503
1504 //____________________________________________________________________
1505 void AliTRDcheckESD::CheckActiveSM(TH1D* phiProj, Bool_t activeSM[18]) {
1506   //
1507   // Check the active super-modules
1508   //
1509   Double_t entries[18] = {0.0};
1510   Double_t smPhiLimits[19];
1511   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
1512   for(Int_t phiBin=1; phiBin<=phiProj->GetXaxis()->GetNbins(); ++phiBin) {
1513     Double_t phi = phiProj->GetBinCenter(phiBin);
1514     Int_t sm = -1;
1515     for(Int_t ism=0; ism<18; ++ism)
1516       if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1]) sm = ism;
1517     if(sm==-1) continue;
1518     entries[sm] += phiProj->GetBinContent(phiBin);
1519   }
1520   Double_t avEntries = Double_t(phiProj->Integral())/18.0;
1521   for(Int_t ism=0; ism<18; ++ism)
1522     if(entries[ism]>0.5*avEntries) activeSM[ism] = kTRUE;
1523 }
1524
1525 //____________________________________________________________________
1526 TH1F* AliTRDcheckESD::EfficiencyTRD(TH3* tpc3D, TH3* trd3D, Bool_t useAcceptance) {
1527   //
1528   // Calculate the TRD-TPC matching efficiency as function of pt
1529   //
1530
1531   if(!tpc3D || !trd3D) return NULL;
1532   Int_t nBinsZ = trd3D->GetZaxis()->GetNbins();
1533   // project everything on the eta-phi map to obtain an acceptance map
1534   Float_t nada = 0.;
1535   TH2F *trdAcc = (useAcceptance ? (TH2F*)Proj3D(trd3D, 0x0, 1, nBinsZ, nada)->Clone(Form("trdAcc%f", gRandom->Rndm())) : 0x0);
1536   TH1D *phiProj = (trdAcc ? trdAcc->ProjectionY(Form("phiProj%f", gRandom->Rndm())) : 0x0);
1537
1538   // prepare the acceptance map
1539   Bool_t activeSM[18] = {kFALSE};
1540   Double_t smPhiLimits[19];
1541   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
1542   if(phiProj) {
1543     CheckActiveSM(phiProj, activeSM);   // get the active SMs
1544     trdAcc->Reset();
1545     // Put 1 entry in every bin which belongs to an active SM
1546     for(Int_t iY=1; iY<=trdAcc->GetYaxis()->GetNbins(); ++iY) {
1547       Double_t phi = trdAcc->GetYaxis()->GetBinCenter(iY);
1548       Bool_t isActive = kFALSE;
1549       for(Int_t ism=0; ism<18; ++ism) {
1550         if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) {
1551           isActive = kTRUE;
1552         }
1553       }
1554       if(!isActive) continue;
1555       for(Int_t iX=1; iX<=trdAcc->GetXaxis()->GetNbins(); ++iX)
1556         if(trdAcc->GetXaxis()->GetBinCenter(iX)>=-0.85 && trdAcc->GetXaxis()->GetBinCenter(iX)<=0.85) trdAcc->SetBinContent(iX, iY, 1.0);
1557     }  // end for over Y(phi) bins
1558   }  // end if phiProj
1559
1560   // get the bin limits from the Z axis of 3D histos
1561   Float_t *ptBinLimits = new Float_t[nBinsZ+1];
1562   for(Int_t i=1; i<=nBinsZ; i++) {
1563     ptBinLimits[i-1] = trd3D->GetZaxis()->GetBinLowEdge(i);
1564   }
1565   ptBinLimits[nBinsZ] = trd3D->GetZaxis()->GetBinUpEdge(nBinsZ);
1566
1567   TH1F *efficiency = new TH1F(Form("eff%d", Int_t(1000000.0*gRandom->Rndm())), "TRD-TPC matching efficiency", nBinsZ, ptBinLimits);
1568
1569   // loop over Z bins
1570   Bool_t effGood = kFALSE;
1571   for(Int_t i=1; i<=nBinsZ; i++) {
1572     Float_t tpcEntries = 0.0; Float_t trdEntries = 0.0;
1573     Proj3D(tpc3D, trdAcc, i, i, tpcEntries);
1574     Proj3D(trd3D, trdAcc, i, i, trdEntries);
1575     Float_t ratio = 0;
1576     if(tpcEntries>0) ratio = trdEntries/tpcEntries;
1577     Float_t error = 0;
1578     if(tpcEntries>0 && trdEntries>0 && (tpcEntries-trdEntries)>=0.0)
1579       error = TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries);
1580     if(ratio>0.001) {
1581       efficiency->SetBinContent(i,ratio);
1582       efficiency->SetBinError(i,error);
1583       effGood = kTRUE;
1584     }
1585   }     // end loop over Z bins
1586   if(!effGood) return 0x0;
1587
1588   return efficiency;
1589 }
1590
1591 //__________________________________________________________________________________________________
1592 void AliTRDcheckESD::PlotCentSummaryFromCF(Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc) {
1593   //
1594   // Make the centrality summary figure from the CF container
1595   //
1596   if(!fCfContainer) return;
1597
1598   trendValues = trendValues;
1599
1600   TLatex* lat=new TLatex();
1601   lat->SetTextSize(0.06);
1602   lat->SetTextColor(2);
1603
1604   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1605   gPad->Divide(3,3,0.,0.);
1606   TList* l=gPad->GetListOfPrimitives();
1607   TVirtualPad* pad=0x0;
1608
1609   fCfContainer->SetRangeUser(kTrackDCAxy, -0.999, +0.999);
1610   fCfContainer->SetRangeUser(kTrackDCAz, -3.0, +3.0);
1611   if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, 0.0, 0.0);
1612
1613   // find all the isolated bunch crossings with entries
1614   Bool_t isIsolated[3500];
1615   TH1D* tempTH1D = (TH1D*)fCfContainer->Project(0, kEventBC);
1616   FindIsolatedBCs(tempTH1D, isIsolated); delete tempTH1D;
1617   Int_t nIsolatedBC = 0;
1618   for(Int_t ibc=0; ibc<3500; ++ibc)
1619     if(isIsolated[ibc]) nIsolatedBC++;
1620
1621   if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
1622   TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.3);
1623   rangeEffPt->SetStats(kFALSE);
1624   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
1625   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
1626
1627   Int_t padsForEffs[5] = {0,3,6,1,4};
1628   for(Int_t iCent=1; iCent<6; ++iCent) {
1629     pad = ((TVirtualPad*)l->At(padsForEffs[iCent-1])); pad->cd();
1630     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1631     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1632     rangeEffPt->Draw();
1633     TLine line;
1634     line.SetLineStyle(2);
1635     line.SetLineWidth(2);
1636     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
1637     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
1638
1639     fCfContainer->SetRangeUser(kEventMult, Double_t(iCent), Double_t(iCent), kTRUE);
1640     fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0);        // positive charges
1641     fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
1642
1643     TH3D* h3PosTPC = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
1644     if(h3PosTPC->GetEntries()<10) {
1645       delete h3PosTPC;
1646       continue;
1647     }
1648     TH3D* h3PosTRDall = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1649     fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);        // >= 4 TRD tracklets
1650     TH3D* h3PosTRDtrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1651     fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);        // >= 5 TRD tracklets
1652     TH3D* h3PosTRDtrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1653     fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);        // >= 6 TRD tracklets
1654     TH3D* h3PosTRDtrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1655
1656     fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0);        // negative charges
1657     fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);    // >= 0 TRD tracklets
1658     TH3D* h3NegTPC = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
1659     TH3D* h3NegTRDall = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1660     fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);        // 4 TRD tracklets
1661     TH3D* h3NegTRDtrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1662     fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);        // 5 TRD tracklets
1663     TH3D* h3NegTRDtrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1664     fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);        // 6 TRD tracklets
1665     TH3D* h3NegTRDtrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1666
1667     TH1F* hEffPosAll = EfficiencyTRD(h3PosTPC, h3PosTRDall, kTRUE);
1668     TH1F* hEffPosTrk4 = EfficiencyTRD(h3PosTPC, h3PosTRDtrk4, kTRUE);
1669     TH1F* hEffPosTrk5 = EfficiencyTRD(h3PosTPC, h3PosTRDtrk5, kTRUE);
1670     TH1F* hEffPosTrk6 = EfficiencyTRD(h3PosTPC, h3PosTRDtrk6, kTRUE);
1671     TH1F* hEffNegAll = EfficiencyTRD(h3NegTPC, h3NegTRDall, kTRUE);
1672     TH1F* hEffNegTrk4 = EfficiencyTRD(h3NegTPC, h3NegTRDtrk4, kTRUE);
1673     TH1F* hEffNegTrk5 = EfficiencyTRD(h3NegTPC, h3NegTRDtrk5, kTRUE);
1674     TH1F* hEffNegTrk6 = EfficiencyTRD(h3NegTPC, h3NegTRDtrk6, kTRUE);
1675
1676     delete h3PosTPC; delete h3NegTPC;
1677     delete h3PosTRDall; delete h3PosTRDtrk4; delete h3PosTRDtrk5; delete h3PosTRDtrk6;
1678     delete h3NegTRDall; delete h3NegTRDtrk4; delete h3NegTRDtrk5; delete h3NegTRDtrk6;
1679
1680     // get matching efficiencies for isolated bunches
1681     TH3D* h3TPCrefPos_IsolatedBC=0x0; TH3D* h3TPCrefNeg_IsolatedBC=0x0;
1682     TH3D* h3TRDrefPosAll_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk4_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk5_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk6_IsolatedBC=0x0;
1683     TH3D* h3TRDrefNegAll_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk4_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk5_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk6_IsolatedBC=0x0;
1684     for(Int_t ibc=0; ibc<3500; ++ibc) {
1685       if(!isIsolated[ibc]) continue;
1686       fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
1687
1688       TH3D* tempTH3D;
1689       fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
1690       fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0);    // positive charges
1691       tempTH3D = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
1692       if(!h3TPCrefPos_IsolatedBC) h3TPCrefPos_IsolatedBC = tempTH3D;
1693       else {h3TPCrefPos_IsolatedBC->Add(tempTH3D); delete tempTH3D;};
1694       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1695       if(!h3TRDrefPosAll_IsolatedBC) h3TRDrefPosAll_IsolatedBC = tempTH3D;
1696       else {h3TRDrefPosAll_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1697       fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);
1698       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1699       if(!h3TRDrefPosTrk4_IsolatedBC) h3TRDrefPosTrk4_IsolatedBC = tempTH3D;
1700       else {h3TRDrefPosTrk4_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1701       fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);
1702       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1703       if(!h3TRDrefPosTrk5_IsolatedBC) h3TRDrefPosTrk5_IsolatedBC = tempTH3D;
1704       else {h3TRDrefPosTrk5_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1705       fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);
1706       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1707       if(!h3TRDrefPosTrk6_IsolatedBC) h3TRDrefPosTrk6_IsolatedBC = tempTH3D;
1708       else {h3TRDrefPosTrk6_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1709
1710       fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0);   // negative charges
1711       fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
1712       tempTH3D = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
1713       if(!h3TPCrefNeg_IsolatedBC) h3TPCrefNeg_IsolatedBC = tempTH3D;
1714       else {h3TPCrefNeg_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1715       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1716       if(!h3TRDrefNegAll_IsolatedBC) h3TRDrefNegAll_IsolatedBC = tempTH3D;
1717       else {h3TRDrefNegAll_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1718       fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);
1719       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1720       if(!h3TRDrefNegTrk4_IsolatedBC) h3TRDrefNegTrk4_IsolatedBC = tempTH3D;
1721       else {h3TRDrefNegTrk4_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1722       fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);
1723       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1724       if(!h3TRDrefNegTrk5_IsolatedBC) h3TRDrefNegTrk5_IsolatedBC = tempTH3D;
1725       else {h3TRDrefNegTrk5_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1726       fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);
1727       tempTH3D = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
1728       if(!h3TRDrefNegTrk6_IsolatedBC) h3TRDrefNegTrk6_IsolatedBC = tempTH3D;
1729       else {h3TRDrefNegTrk6_IsolatedBC->Add(tempTH3D); delete tempTH3D;}
1730     }
1731     fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);
1732     fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0);
1733     fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
1734
1735     TH1F* hEffPosAll_IsolatedBC  = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosAll_IsolatedBC, kTRUE);
1736     TH1F* hEffPosTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk4_IsolatedBC, kTRUE);
1737     TH1F* hEffPosTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk5_IsolatedBC, kTRUE);
1738     TH1F* hEffPosTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk6_IsolatedBC, kTRUE);
1739     TH1F* hEffNegAll_IsolatedBC  = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegAll_IsolatedBC, kTRUE);
1740     TH1F* hEffNegTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk4_IsolatedBC, kTRUE);
1741     TH1F* hEffNegTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk5_IsolatedBC, kTRUE);
1742     TH1F* hEffNegTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk6_IsolatedBC, kTRUE);
1743
1744     if(h3TPCrefPos_IsolatedBC) delete h3TPCrefPos_IsolatedBC;
1745     if(h3TPCrefNeg_IsolatedBC) delete h3TPCrefNeg_IsolatedBC;
1746     if(h3TRDrefPosAll_IsolatedBC) delete h3TRDrefPosAll_IsolatedBC;
1747     if(h3TRDrefPosTrk4_IsolatedBC) delete h3TRDrefPosTrk4_IsolatedBC;
1748     if(h3TRDrefPosTrk5_IsolatedBC) delete h3TRDrefPosTrk5_IsolatedBC;
1749     if(h3TRDrefPosTrk6_IsolatedBC) delete h3TRDrefPosTrk6_IsolatedBC;
1750     if(h3TRDrefNegAll_IsolatedBC) delete h3TRDrefNegAll_IsolatedBC;
1751     if(h3TRDrefNegTrk4_IsolatedBC) delete h3TRDrefNegTrk4_IsolatedBC;
1752     if(h3TRDrefNegTrk5_IsolatedBC) delete h3TRDrefNegTrk5_IsolatedBC;
1753     if(h3TRDrefNegTrk6_IsolatedBC) delete h3TRDrefNegTrk6_IsolatedBC;
1754
1755     if(!useIsolatedBC) {
1756       SetStyle(hEffPosAll,  1, kRed, 1, 24, kRed, 1);
1757       SetStyle(hEffPosTrk4, 1, kRed, 1, 25, kRed, 1);
1758       SetStyle(hEffPosTrk5, 1, kRed, 1, 26, kRed, 1);
1759       SetStyle(hEffPosTrk6, 1, kRed, 1, 27, kRed, 1);
1760       SetStyle(hEffNegAll,  1, kBlue, 1, 24, kBlue, 1);
1761       SetStyle(hEffNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
1762       SetStyle(hEffNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
1763       SetStyle(hEffNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
1764       hEffPosAll->Draw("same");
1765       hEffNegAll->Draw("same");
1766       hEffPosTrk4->Draw("same");
1767       hEffNegTrk4->Draw("same");
1768       hEffPosTrk5->Draw("same");
1769       hEffNegTrk5->Draw("same");
1770       hEffPosTrk6->Draw("same");
1771       hEffNegTrk6->Draw("same");
1772     }
1773     else {
1774       if(nIsolatedBC>0) {
1775         SetStyle(hEffPosAll_IsolatedBC,  1, kRed, 1, 24, kRed, 1);
1776         SetStyle(hEffPosTrk4_IsolatedBC, 1, kRed, 1, 25, kRed, 1);
1777         SetStyle(hEffPosTrk5_IsolatedBC, 1, kRed, 1, 26, kRed, 1);
1778         SetStyle(hEffPosTrk6_IsolatedBC, 1, kRed, 1, 27, kRed, 1);
1779         SetStyle(hEffNegAll_IsolatedBC,  1, kBlue, 1, 24, kBlue, 1);
1780         SetStyle(hEffNegTrk4_IsolatedBC, 1, kBlue, 1, 25, kBlue, 1);
1781         SetStyle(hEffNegTrk5_IsolatedBC, 1, kBlue, 1, 26, kBlue, 1);
1782         SetStyle(hEffNegTrk6_IsolatedBC, 1, kBlue, 1, 27, kBlue, 1);
1783         hEffPosAll_IsolatedBC->Draw("same");
1784         hEffNegAll_IsolatedBC->Draw("same");
1785         hEffPosTrk4_IsolatedBC->Draw("same");
1786         hEffNegTrk4_IsolatedBC->Draw("same");
1787         hEffPosTrk5_IsolatedBC->Draw("same");
1788         hEffNegTrk5_IsolatedBC->Draw("same");
1789         hEffPosTrk6_IsolatedBC->Draw("same");
1790         hEffNegTrk6_IsolatedBC->Draw("same");
1791       }
1792     }
1793
1794     TLegend* leg=new TLegend(0.18, 0.7, 0.77, 0.89);
1795     if(iCent==1) {
1796       leg->SetFillColor(0);
1797       leg->SetNColumns(2);
1798       leg->SetMargin(0.1);
1799       leg->SetBorderSize(0);
1800       if(useIsolatedBC) {
1801         leg->SetHeader("Isolated bunch crossings");
1802         if(nIsolatedBC) {
1803           leg->AddEntry(hEffPosAll_IsolatedBC,  "pos. (#geq 1 tracklet)", "p");
1804           leg->AddEntry(hEffNegAll_IsolatedBC,  "neg. (#geq 1 tracklet)", "p");
1805           leg->AddEntry(hEffPosTrk4_IsolatedBC, "pos. (4 tracklets)", "p");
1806           leg->AddEntry(hEffNegTrk4_IsolatedBC, "neg. (4 tracklets)", "p");
1807           leg->AddEntry(hEffPosTrk5_IsolatedBC, "pos. (5 tracklets)", "p");
1808           leg->AddEntry(hEffNegTrk5_IsolatedBC, "neg. (5 tracklets)", "p");
1809           leg->AddEntry(hEffPosTrk6_IsolatedBC, "pos. (6 tracklets)", "p");
1810           leg->AddEntry(hEffNegTrk6_IsolatedBC, "neg. (6 tracklets)", "p");
1811         }
1812       }
1813       else {
1814         leg->SetHeader("All bunch crossings");
1815         leg->AddEntry(hEffPosAll,  "pos. (#geq 1 tracklet)", "p");
1816         leg->AddEntry(hEffNegAll,  "neg. (#geq 1 tracklet)", "p");
1817         leg->AddEntry(hEffPosTrk4, "pos. (4 tracklets)", "p");
1818         leg->AddEntry(hEffNegTrk4, "neg. (4 tracklets)", "p");
1819         leg->AddEntry(hEffPosTrk5, "pos. (5 tracklets)", "p");
1820         leg->AddEntry(hEffNegTrk5, "neg. (5 tracklets)", "p");
1821         leg->AddEntry(hEffPosTrk6, "pos. (6 tracklets)", "p");
1822         leg->AddEntry(hEffNegTrk6, "neg. (6 tracklets)", "p");
1823       }
1824       leg->Draw();
1825     }
1826     lat->DrawLatex(0.2, 1.32, Form("Centrality class %d", iCent));
1827   }   // end for loop over multiplicity classes
1828
1829   // Reset the modified user ranges of the CF container
1830   fCfContainer->SetRangeUser(kEventMult, 0, 6, kTRUE);
1831   fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0);
1832   fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
1833
1834   // Cluster distributions in all multiplicity classes
1835   pad = ((TVirtualPad*)l->At(2)); pad->cd();
1836   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1837   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
1838   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1839   if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
1840   TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
1841   SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
1842   SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1843   rangeNcls->SetStats(kFALSE);
1844   rangeNcls->Draw();
1845
1846   TH1D* hNcls[6]={0x0};
1847   TLegend* legCls=new TLegend(0.7, 0.75, 0.97, 0.97);
1848   legCls->SetBorderSize(0);
1849   legCls->SetFillColor(0);
1850   legCls->SetMargin(0.15);
1851   for(Int_t iCent=0; iCent<6; ++iCent) {
1852     if(iCent>0)
1853       fCfContainer->SetRangeUser(kEventMult, Double_t(iCent), Double_t(iCent), kTRUE);
1854     if(!useIsolatedBC) hNcls[iCent] = (TH1D*)fCfContainer->Project(1, kTrackTrdClusters);
1855     else{
1856       for(Int_t ibc=0; ibc<3500; ++ibc) {
1857         if(!isIsolated[ibc]) continue;
1858         fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
1859         tempTH1D = (TH1D*)fCfContainer->Project(1, kTrackTrdClusters);
1860         if(!hNcls[iCent]) hNcls[iCent] = tempTH1D;
1861         else {hNcls[iCent]->Add(tempTH1D); delete tempTH1D;}
1862       }
1863       fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);
1864     }
1865     if(!hNcls[iCent]) continue;
1866     hNcls[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
1867     Double_t maximum = hNcls[iCent]->GetMaximum();
1868     if(maximum>1.0)
1869       hNcls[iCent]->Scale(1.0/maximum);
1870     hNcls[iCent]->SetStats(kFALSE);
1871     hNcls[iCent]->SetTitle("");
1872     hNcls[iCent]->SetLineWidth(2);
1873
1874     if(hNcls[iCent]->Integral()>0.01) {
1875       hNcls[iCent]->Draw("same");
1876       legCls->AddEntry(hNcls[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
1877     }
1878   }
1879   if(useIsolatedBC) legCls->SetHeader("Isolated bunch crossings");
1880   else legCls->SetHeader("All bunch crossings");
1881   legCls->Draw();
1882   fCfContainer->SetRangeUser(kEventMult, 0.0, 6.0, kTRUE);
1883
1884   // Qtot vs P
1885   pad = ((TVirtualPad*)l->At(5)); pad->cd();
1886   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
1887   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
1888   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1889   if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
1890   TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
1891   SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1892   SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
1893   rangeQtot->SetStats(kFALSE);
1894   rangeQtot->Draw();
1895
1896   TH1D* hQtot[6]={0x0};
1897   TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.97);
1898   leg2->SetFillColor(0);
1899   leg2->SetBorderSize(0);
1900   for(Int_t iCent=0; iCent<6; ++iCent) {
1901     if(iCent>0)
1902       fCfContainer->SetRangeUser(kEventMult, Double_t(iCent), Double_t(iCent), kTRUE);
1903     if(useIsolatedBC) {
1904       for(Int_t ibc=0; ibc<3500; ++ibc) {
1905         if(!isIsolated[ibc]) continue;
1906         fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
1907         for(Int_t il=0; il<6; ++il) {
1908           tempTH1D = (TH1D*)fCfContainer->Project(1, kTrackQtot+il);
1909           if(!hQtot[iCent] && il==0) hQtot[iCent] = tempTH1D;
1910           else {hQtot[iCent]->Add(tempTH1D); delete tempTH1D;}
1911         }
1912       }
1913       fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);
1914     }
1915     else {
1916       for(Int_t il=0; il<6; ++il) {
1917         tempTH1D = (TH1D*)fCfContainer->Project(1, kTrackQtot+il);
1918         if(il==0) hQtot[iCent] = tempTH1D;
1919         else hQtot[iCent]->Add(tempTH1D);
1920       }
1921     } // end if(useIsolatedBC)
1922
1923     if(!hQtot[iCent]) continue;
1924     hQtot[iCent]->SetBinContent(1, 0);
1925     Double_t maximum = hQtot[iCent]->GetMaximum();
1926     if(maximum>1.0)
1927       hQtot[iCent]->Scale(1.0/maximum);
1928     hQtot[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
1929     hQtot[iCent]->SetStats(kFALSE);
1930     hQtot[iCent]->SetTitle("");
1931     hQtot[iCent]->SetLineWidth(2);
1932     if(hQtot[iCent]->Integral()>0.01) {
1933       hQtot[iCent]->Draw(iCent==0 ? "" : "same");
1934       leg2->AddEntry(hQtot[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
1935     }
1936   }
1937   if(useIsolatedBC) leg2->SetHeader("Isolated bunch crossings");
1938   else leg2->SetHeader("All bunch crossings");
1939   leg2->Draw();
1940   fCfContainer->SetRangeUser(kEventMult, 0.0, 5.0, kTRUE);
1941   if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
1942 }
1943
1944
1945 //_________________________________________________________________
1946 void AliTRDcheckESD::PlotTrackingSummaryFromCF(Int_t centralityClass, Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc) {
1947
1948   if(!fCfContainer) return;
1949
1950   TLatex *lat=new TLatex();
1951   lat->SetTextSize(0.06);
1952   lat->SetTextColor(2);
1953
1954   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
1955   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
1956   gPad->Divide(3,3,0.,0.);
1957   TList* l=gPad->GetListOfPrimitives();
1958
1959   // eta-phi distr. for positive TPC tracks
1960   TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
1961   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
1962   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
1963   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
1964
1965   fCfContainer->SetRangeUser(kTrackDCAxy, -0.999, +0.999);
1966   fCfContainer->SetRangeUser(kTrackDCAz, -3.0, +3.0);
1967   if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, 0.0, 0.0);
1968
1969   // find all the isolated bunch crossings with entries
1970   Bool_t isIsolated[3500];
1971   TH1D* tempTH1D = (TH1D*)fCfContainer->Project(0, kEventBC);
1972   FindIsolatedBCs(tempTH1D, isIsolated); delete tempTH1D;
1973   Int_t nIsolatedBC = 0;
1974   for(Int_t ibc=0; ibc<3500; ++ibc)
1975     if(isIsolated[ibc]) nIsolatedBC++;
1976
1977   if(centralityClass>0) // select the multiplicity class
1978     fCfContainer->SetRangeUser(kEventMult, Double_t(centralityClass), Double_t(centralityClass), kTRUE);
1979
1980   TH2D* hTPCrefPos = 0x0; TH2D* hTRDrefPos = 0x0; TH2D* hTOFrefPos = 0x0;
1981   TH2D* hTPCrefNeg = 0x0; TH2D* hTRDrefNeg = 0x0; TH2D* hTOFrefNeg = 0x0;
1982   if(!useIsolatedBC) {
1983     fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
1984     fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0);      // positive charges
1985     hTPCrefPos = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi);
1986     hTRDrefPos = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi);
1987     hTOFrefPos = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi);
1988     fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0);      // negative charges
1989     hTPCrefNeg = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi);
1990     hTRDrefNeg = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi);
1991     hTOFrefNeg = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi);
1992     fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0);      // reset charge cut
1993   }
1994
1995   TH2D* hTPCrefPos_IsolatedBC=0x0; TH2D* hTPCrefNeg_IsolatedBC=0x0;
1996   TH2D* hTRDrefPos_IsolatedBC=0x0; TH2D* hTRDrefNeg_IsolatedBC=0x0;
1997   TH2D* hTOFrefPos_IsolatedBC=0x0; TH2D* hTOFrefNeg_IsolatedBC=0x0;
1998   if(useIsolatedBC) {
1999     fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
2000     for(Int_t ibc=0; ibc<3500; ++ibc) {
2001       if(!isIsolated[ibc]) continue;
2002       fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
2003       fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0);      // positive charges
2004       TH2D* tempTH2D;
2005       tempTH2D = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi);
2006       if(!hTPCrefPos_IsolatedBC) hTPCrefPos_IsolatedBC = tempTH2D;
2007       else {hTPCrefPos_IsolatedBC->Add(tempTH2D); delete tempTH2D;}
2008       tempTH2D = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi);
2009       if(!hTRDrefPos_IsolatedBC) hTRDrefPos_IsolatedBC = tempTH2D;
2010       else {hTRDrefPos_IsolatedBC->Add(tempTH2D); delete tempTH2D;}
2011       tempTH2D = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi);
2012       if(!hTOFrefPos_IsolatedBC) hTOFrefPos_IsolatedBC = tempTH2D;
2013       else {hTOFrefPos_IsolatedBC->Add(tempTH2D); delete tempTH2D;}
2014       fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0);      // negative charges
2015       tempTH2D = (TH2D*)fCfContainer->Project(0, kTrackEta, kTrackPhi);
2016       if(!hTPCrefNeg_IsolatedBC) hTPCrefNeg_IsolatedBC = tempTH2D;
2017       else {hTPCrefNeg_IsolatedBC->Add(tempTH2D); delete tempTH2D;}
2018       tempTH2D = (TH2D*)fCfContainer->Project(1, kTrackEta, kTrackPhi);
2019       if(!hTRDrefNeg_IsolatedBC) hTRDrefNeg_IsolatedBC = tempTH2D;
2020       else {hTRDrefNeg_IsolatedBC->Add(tempTH2D); delete tempTH2D;}
2021       tempTH2D = (TH2D*)fCfContainer->Project(2, kTrackEta, kTrackPhi);
2022       if(!hTOFrefNeg_IsolatedBC) hTOFrefNeg_IsolatedBC = tempTH2D;
2023       else {hTOFrefNeg_IsolatedBC->Add(tempTH2D); delete tempTH2D;}
2024     }
2025     fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.);   // reset the BC range
2026     fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0);      // reset charge cut
2027   }
2028
2029   if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
2030   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
2031   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
2032   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
2033   rangeEtaPhi->SetStats(kFALSE);
2034
2035   //----------------------------------------------
2036   // eta-phi efficiency for positive TRD tracks
2037   pad = ((TVirtualPad*)l->At(0)); pad->cd();
2038   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2039   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2040   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2041   rangeEtaPhi->Draw();
2042
2043   if(useIsolatedBC) {
2044     if(nIsolatedBC>0) {
2045       TH2D* hTRDeffPos_IsolatedBC = (TH2D*)hTRDrefPos_IsolatedBC->Clone("hTRDeffPos_IsolatedBC");
2046       hTRDeffPos_IsolatedBC->Reset();
2047       hTRDeffPos_IsolatedBC->SetStats(kFALSE);
2048       hTRDeffPos_IsolatedBC->Divide(hTRDrefPos_IsolatedBC, hTPCrefPos_IsolatedBC);
2049       hTRDeffPos_IsolatedBC->SetMaximum(1.0);
2050       hTRDeffPos_IsolatedBC->Draw("samecolz");
2051     }
2052   }
2053   else {
2054     TH2D* hTRDeffPos = (TH2D*)hTRDrefPos->Clone("hTRDeffPos");
2055     hTRDeffPos->Reset();
2056     hTRDeffPos->SetStats(kFALSE);
2057     hTRDeffPos->Divide(hTRDrefPos, hTPCrefPos);
2058     hTRDeffPos->SetMaximum(1.0);
2059     hTRDeffPos->Draw("samecolz");
2060   }
2061   lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for positive tracks");
2062   DrawTRDGrid();
2063
2064   //----------------------------------------------
2065   // eta-phi efficiency for negative TRD tracks
2066   pad = ((TVirtualPad*)l->At(3)); pad->cd();
2067   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2068   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2069   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2070   rangeEtaPhi->Draw();
2071
2072   if(useIsolatedBC) {
2073     if(nIsolatedBC>0) {
2074       TH2D* hTRDeffNeg_IsolatedBC = (TH2D*)hTRDrefNeg_IsolatedBC->Clone("hTRDeffNeg_IsolatedBC");
2075       hTRDeffNeg_IsolatedBC->Reset();
2076       hTRDeffNeg_IsolatedBC->SetStats(kFALSE);
2077       hTRDeffNeg_IsolatedBC->Divide(hTRDrefNeg_IsolatedBC, hTPCrefNeg_IsolatedBC);
2078       hTRDeffNeg_IsolatedBC->SetMaximum(1.0);
2079       hTRDeffNeg_IsolatedBC->Draw("samecolz");
2080     }
2081   }
2082   else {
2083     TH2D* hTRDeffNeg = (TH2D*)hTRDrefNeg->Clone("hTRDeffNeg");
2084     hTRDeffNeg->Reset();
2085     hTRDeffNeg->SetStats(kFALSE);
2086     hTRDeffNeg->Divide(hTRDrefNeg, hTPCrefNeg);
2087     hTRDeffNeg->SetMaximum(1.0);
2088     hTRDeffNeg->Draw("samecolz");
2089   }
2090   lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for negative tracks");
2091   DrawTRDGrid();
2092
2093   //----------------------------------------------
2094   // eta-phi TRD-TOF matching efficiency for positive tracks
2095   pad = ((TVirtualPad*)l->At(1)); pad->cd();
2096   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2097   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2098   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2099   rangeEtaPhi->Draw();
2100
2101   if(useIsolatedBC) {
2102     if(nIsolatedBC>0) {
2103       TH2D* hTOFeffPos_IsolatedBC = (TH2D*)hTOFrefPos_IsolatedBC->Clone("hTOFeffPos_IsolatedBC");
2104       hTOFeffPos_IsolatedBC->Reset();
2105       hTOFeffPos_IsolatedBC->SetStats(kFALSE);
2106       hTOFeffPos_IsolatedBC->Divide(hTOFrefPos_IsolatedBC, hTRDrefPos_IsolatedBC);
2107       hTOFeffPos_IsolatedBC->SetMaximum(1.0);
2108       hTOFeffPos_IsolatedBC->Draw("samecolz");
2109     }
2110   }
2111   else {
2112     TH2D* hTOFeffPos = (TH2D*)hTOFrefPos->Clone("hTOFeffPos");
2113     hTOFeffPos->Reset();
2114     hTOFeffPos->SetStats(kFALSE);
2115     hTOFeffPos->Divide(hTOFrefPos, hTRDrefPos);
2116     hTOFeffPos->SetMaximum(1.0);
2117     hTOFeffPos->Draw("samecolz");
2118   }
2119   lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for positive tracks");
2120   DrawTRDGrid();
2121
2122   //----------------------------------------------
2123   // eta-phi TRD-TOF matching efficiency for negative tracks
2124   pad = ((TVirtualPad*)l->At(4)); pad->cd();
2125   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2126   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2127   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2128   rangeEtaPhi->Draw();
2129
2130   if(useIsolatedBC) {
2131     if(nIsolatedBC) {
2132       TH2D* hTOFeffNeg_IsolatedBC = (TH2D*)hTOFrefNeg_IsolatedBC->Clone("hTOFeffNeg_IsolatedBC");
2133       hTOFeffNeg_IsolatedBC->Reset();
2134       hTOFeffNeg_IsolatedBC->SetStats(kFALSE);
2135       hTOFeffNeg_IsolatedBC->Divide(hTOFrefNeg_IsolatedBC, hTRDrefNeg_IsolatedBC);
2136       hTOFeffNeg_IsolatedBC->SetMaximum(1.0);
2137       hTOFeffNeg_IsolatedBC->Draw("samecolz");
2138     }
2139   }
2140   else {
2141     TH2D* hTOFeffNeg = (TH2D*)hTOFrefNeg->Clone("hTOFeffNeg");
2142     hTOFeffNeg->Reset();
2143     hTOFeffNeg->SetStats(kFALSE);
2144     hTOFeffNeg->Divide(hTOFrefNeg, hTRDrefNeg);
2145     hTOFeffNeg->SetMaximum(1.0);
2146     hTOFeffNeg->Draw("samecolz");
2147   }
2148   lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for negative tracks");
2149   DrawTRDGrid();
2150
2151   if(hTRDrefPos) delete hTRDrefPos; if(hTPCrefPos) delete hTPCrefPos; if(hTOFrefPos) delete hTOFrefPos;
2152   if(hTRDrefNeg) delete hTRDrefNeg; if(hTPCrefNeg) delete hTPCrefNeg; if(hTOFrefNeg) delete hTOFrefNeg;
2153   if(hTRDrefPos_IsolatedBC) delete hTRDrefPos_IsolatedBC; if(hTPCrefPos_IsolatedBC) delete hTPCrefPos_IsolatedBC; if(hTOFrefPos_IsolatedBC) delete hTOFrefPos_IsolatedBC;
2154   if(hTRDrefNeg_IsolatedBC) delete hTRDrefNeg_IsolatedBC; if(hTPCrefNeg_IsolatedBC) delete hTPCrefNeg_IsolatedBC; if(hTOFrefNeg_IsolatedBC) delete hTOFrefNeg_IsolatedBC;
2155
2156   fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
2157   fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0);    // positive charges
2158   TH3D* h3TPCrefPos = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
2159   TH3D* h3TRDrefPosAll = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2160   TH3D* h3TOFrefPosAll = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2161   fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);
2162   TH3D* h3TRDrefPosTrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2163   TH3D* h3TOFrefPosTrk4 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2164   fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);
2165   TH3D* h3TRDrefPosTrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2166   TH3D* h3TOFrefPosTrk5 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2167   fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);
2168   TH3D* h3TRDrefPosTrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2169   TH3D* h3TOFrefPosTrk6 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2170
2171   fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0);   // negative charges
2172   fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
2173   TH3D* h3TPCrefNeg = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
2174   TH3D* h3TRDrefNegAll = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2175   TH3D* h3TOFrefNegAll = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2176   fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);
2177   TH3D* h3TRDrefNegTrk4 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2178   TH3D* h3TOFrefNegTrk4 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2179   fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);
2180   TH3D* h3TRDrefNegTrk5 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2181   TH3D* h3TOFrefNegTrk5 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2182   fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);
2183   TH3D* h3TRDrefNegTrk6 = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2184   TH3D* h3TOFrefNegTrk6 = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2185   fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0);
2186   fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
2187
2188   TH1F* hTRDEffPtPosAll = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosAll, kTRUE);
2189   TH1F* hTRDEffPtNegAll = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegAll, kTRUE);
2190   TH1F* hTRDEffPtPosTrk4 = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosTrk4, kTRUE);
2191   TH1F* hTRDEffPtNegTrk4 = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegTrk4, kTRUE);
2192   TH1F* hTRDEffPtPosTrk5 = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosTrk5, kTRUE);
2193   TH1F* hTRDEffPtNegTrk5 = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegTrk5, kTRUE);
2194   TH1F* hTRDEffPtPosTrk6 = EfficiencyTRD(h3TPCrefPos, h3TRDrefPosTrk6, kTRUE);
2195   TH1F* hTRDEffPtNegTrk6 = EfficiencyTRD(h3TPCrefNeg, h3TRDrefNegTrk6, kTRUE);
2196
2197   TH1F* hTOFEffPtPosAll = EfficiencyTRD(h3TRDrefPosAll, h3TOFrefPosAll, kFALSE);
2198   TH1F* hTOFEffPtNegAll = EfficiencyTRD(h3TRDrefNegAll, h3TOFrefNegAll, kFALSE);
2199   TH1F* hTOFEffPtPosTrk4 = EfficiencyTRD(h3TRDrefPosTrk4, h3TOFrefPosTrk4, kFALSE);
2200   TH1F* hTOFEffPtNegTrk4 = EfficiencyTRD(h3TRDrefNegTrk4, h3TOFrefNegTrk4, kFALSE);
2201   TH1F* hTOFEffPtPosTrk5 = EfficiencyTRD(h3TRDrefPosTrk5, h3TOFrefPosTrk5, kFALSE);
2202   TH1F* hTOFEffPtNegTrk5 = EfficiencyTRD(h3TRDrefNegTrk5, h3TOFrefNegTrk5, kFALSE);
2203   TH1F* hTOFEffPtPosTrk6 = EfficiencyTRD(h3TRDrefPosTrk6, h3TOFrefPosTrk6, kFALSE);
2204   TH1F* hTOFEffPtNegTrk6 = EfficiencyTRD(h3TRDrefNegTrk6, h3TOFrefNegTrk6, kFALSE);
2205
2206   delete h3TPCrefPos; delete h3TPCrefNeg;
2207   delete h3TRDrefPosAll; delete h3TRDrefPosTrk4; delete h3TRDrefPosTrk5; delete h3TRDrefPosTrk6;
2208   delete h3TRDrefNegAll; delete h3TRDrefNegTrk4; delete h3TRDrefNegTrk5; delete h3TRDrefNegTrk6;
2209   delete h3TOFrefPosAll; delete h3TOFrefPosTrk4; delete h3TOFrefPosTrk5; delete h3TOFrefPosTrk6;
2210   delete h3TOFrefNegAll; delete h3TOFrefNegTrk4; delete h3TOFrefNegTrk5; delete h3TOFrefNegTrk6;
2211
2212   TF1* funcConst = new TF1("constFunc", "[0]", 1.0, 3.0);
2213   if(trendValues && hTRDEffPtPosAll && hTRDEffPtPosAll->Integral()>0.1) {
2214     hTRDEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2215     trendValues[0] = funcConst->GetParameter(0);
2216     trendValues[1] = funcConst->GetParError(0);
2217   }
2218   if(trendValues && hTRDEffPtNegAll && hTRDEffPtNegAll->Integral()>0.1) {
2219     hTRDEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2220     trendValues[2] = funcConst->GetParameter(0);
2221     trendValues[3] = funcConst->GetParError(0);
2222   }
2223   if(trendValues && hTOFEffPtPosAll && hTOFEffPtPosAll->Integral()>0.1) {
2224     hTOFEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2225     trendValues[4] = funcConst->GetParameter(0);
2226     trendValues[5] = funcConst->GetParError(0);
2227   }
2228   if(trendValues && hTOFEffPtNegAll && hTOFEffPtNegAll->Integral()>0.1) {
2229     hTOFEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2230     trendValues[6] = funcConst->GetParameter(0);
2231     trendValues[7] = funcConst->GetParError(0);
2232   }
2233
2234   // get matching efficiencies for isolated bunches
2235   TH3D* h3TPCrefPos_IsolatedBC=0x0; TH3D* h3TPCrefNeg_IsolatedBC=0x0;
2236   TH3D* h3TRDrefPosAll_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk4_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk5_IsolatedBC=0x0; TH3D* h3TRDrefPosTrk6_IsolatedBC=0x0;
2237   TH3D* h3TRDrefNegAll_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk4_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk5_IsolatedBC=0x0; TH3D* h3TRDrefNegTrk6_IsolatedBC=0x0;
2238   TH3D* h3TOFrefPosAll_IsolatedBC=0x0; TH3D* h3TOFrefPosTrk4_IsolatedBC=0x0; TH3D* h3TOFrefPosTrk5_IsolatedBC=0x0; TH3D* h3TOFrefPosTrk6_IsolatedBC=0x0;
2239   TH3D* h3TOFrefNegAll_IsolatedBC=0x0; TH3D* h3TOFrefNegTrk4_IsolatedBC=0x0; TH3D* h3TOFrefNegTrk5_IsolatedBC=0x0; TH3D* h3TOFrefNegTrk6_IsolatedBC=0x0;
2240   for(Int_t ibc=0; ibc<3500; ++ibc) {
2241     if(!isIsolated[ibc]) continue;
2242     fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
2243
2244     TH3D* temp;
2245     fCfContainer->SetRangeUser(kTrackCharge, +1.0, +1.0);    // positive charges
2246     fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
2247     temp = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
2248     if(!h3TPCrefPos_IsolatedBC) h3TPCrefPos_IsolatedBC = temp;
2249     else {h3TPCrefPos_IsolatedBC->Add(temp); delete temp;}
2250     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2251     if(!h3TRDrefPosAll_IsolatedBC) h3TRDrefPosAll_IsolatedBC = temp;
2252     else {h3TRDrefPosAll_IsolatedBC->Add(temp); delete temp;}
2253     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2254     if(!h3TOFrefPosAll_IsolatedBC) h3TOFrefPosAll_IsolatedBC = temp;
2255     else {h3TOFrefPosAll_IsolatedBC->Add(temp); delete temp;}
2256     fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);
2257     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2258     if(!h3TRDrefPosTrk4_IsolatedBC) h3TRDrefPosTrk4_IsolatedBC = temp;
2259     else {h3TRDrefPosTrk4_IsolatedBC->Add(temp); delete temp;}
2260     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2261     if(!h3TOFrefPosTrk4_IsolatedBC) h3TOFrefPosTrk4_IsolatedBC = temp;
2262     else {h3TOFrefPosTrk4_IsolatedBC->Add(temp); delete temp;}
2263     fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);
2264     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2265     if(!h3TRDrefPosTrk5_IsolatedBC) h3TRDrefPosTrk5_IsolatedBC = temp;
2266     else {h3TRDrefPosTrk5_IsolatedBC->Add(temp); delete temp;}
2267     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2268     if(!h3TOFrefPosTrk5_IsolatedBC) h3TOFrefPosTrk5_IsolatedBC = temp;
2269     else {h3TOFrefPosTrk5_IsolatedBC->Add(temp); delete temp;}
2270     fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);
2271     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2272     if(!h3TRDrefPosTrk6_IsolatedBC) h3TRDrefPosTrk6_IsolatedBC = temp;
2273     else {h3TRDrefPosTrk6_IsolatedBC->Add(temp); delete temp;}
2274     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2275     if(!h3TOFrefPosTrk6_IsolatedBC) h3TOFrefPosTrk6_IsolatedBC = temp;
2276     else {h3TOFrefPosTrk6_IsolatedBC->Add(temp); delete temp;}
2277
2278     fCfContainer->SetRangeUser(kTrackCharge, -1.0, -1.0);   // negative charges
2279     fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
2280     temp = (TH3D*)fCfContainer->Project(0, kTrackEta, kTrackPhi, kTrackPt);
2281     if(!h3TPCrefNeg_IsolatedBC) h3TPCrefNeg_IsolatedBC = temp;
2282     else {h3TPCrefNeg_IsolatedBC->Add(temp); delete temp;}
2283     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2284     if(!h3TRDrefNegAll_IsolatedBC) h3TRDrefNegAll_IsolatedBC = temp;
2285     else {h3TRDrefNegAll_IsolatedBC->Add(temp); delete temp;}
2286     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2287     if(!h3TOFrefNegAll_IsolatedBC) h3TOFrefNegAll_IsolatedBC = temp;
2288     else {h3TOFrefNegAll_IsolatedBC->Add(temp); delete temp;}
2289     fCfContainer->SetRangeUser(kTrackTrdTracklets, 4.0, 4.0);
2290     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2291     if(!h3TRDrefNegTrk4_IsolatedBC) h3TRDrefNegTrk4_IsolatedBC = temp;
2292     else {h3TRDrefNegTrk4_IsolatedBC->Add(temp); delete temp;}
2293     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2294     if(!h3TOFrefNegTrk4_IsolatedBC) h3TOFrefNegTrk4_IsolatedBC = temp;
2295     else {h3TOFrefNegTrk4_IsolatedBC->Add(temp); delete temp;}
2296     fCfContainer->SetRangeUser(kTrackTrdTracklets, 5.0, 5.0);
2297     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2298     if(!h3TRDrefNegTrk5_IsolatedBC) h3TRDrefNegTrk5_IsolatedBC = temp;
2299     else {h3TRDrefNegTrk5_IsolatedBC->Add(temp); delete temp;}
2300     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2301     if(!h3TOFrefNegTrk5_IsolatedBC) h3TOFrefNegTrk5_IsolatedBC = temp;
2302     else {h3TOFrefNegTrk5_IsolatedBC->Add(temp); delete temp;}
2303     fCfContainer->SetRangeUser(kTrackTrdTracklets, 6.0, 6.0);
2304     temp = (TH3D*)fCfContainer->Project(1, kTrackEta, kTrackPhi, kTrackPt);
2305     if(!h3TRDrefNegTrk6_IsolatedBC) h3TRDrefNegTrk6_IsolatedBC = temp;
2306     else {h3TRDrefNegTrk6_IsolatedBC->Add(temp); delete temp;}
2307     temp = (TH3D*)fCfContainer->Project(2, kTrackEta, kTrackPhi, kTrackPt);
2308     if(!h3TOFrefNegTrk6_IsolatedBC) h3TOFrefNegTrk6_IsolatedBC = temp;
2309     else {h3TOFrefNegTrk6_IsolatedBC->Add(temp); delete temp;}
2310   }
2311   fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);
2312   fCfContainer->SetRangeUser(kTrackCharge, -1.0, +1.0);
2313   fCfContainer->SetRangeUser(kTrackTrdTracklets, 0.0, 6.0);
2314
2315   TH1F* hTRDEffPtPosAll_IsolatedBC  = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosAll_IsolatedBC, kTRUE);
2316   TH1F* hTRDEffPtNegAll_IsolatedBC  = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegAll_IsolatedBC, kTRUE);
2317   TH1F* hTRDEffPtPosTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk4_IsolatedBC, kTRUE);
2318   TH1F* hTRDEffPtNegTrk4_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk4_IsolatedBC, kTRUE);
2319   TH1F* hTRDEffPtPosTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk5_IsolatedBC, kTRUE);
2320   TH1F* hTRDEffPtNegTrk5_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk5_IsolatedBC, kTRUE);
2321   TH1F* hTRDEffPtPosTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefPos_IsolatedBC, h3TRDrefPosTrk6_IsolatedBC, kTRUE);
2322   TH1F* hTRDEffPtNegTrk6_IsolatedBC = EfficiencyTRD(h3TPCrefNeg_IsolatedBC, h3TRDrefNegTrk6_IsolatedBC, kTRUE);
2323
2324   TH1F* hTOFEffPtPosAll_IsolatedBC  = EfficiencyTRD(h3TRDrefPosAll_IsolatedBC, h3TOFrefPosAll_IsolatedBC, kFALSE);
2325   TH1F* hTOFEffPtNegAll_IsolatedBC  = EfficiencyTRD(h3TRDrefNegAll_IsolatedBC, h3TOFrefNegAll_IsolatedBC, kFALSE);
2326   TH1F* hTOFEffPtPosTrk4_IsolatedBC = EfficiencyTRD(h3TRDrefPosTrk4_IsolatedBC, h3TOFrefPosTrk4_IsolatedBC, kFALSE);
2327   TH1F* hTOFEffPtNegTrk4_IsolatedBC = EfficiencyTRD(h3TRDrefNegTrk4_IsolatedBC, h3TOFrefNegTrk4_IsolatedBC, kFALSE);
2328   TH1F* hTOFEffPtPosTrk5_IsolatedBC = EfficiencyTRD(h3TRDrefPosTrk5_IsolatedBC, h3TOFrefPosTrk5_IsolatedBC, kFALSE);
2329   TH1F* hTOFEffPtNegTrk5_IsolatedBC = EfficiencyTRD(h3TRDrefNegTrk5_IsolatedBC, h3TOFrefNegTrk5_IsolatedBC, kFALSE);
2330   TH1F* hTOFEffPtPosTrk6_IsolatedBC = EfficiencyTRD(h3TRDrefPosTrk6_IsolatedBC, h3TOFrefPosTrk6_IsolatedBC, kFALSE);
2331   TH1F* hTOFEffPtNegTrk6_IsolatedBC = EfficiencyTRD(h3TRDrefNegTrk6_IsolatedBC, h3TOFrefNegTrk6_IsolatedBC, kFALSE);
2332
2333   if(h3TPCrefPos_IsolatedBC) delete h3TPCrefPos_IsolatedBC; if(h3TPCrefNeg_IsolatedBC) delete h3TPCrefNeg_IsolatedBC;
2334   if(h3TRDrefPosAll_IsolatedBC) delete h3TRDrefPosAll_IsolatedBC; if(h3TRDrefPosTrk4_IsolatedBC) delete h3TRDrefPosTrk4_IsolatedBC;
2335   if(h3TRDrefPosTrk5_IsolatedBC) delete h3TRDrefPosTrk5_IsolatedBC; if(h3TRDrefPosTrk6_IsolatedBC) delete h3TRDrefPosTrk6_IsolatedBC;
2336   if(h3TRDrefNegAll_IsolatedBC) delete h3TRDrefNegAll_IsolatedBC; if(h3TRDrefNegTrk4_IsolatedBC) delete h3TRDrefNegTrk4_IsolatedBC;
2337   if(h3TRDrefNegTrk5_IsolatedBC) delete h3TRDrefNegTrk5_IsolatedBC; if(h3TRDrefNegTrk6_IsolatedBC) delete h3TRDrefNegTrk6_IsolatedBC;
2338   if(h3TOFrefPosAll_IsolatedBC) delete h3TOFrefPosAll_IsolatedBC; if(h3TOFrefPosTrk4_IsolatedBC) delete h3TOFrefPosTrk4_IsolatedBC;
2339   if(h3TOFrefPosTrk5_IsolatedBC) delete h3TOFrefPosTrk5_IsolatedBC; if(h3TOFrefPosTrk6_IsolatedBC) delete h3TOFrefPosTrk6_IsolatedBC;
2340   if(h3TOFrefNegAll_IsolatedBC) delete h3TOFrefNegAll_IsolatedBC; if(h3TOFrefNegTrk4_IsolatedBC) delete h3TOFrefNegTrk4_IsolatedBC;
2341   if(h3TOFrefNegTrk5_IsolatedBC) delete h3TOFrefNegTrk5_IsolatedBC; if(h3TOFrefNegTrk6_IsolatedBC) delete h3TOFrefNegTrk6_IsolatedBC;
2342
2343   if(trendValues &&  hTRDEffPtPosAll_IsolatedBC && hTRDEffPtPosAll_IsolatedBC->Integral()>0.1) {
2344     hTRDEffPtPosAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2345     trendValues[18] = funcConst->GetParameter(0);
2346     trendValues[19] = funcConst->GetParError(0);
2347   }
2348   if(trendValues &&  hTRDEffPtNegAll_IsolatedBC && hTRDEffPtNegAll_IsolatedBC->Integral()>0.1) {
2349     hTRDEffPtNegAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2350     trendValues[20] = funcConst->GetParameter(0);
2351     trendValues[21] = funcConst->GetParError(0);
2352   }
2353   if(trendValues &&  hTOFEffPtPosAll_IsolatedBC && hTOFEffPtPosAll_IsolatedBC->Integral()>0.1) {
2354     hTOFEffPtPosAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2355     trendValues[22] = funcConst->GetParameter(0);
2356     trendValues[23] = funcConst->GetParError(0);
2357   }
2358   if(trendValues &&  hTOFEffPtNegAll_IsolatedBC && hTOFEffPtNegAll_IsolatedBC->Integral()>0.1) {
2359     hTOFEffPtNegAll_IsolatedBC->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2360     trendValues[24] = funcConst->GetParameter(0);
2361     trendValues[25] = funcConst->GetParError(0);
2362   }
2363
2364   //---------------------------------------------------------
2365   // TPC-TRD matching efficiency vs pt
2366   pad = ((TVirtualPad*)l->At(6)); pad->cd();
2367   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2368   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2369   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2370
2371   if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
2372   TH2F* rangeEffPt=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
2373   rangeEffPt->SetStats(kFALSE);
2374   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2375   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2376   rangeEffPt->Draw();
2377   lat->DrawLatex(0.2, 1.42, "TPC-TRD matching efficiency");
2378   //++++++++++++++++++
2379   TLine line;
2380   line.SetLineStyle(2);
2381   line.SetLineWidth(2);
2382   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2383   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2384   TLegend* leg=new TLegend(0.2, 0.7, 0.7, 0.89);
2385   leg->SetNColumns(2);
2386   leg->SetMargin(0.15);
2387   leg->SetBorderSize(0);
2388   leg->SetFillColor(0);
2389
2390   if(!useIsolatedBC) {
2391     SetStyle(hTRDEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
2392     SetStyle(hTRDEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
2393     SetStyle(hTRDEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
2394     SetStyle(hTRDEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2395     SetStyle(hTRDEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
2396     SetStyle(hTRDEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2397     SetStyle(hTRDEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
2398     SetStyle(hTRDEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2399     leg->SetHeader("All bunch crossings");
2400     hTRDEffPtPosAll->Draw("same"); leg->AddEntry(hTRDEffPtPosAll, "pos. (#geq 1 tracklet)", "p");
2401     hTRDEffPtNegAll->Draw("same"); leg->AddEntry(hTRDEffPtNegAll, "neg. (#geq 1 tracklet)", "p");
2402     hTRDEffPtPosTrk4->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4, "pos. (4 tracklets)", "p");
2403     hTRDEffPtNegTrk4->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4, "neg. (4 tracklets)", "p");
2404     hTRDEffPtPosTrk5->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5, "pos. (5 tracklets)", "p");
2405     hTRDEffPtNegTrk5->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5, "neg. (5 tracklets)", "p");
2406     hTRDEffPtPosTrk6->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6, "pos. (6 tracklets)", "p");
2407     hTRDEffPtNegTrk6->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6, "neg. (6 tracklets)", "p");
2408   }
2409   else {
2410     if(nIsolatedBC>0) {
2411       SetStyle(hTRDEffPtPosAll_IsolatedBC, 1, kRed, 1, 24, kRed, 1);
2412       SetStyle(hTRDEffPtNegAll_IsolatedBC, 1, kBlue, 1, 24, kBlue, 1);
2413       SetStyle(hTRDEffPtPosTrk4_IsolatedBC, 1, kRed, 1, 25, kRed, 1);
2414       SetStyle(hTRDEffPtNegTrk4_IsolatedBC, 1, kBlue, 1, 25, kBlue, 1);
2415       SetStyle(hTRDEffPtPosTrk5_IsolatedBC, 1, kRed, 1, 26, kRed, 1);
2416       SetStyle(hTRDEffPtNegTrk5_IsolatedBC, 1, kBlue, 1, 26, kBlue, 1);
2417       SetStyle(hTRDEffPtPosTrk6_IsolatedBC, 1, kRed, 1, 27, kRed, 1);
2418       SetStyle(hTRDEffPtNegTrk6_IsolatedBC, 1, kBlue, 1, 27, kBlue, 1);
2419       leg->SetHeader("Isolated bunch crossings");
2420       hTRDEffPtPosAll_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosAll_IsolatedBC, "pos. (#geq 1 tracklet)", "p");
2421       hTRDEffPtNegAll_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegAll_IsolatedBC, "neg. (#geq 1 tracklet)", "p");
2422       hTRDEffPtPosTrk4_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4_IsolatedBC, "pos. (4 tracklets)", "p");
2423       hTRDEffPtNegTrk4_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4_IsolatedBC, "neg. (4 tracklets)", "p");
2424       hTRDEffPtPosTrk5_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5_IsolatedBC, "pos. (5 tracklets)", "p");
2425       hTRDEffPtNegTrk5_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5_IsolatedBC, "neg. (5 tracklets)", "p");
2426       hTRDEffPtPosTrk6_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6_IsolatedBC, "pos. (6 tracklets)", "p");
2427       hTRDEffPtNegTrk6_IsolatedBC->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6_IsolatedBC, "neg. (6 tracklets)", "p");
2428     }
2429   }
2430
2431   leg->Draw();
2432
2433   //---------------------------------------------------------
2434   // TRD-TOF matching efficiency vs pt
2435   pad = ((TVirtualPad*)l->At(7)); pad->cd();
2436   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2437   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2438   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2439
2440   rangeEffPt->Draw();
2441   lat->DrawLatex(0.2, 1.42, "TRD-TOF matching efficiency");
2442
2443   if(!useIsolatedBC) {
2444     SetStyle(hTOFEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
2445     SetStyle(hTOFEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
2446     SetStyle(hTOFEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
2447     SetStyle(hTOFEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
2448     SetStyle(hTOFEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
2449     SetStyle(hTOFEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2450     SetStyle(hTOFEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2451     SetStyle(hTOFEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2452     hTOFEffPtPosAll->Draw("same");
2453     hTOFEffPtPosTrk4->Draw("same");
2454     hTOFEffPtPosTrk5->Draw("same");
2455     hTOFEffPtPosTrk6->Draw("same");
2456     hTOFEffPtNegAll->Draw("same");
2457     hTOFEffPtNegTrk4->Draw("same");
2458     hTOFEffPtNegTrk5->Draw("same");
2459     hTOFEffPtNegTrk6->Draw("same");
2460   }
2461   else {
2462     if(nIsolatedBC>0) {
2463       SetStyle(hTOFEffPtPosAll_IsolatedBC, 1, kRed, 1, 24, kRed, 1);
2464       SetStyle(hTOFEffPtPosTrk4_IsolatedBC, 1, kRed, 1, 25, kRed, 1);
2465       SetStyle(hTOFEffPtPosTrk5_IsolatedBC, 1, kRed, 1, 26, kRed, 1);
2466       SetStyle(hTOFEffPtPosTrk6_IsolatedBC, 1, kRed, 1, 27, kRed, 1);
2467       SetStyle(hTOFEffPtNegAll_IsolatedBC, 1, kBlue, 1, 24, kBlue, 1);
2468       SetStyle(hTOFEffPtNegTrk4_IsolatedBC, 1, kBlue, 1, 25, kBlue, 1);
2469       SetStyle(hTOFEffPtNegTrk5_IsolatedBC, 1, kBlue, 1, 26, kBlue, 1);
2470       SetStyle(hTOFEffPtNegTrk6_IsolatedBC, 1, kBlue, 1, 27, kBlue, 1);
2471       hTOFEffPtPosAll_IsolatedBC->Draw("same");
2472       hTOFEffPtPosTrk4_IsolatedBC->Draw("same");
2473       hTOFEffPtPosTrk5_IsolatedBC->Draw("same");
2474       hTOFEffPtPosTrk6_IsolatedBC->Draw("same");
2475       hTOFEffPtNegAll_IsolatedBC->Draw("same");
2476       hTOFEffPtNegTrk4_IsolatedBC->Draw("same");
2477       hTOFEffPtNegTrk5_IsolatedBC->Draw("same");
2478       hTOFEffPtNegTrk6_IsolatedBC->Draw("same");
2479     }
2480   }
2481
2482   //-----------------------------------------------------
2483   // <ntracklets> vs (phi,eta)
2484   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2485   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2486   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2487   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2488
2489   rangeEtaPhi->Draw();
2490   lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>");
2491
2492   TH3D* hNtracklets = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackTrdTracklets);
2493   TH3D* hNtracklets_IsolatedBC=0x0;
2494   for(Int_t ibc=0; ibc<3500; ++ibc) {
2495     if(!isIsolated[ibc]) continue;
2496     fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
2497     TH3D* temp = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackTrdTracklets);
2498     if(!hNtracklets_IsolatedBC) hNtracklets_IsolatedBC = temp;
2499     else {hNtracklets_IsolatedBC->Add(temp); delete temp;}
2500   }
2501   fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);   // reset the BC range
2502
2503   TProfile2D* hNtrackletsProf=0x0;
2504   if(useIsolatedBC) {
2505     if(nIsolatedBC>0)
2506       hNtrackletsProf = hNtracklets_IsolatedBC->Project3DProfile();
2507   }
2508   else hNtrackletsProf = hNtracklets->Project3DProfile();
2509   delete hNtracklets; if(hNtracklets_IsolatedBC) delete hNtracklets_IsolatedBC;
2510   if(hNtrackletsProf) {
2511     hNtrackletsProf->SetStats(kFALSE);
2512     hNtrackletsProf->SetMinimum(0.);
2513     hNtrackletsProf->SetMaximum(6.);
2514     hNtrackletsProf->Draw("samecolz");
2515     DrawTRDGrid();
2516   }
2517
2518   // calculate the trend value for tracklets/track
2519   TH2D* hNtrackletsVsP = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdTracklets);
2520   if(trendValues &&  hNtrackletsVsP && hNtrackletsVsP->GetEntries()>0.1) {
2521     TProfile* hNtrackletsVsPprof = hNtrackletsVsP->ProfileX("hNtrackletsVsPprof");
2522     hNtrackletsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2523     trendValues[8] = funcConst->GetParameter(0);
2524     trendValues[9] = funcConst->GetParError(0);
2525     delete hNtrackletsVsP;
2526   }
2527   TH2D* hNtrackletsVsP_IsolatedBC=0x0;
2528   for(Int_t ibc=0; ibc<3500; ++ibc) {
2529     if(!isIsolated[ibc]) continue;
2530     fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
2531     TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdTracklets);
2532     if(!hNtrackletsVsP_IsolatedBC) hNtrackletsVsP_IsolatedBC = temp;
2533     else {hNtrackletsVsP_IsolatedBC->Add(temp); delete temp;}
2534   }
2535   fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);   // reset the BC range
2536   if(trendValues &&  hNtrackletsVsP_IsolatedBC && hNtrackletsVsP_IsolatedBC->GetEntries()>0.1) {
2537     TProfile* hNtrackletsVsPprof_IsolatedBC = hNtrackletsVsP_IsolatedBC->ProfileX("hNtrackletsVsPprof_IsolatedBC");
2538     hNtrackletsVsPprof_IsolatedBC->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2539     trendValues[26] = funcConst->GetParameter(0);
2540     trendValues[27] = funcConst->GetParError(0);
2541     delete hNtrackletsVsPprof_IsolatedBC;
2542   }
2543
2544   //--------------------------------------------------------------
2545   // Nclusters per TRD track vs momentum
2546   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2547   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
2548   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2549   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2550   pad->SetLogz();
2551
2552   if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
2553   TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
2554   SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2555   SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
2556   rangeNclsP->SetStats(kFALSE);
2557   rangeNclsP->Draw();
2558   lat->DrawLatex(1.0, 205., "TRD Clusters / track");
2559
2560   TH2D* hNclsVsP = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdClusters);
2561   TH2D* hNclsVsP_IsolatedBC=0x0;
2562   for(Int_t ibc=0; ibc<3500; ++ibc) {
2563     if(!isIsolated[ibc]) continue;
2564     fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
2565     TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackTrdClusters);
2566     if(!hNclsVsP_IsolatedBC) hNclsVsP_IsolatedBC = temp;
2567     else {hNclsVsP_IsolatedBC->Add(temp); delete temp;}
2568   }
2569   fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);   // reset the BC range
2570
2571   if(useIsolatedBC && hNclsVsP_IsolatedBC) {
2572     hNclsVsP_IsolatedBC->SetStats(kFALSE);
2573     hNclsVsP_IsolatedBC->Draw("samecolz");
2574   }
2575   if(!useIsolatedBC && hNclsVsP) {
2576     hNclsVsP->SetStats(kFALSE);
2577     hNclsVsP->Draw("samecolz");
2578   }
2579
2580   if(trendValues && hNclsVsP && hNclsVsP->GetEntries()>10) {
2581     TProfile* hNclsVsPprof = hNclsVsP->ProfileX("hNclsVsPprof");
2582     hNclsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2583     trendValues[10] = funcConst->GetParameter(0);
2584     trendValues[11] = funcConst->GetParError(0);
2585   }
2586   if(trendValues && hNclsVsP_IsolatedBC && hNclsVsP_IsolatedBC->GetEntries()>10) {
2587     TProfile* hNclsVsPprof_IsolatedBC = hNclsVsP_IsolatedBC->ProfileX("hNclsVsPprof_IsolateBC");
2588     hNclsVsPprof_IsolatedBC->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2589     trendValues[28] = funcConst->GetParameter(0);
2590     trendValues[29] = funcConst->GetParError(0);
2591   }
2592
2593   //--------------------------------------------------------------
2594   // TRD-TPC and TOF-TRD matching efficiency vs bunch crossing
2595   pad = ((TVirtualPad*)l->At(8)); pad->cd();
2596   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2597   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2598   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2599
2600   TH1D* phiProj = (TH1D*)fCfContainer->Project(1, kTrackPhi);
2601   Double_t smPhiLimits[19];
2602   Bool_t activeSM[18] = {kFALSE};
2603   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
2604   CheckActiveSM(phiProj, activeSM);
2605   for(Int_t ism=0; ism<18; ++ism) cout << "sm " << ism << " is active : " << (activeSM[ism] ? "yes" : "no") << endl;
2606
2607   fCfContainer->SetRangeUser(kTrackPt, 1.01, 2.99);   // 1.0 < pt < 3.0 GeV/c
2608   TH2D* hTPCPhiBC = (TH2D*)fCfContainer->Project(0, kEventBC, kTrackPhi);
2609   TH2D* hTRDPhiBC = (TH2D*)fCfContainer->Project(1, kEventBC, kTrackPhi);
2610   TH2D* hTOFPhiBC = (TH2D*)fCfContainer->Project(2, kEventBC, kTrackPhi);
2611   TH1D* projectionBC = (TH1D*)fCfContainer->Project(0, kEventBC);
2612   fCfContainer->SetRangeUser(kTrackPt, 0.0, 100.0);   // reset the pt range
2613   TH1D* hTRDEffBC = new TH1D("hTRDEffBC", "", hTPCPhiBC->GetXaxis()->GetNbins(), hTPCPhiBC->GetXaxis()->GetXmin(), hTPCPhiBC->GetXaxis()->GetXmax());
2614   TH1D* hTOFEffBC = new TH1D("hTOFEffBC", "", hTPCPhiBC->GetXaxis()->GetNbins(), hTPCPhiBC->GetXaxis()->GetXmin(), hTPCPhiBC->GetXaxis()->GetXmax());
2615
2616   for(Int_t bcBin=1; bcBin<=hTPCPhiBC->GetXaxis()->GetNbins(); ++bcBin) {
2617     if(projectionBC->GetBinContent(bcBin)<0.1) continue;
2618     Double_t tpcEntries = 0.0; Double_t trdEntries = 0.0; Double_t tofEntries = 0.0;
2619     for(Int_t phiBin=1; phiBin<=hTPCPhiBC->GetYaxis()->GetNbins(); ++phiBin) {
2620       Double_t phi = hTPCPhiBC->GetYaxis()->GetBinCenter(phiBin);
2621       for(Int_t ism=0; ism<18; ++ism) {
2622         if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) {
2623           tpcEntries += hTPCPhiBC->GetBinContent(bcBin, phiBin);
2624           trdEntries += hTRDPhiBC->GetBinContent(bcBin, phiBin);
2625           tofEntries += hTOFPhiBC->GetBinContent(bcBin, phiBin);
2626         }
2627       }  // end loop over super-modules
2628     }  // end loop over phi bins
2629     hTRDEffBC->SetBinContent(bcBin, (tpcEntries>0.01 ? trdEntries/tpcEntries : 0.0));
2630     if(tpcEntries>0.01 && trdEntries>0.01 && (tpcEntries-trdEntries)>=0.01)
2631     hTRDEffBC->SetBinError(bcBin, TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries));
2632     hTOFEffBC->SetBinContent(bcBin, (trdEntries>0.01 ? tofEntries/trdEntries : 0.0));
2633     if(trdEntries>0.01 && tofEntries>0.01 && (trdEntries-tofEntries)>=0.01)
2634     hTOFEffBC->SetBinError(bcBin, TMath::Sqrt(tofEntries*(trdEntries-tofEntries)/trdEntries/trdEntries/trdEntries));
2635   }  // end loop over BC bins
2636   delete hTPCPhiBC; delete hTRDPhiBC; delete hTOFPhiBC;
2637   delete projectionBC;
2638
2639   if(gROOT->FindObject("rangeBC")) delete gROOT->FindObject("rangeBC");
2640   TH2F* rangeBC = new TH2F("rangeBC", "", 10, -0.5, 3499.5, 10, 0.0, 1.4);
2641   rangeBC->SetStats(kFALSE);
2642   SetStyle(rangeBC->GetXaxis(), "Bunch crossing", 0.07, 0.8, kTRUE, 0.05);
2643   SetStyle(rangeBC->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2644   rangeBC->Draw();
2645
2646   TLegend* legBC=new TLegend(0.8, 0.7, 0.95, 0.89);
2647   legBC->SetBorderSize(0);
2648   legBC->SetMargin(0.15);
2649   legBC->SetFillColor(0);
2650   if(hTRDEffBC) {
2651     hTRDEffBC->SetStats(kFALSE);
2652     SetStyle(hTRDEffBC, 1, kRed, 2, 24, kRed, 1); legBC->AddEntry(hTRDEffBC, "TPC-TRD", "p");
2653     SetStyle(hTOFEffBC, 1, kBlue, 2, 24, kBlue, 1); legBC->AddEntry(hTOFEffBC, "TRD-TOF", "p");
2654     hTRDEffBC->Draw("same");
2655     hTOFEffBC->Draw("same");
2656     legBC->Draw();
2657     lat->DrawLatex(200., 1.42, "Matching efficiency at 1<p_{T}<3 GeV/c");
2658   }
2659
2660   // reset the user range on the event multiplicity
2661   fCfContainer->SetRangeUser(kEventMult, 0.0, 6.0, kTRUE);
2662   if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2663
2664   delete funcConst;
2665 }
2666
2667
2668 //_________________________________________________________________
2669 void AliTRDcheckESD::PlotPidSummaryFromCF(Int_t centralityClass, Double_t* trendValues, Bool_t useIsolatedBC, Bool_t cutTOFbc) {
2670
2671   if(!fCfContainer) return;
2672
2673   TLatex *lat=new TLatex();
2674   lat->SetTextSize(0.07);
2675   lat->SetTextColor(2);
2676   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2677   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2678   gPad->Divide(3,3,0.,0.);
2679   TList* l=gPad->GetListOfPrimitives();
2680
2681   fCfContainer->SetRangeUser(kTrackDCAxy, -0.999, +0.999);
2682   fCfContainer->SetRangeUser(kTrackDCAz, -3.0, +3.0);
2683   if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, 0.0, 0.0);
2684
2685   // find all the isolated bunch crossings with entries
2686   Bool_t isIsolated[3500];
2687   TH1D* tempTH1D = (TH1D*)fCfContainer->Project(0, kEventBC);
2688   FindIsolatedBCs(tempTH1D, isIsolated); delete tempTH1D;
2689   Int_t nIsolatedBC = 0;
2690   for(Int_t ibc=0; ibc<3500; ++ibc)
2691     if(isIsolated[ibc]) nIsolatedBC++;
2692
2693   if(centralityClass>0) // select the multiplicity class
2694     fCfContainer->SetRangeUser(kEventMult, Double_t(centralityClass), Double_t(centralityClass), kTRUE);
2695
2696   if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
2697   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
2698   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
2699   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
2700   rangeEtaPhi->SetStats(kFALSE);
2701
2702   // eta-phi distr. for <Qtot> in layer 0
2703   TVirtualPad* pad;
2704   TProfile2D* hProf2D;
2705   for(Int_t iLayer=0; iLayer<6; ++iLayer) {
2706     pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
2707     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2708     pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2709     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2710     rangeEtaPhi->Draw();
2711
2712     TH3D* hQtotEtaPhi=0x0;
2713     if(useIsolatedBC) {
2714       for(Int_t ibc=0; ibc<3500; ++ibc) {
2715         if(!isIsolated[ibc]) continue;
2716         fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
2717         TH3D* temp = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackQtot+iLayer);
2718         if(!hQtotEtaPhi) hQtotEtaPhi = temp;
2719         else {hQtotEtaPhi->Add(temp); delete temp;}
2720       }
2721       fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);
2722     }
2723     else hQtotEtaPhi = (TH3D*)fCfContainer->Project(1, kTrackPhi, kTrackEta, kTrackQtot+iLayer);
2724     hProf2D = (hQtotEtaPhi ? hQtotEtaPhi->Project3DProfile() : 0x0);
2725     if(hQtotEtaPhi) delete hQtotEtaPhi;
2726
2727     if(hProf2D) {
2728       hProf2D->SetStats(kFALSE);
2729       hProf2D->SetMinimum(0.);
2730       hProf2D->SetMaximum(4.);
2731       hProf2D->Draw("samecolz");
2732     }
2733     lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer));
2734     DrawTRDGrid();
2735   }
2736
2737   // PH versus slice number
2738   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2739   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2740   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
2741   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2742
2743   if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
2744   TH2F* rangePHslice=new TH2F("rangePHslice", "", 8, -0.5, 7.5, 10, 0.0, 2000.);
2745   rangePHslice->SetStats(kFALSE);
2746   SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
2747   SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
2748   rangePHslice->Draw();
2749
2750   TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
2751
2752   TH2F* h2F;
2753   TH1D* hF;
2754   if((h2F = dynamic_cast<TH2F*>(fHistos->At(kPHSlice+centralityClass)))) {
2755     hF = Proj2D(h2F);
2756     h2F->SetStats(kFALSE);
2757     h2F->Draw("samecolz");
2758     if(trendValues) {
2759       hF->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
2760       trendValues[12] = funcPol1->GetParameter(0);  // PH plateau
2761       trendValues[13] = funcPol1->GetParError(0);   // PH plateau
2762       trendValues[14] = funcPol1->GetParameter(1);  // PH slope
2763       trendValues[15] = funcPol1->GetParError(1);   // PH slope
2764     }
2765     hF->SetLineWidth(2);
2766     hF->SetLineStyle(2);
2767     hF->Draw("same");
2768   }
2769   delete funcPol1;
2770
2771   // Qtot vs P
2772   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2773   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2774   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
2775   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2776   pad->SetLogz();
2777
2778   if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
2779   TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99);
2780   SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2781   SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
2782   rangeQtotP->SetStats(kFALSE);
2783   rangeQtotP->Draw();
2784
2785   TH2D* hQtotP_IsolatedBC = 0x0;
2786   for(Int_t ibc=0; ibc<3500; ++ibc) {
2787     if(!isIsolated[ibc]) continue;
2788     fCfContainer->SetRangeUser(kEventBC, Double_t(ibc), Double_t(ibc));
2789     TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot);
2790     if(!hQtotP_IsolatedBC) hQtotP_IsolatedBC = temp;
2791     else {hQtotP_IsolatedBC->Add(temp); delete temp;}
2792     for(Int_t il=1; il<6; ++il) {
2793       temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot+il);
2794       hQtotP_IsolatedBC->Add(temp); delete temp;
2795     }
2796   }
2797   fCfContainer->SetRangeUser(kEventBC, 0.0, 3500.0);
2798
2799   TH2D* temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot);
2800   TH2D* hQtotP = temp;
2801   for(Int_t il=1; il<6; ++il) {
2802     temp = (TH2D*)fCfContainer->Project(1, kTrackP, kTrackQtot+il);
2803     hQtotP->Add(temp); delete temp;
2804   }
2805
2806   if(hQtotP_IsolatedBC)
2807     for(Int_t i=1; i<=hQtotP_IsolatedBC->GetXaxis()->GetNbins(); ++i)
2808       hQtotP_IsolatedBC->SetBinContent(i, 1, 0.0);
2809   TH1D* hQtotProj_IsolatedBC = (hQtotP_IsolatedBC ? Proj2D(hQtotP_IsolatedBC) : 0x0);
2810   if(hQtotProj_IsolatedBC) SetStyle(hQtotProj_IsolatedBC, 2, kBlue, 2, 1, kBlue, 1);
2811   if(trendValues && hQtotProj_IsolatedBC && hQtotProj_IsolatedBC->GetEntries()>2) {
2812     trendValues[30] = hQtotProj_IsolatedBC->GetBinContent(hQtotProj_IsolatedBC->FindBin(1.0));   // Landau MPV at 1GeV/c
2813     trendValues[31] = hQtotProj_IsolatedBC->GetBinError(hQtotProj_IsolatedBC->FindBin(1.0));     // Landau width at 1 GeV/c
2814   }
2815   if(hQtotP)
2816     for(Int_t i=1; i<=hQtotP->GetXaxis()->GetNbins(); ++i)
2817       hQtotP->SetBinContent(i, 1, 0.0);
2818   TH1D* hQtotProj = (hQtotP ? Proj2D(hQtotP) : 0x0);
2819   if(hQtotProj) SetStyle(hQtotProj, 2, kBlue, 2, 1, kBlue, 1);
2820   if(trendValues && hQtotProj && hQtotProj->GetEntries()>2) {
2821     trendValues[16] = hQtotProj->GetBinContent(hQtotProj->FindBin(1.0));   // Landau MPV at 1GeV/c
2822     trendValues[17] = hQtotProj->GetBinError(hQtotProj->FindBin(1.0));     // Landau width at 1 GeV/c
2823   }
2824   if(useIsolatedBC && hQtotP_IsolatedBC) {
2825     hQtotP_IsolatedBC->SetStats(kFALSE);
2826     for(Int_t i=1; i<=hQtotP_IsolatedBC->GetXaxis()->GetNbins(); ++i) hQtotP_IsolatedBC->SetBinContent(i, 1, 0.0);
2827     hQtotP_IsolatedBC->Draw("samecolz");
2828     hQtotProj_IsolatedBC->Draw("same");
2829   }
2830   if(!useIsolatedBC && hQtotP) {
2831     hQtotP->SetStats(kFALSE);
2832     hQtotP->Draw("samecolz");
2833     hQtotProj->Draw("same");
2834   }
2835
2836   // reset the user range on the event multiplicity
2837   fCfContainer->SetRangeUser(kEventMult, 0.0, 6.0, kTRUE);
2838   if(cutTOFbc) fCfContainer->SetRangeUser(kTrackTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2839 }
2840
2841
2842 //_________________________________________________________________
2843 Bool_t AliTRDcheckESD::PlotCentSummary(Double_t* trendValues) {
2844
2845   Bool_t isGoodForSaving=kFALSE;
2846
2847   trendValues = trendValues;
2848
2849   TLatex* lat=new TLatex();
2850   lat->SetTextSize(0.06);
2851   lat->SetTextColor(2);
2852
2853   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2854   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2855   gPad->Divide(3,3,0.,0.);
2856   TList* l=gPad->GetListOfPrimitives();
2857
2858   TPad* pad=0x0;
2859
2860   if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
2861   TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.4);
2862   rangeEffPt->SetStats(kFALSE);
2863   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2864   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2865
2866   TH3F *h3(NULL), *h3p(NULL), *h3n(NULL);
2867   Int_t padsForEffs[5] = {0,3,6,1,4};
2868   for(Int_t iCent=1; iCent<6; ++iCent) {
2869     // TPC-TRD matching efficiencies
2870     pad = ((TPad*)l->At(padsForEffs[iCent-1])); pad->cd();
2871     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2872     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2873
2874     if(!(h3p = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+iCent)))) continue;
2875     if(!(h3n = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+iCent)))) continue;
2876     // =============================================
2877     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+iCent)))) continue;
2878     TH1F* hFeffP = EfficiencyTRD(h3p, h3, kTRUE);
2879     //
2880     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+iCent)))) continue;
2881     TH1F* hFeffN = EfficiencyTRD(h3n, h3, kTRUE);
2882     // =============================================
2883     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+iCent)))) continue;
2884     TH1F* hFeffP4 = EfficiencyTRD(h3p, h3, kTRUE);
2885     //
2886     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+iCent)))) continue;
2887     TH1F* hFeffN4 = EfficiencyTRD(h3n, h3, kTRUE);
2888     // =============================================
2889     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+iCent)))) continue;
2890     TH1F* hFeffP5 = EfficiencyTRD(h3p, h3, kTRUE);
2891     //
2892     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+iCent)))) continue;
2893     TH1F* hFeffN5 = EfficiencyTRD(h3n, h3, kTRUE);
2894     // =============================================
2895     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+iCent)))) continue;
2896     TH1F* hFeffP6 = EfficiencyTRD(h3p, h3, kTRUE);
2897     //
2898     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+iCent)))) continue;
2899     TH1F* hFeffN6 = EfficiencyTRD(h3n, h3, kTRUE);
2900
2901     rangeEffPt->Draw();
2902
2903     TLine line;
2904     line.SetLineStyle(2);
2905     line.SetLineWidth(2);
2906     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2907     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2908     line.SetLineStyle(1);
2909     line.SetLineWidth(1);
2910     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 1.0, rangeEffPt->GetXaxis()->GetXmax(), 1.0);
2911     if(hFeffP) SetStyle(hFeffP, 1, kRed, 1, 24, kRed, 1);
2912     if(hFeffP4) SetStyle(hFeffP4, 1, kRed, 1, 25, kRed, 1);
2913     if(hFeffP5) SetStyle(hFeffP5, 1, kRed, 1, 26, kRed, 1);
2914     if(hFeffP6) SetStyle(hFeffP6, 1, kRed, 1, 27, kRed, 1);
2915     if(hFeffN) SetStyle(hFeffN, 1, kBlue, 1, 24, kBlue, 1);
2916     if(hFeffN4) SetStyle(hFeffN4, 1, kBlue, 1, 25, kBlue, 1);
2917     if(hFeffN5) SetStyle(hFeffN5, 1, kBlue, 1, 26, kBlue, 1);
2918     if(hFeffN6) SetStyle(hFeffN6, 1, kBlue, 1, 27, kBlue, 1);
2919
2920     TLegend* leg=new TLegend(0.16, 0.7, 0.61, 0.89);
2921     leg->SetFillColor(0);
2922     leg->SetNColumns(2);
2923     leg->SetTextSize(0.039);
2924     leg->SetMargin(0.1);
2925     if(hFeffP && hFeffP->Integral()>0.001) {
2926       isGoodForSaving = kTRUE;
2927       hFeffP->Draw("same");
2928       leg->AddEntry(hFeffP, "pos. (#geq 1 trcklt)", "p");
2929     }
2930     if(hFeffN && hFeffN->Integral()>0.001) {
2931       isGoodForSaving = kTRUE;
2932       hFeffN->Draw("same");
2933       leg->AddEntry(hFeffN, "neg. (#geq 1 trcklt)", "p");
2934     }
2935     if(hFeffP4 && hFeffP4->Integral()>0.001) {
2936       isGoodForSaving = kTRUE;
2937       hFeffP4->Draw("same");
2938       leg->AddEntry(hFeffP4, "pos. (4 trcklts)", "p");
2939     }
2940     if(hFeffN4 && hFeffN4->Integral()>0.001) {
2941       isGoodForSaving = kTRUE;
2942       hFeffN4->Draw("same");
2943       leg->AddEntry(hFeffN4, "neg. (4 trcklts)", "p");
2944     }
2945     if(hFeffP5 && hFeffP5->Integral()>0.001) {
2946       isGoodForSaving = kTRUE;
2947       hFeffP5->Draw("same");
2948       leg->AddEntry(hFeffP5, "pos. (5 trcklts)", "p");
2949     }
2950     if(hFeffN5 && hFeffN5->Integral()>0.001) {
2951       isGoodForSaving = kTRUE;
2952       hFeffN5->Draw("same");
2953       leg->AddEntry(hFeffN5, "neg. (5 trcklts)", "p");
2954     }
2955     if(hFeffP6 && hFeffP6->Integral()>0.001) {
2956       isGoodForSaving = kTRUE;
2957       hFeffP6->Draw("same");
2958       leg->AddEntry(hFeffP6, "pos. (6 trcklts)", "p");
2959     }
2960     if(hFeffN6 && hFeffN6->Integral()>0.001) {
2961       isGoodForSaving = kTRUE;
2962       hFeffN6->Draw("same");
2963       leg->AddEntry(hFeffN6, "neg. (6 trklts)", "p");
2964     }
2965
2966     if(isGoodForSaving) {
2967       if(iCent==1) leg->Draw();
2968       lat->DrawLatex(5.6, 1.3, Form("Centrality class %d", iCent));
2969       lat->DrawLatex(0.5, 1.42, "TPC-TRD matching efficiency");
2970     }
2971   }   // end loop over multiplicity intervals
2972
2973   // Number of clusters per TRD track
2974   pad = ((TPad*)l->At(2)); pad->cd();
2975   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2976   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2977   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2978   if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
2979   TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
2980   SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
2981   SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2982   rangeNcls->SetStats(kFALSE);
2983   rangeNcls->Draw();
2984
2985   TH2F* h2F[6]; TH1D* proj[6];
2986   TLegend* leg=new TLegend(0.2, 0.7, 0.5, 0.95);
2987   leg->SetFillColor(0);
2988   Bool_t isGood=kFALSE;
2989   for(Int_t iCent=0; iCent<6; ++iCent) {
2990     h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+iCent));
2991     proj[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projCent%d",iCent)) : 0x0);
2992     if(proj[iCent]) {
2993       proj[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2994       Double_t maximum = proj[iCent]->GetMaximum();
2995       if(maximum>1.0)
2996         proj[iCent]->Scale(1.0/maximum);
2997       proj[iCent]->SetStats(kFALSE);
2998       proj[iCent]->Draw("same");
2999       leg->AddEntry(proj[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
3000       isGood = kTRUE;
3001     }
3002   }
3003   if(isGood) leg->Draw();
3004   isGoodForSaving = isGoodForSaving || isGood;
3005
3006   // Qtot vs P
3007   pad = ((TPad*)l->At(5)); pad->cd();
3008   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
3009   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
3010   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3011   if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
3012   TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
3013   SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
3014   SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
3015   rangeQtot->SetStats(kFALSE);
3016   rangeQtot->Draw();
3017
3018   TH1D* projQ[6];
3019   TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.95);
3020   leg2->SetFillColor(0);
3021   isGood = kFALSE;
3022   for(Int_t iCent=0; iCent<6; ++iCent) {
3023     h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kQtotP+iCent));
3024     projQ[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projQCent%d",iCent)) : 0x0);
3025     if(projQ[iCent]) {
3026       projQ[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
3027       Double_t maximum = projQ[iCent]->GetMaximum();
3028       if(maximum>1.0)
3029         projQ[iCent]->Scale(1.0/maximum);
3030       projQ[iCent]->SetStats(kFALSE);
3031       projQ[iCent]->Draw("same");
3032       leg2->AddEntry(projQ[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
3033       isGood = kTRUE;
3034     }
3035   }
3036   if(isGood) leg2->Draw();
3037   isGoodForSaving = isGoodForSaving || isGood;
3038   return isGoodForSaving;
3039 }
3040
3041
3042 //_________________________________________________________________
3043 Bool_t AliTRDcheckESD::PlotTrackingSummary(Int_t centralityClass, Double_t* trendValues) {
3044
3045   Bool_t isGoodForSaving=kFALSE;
3046
3047   TLatex *lat=new TLatex();
3048   lat->SetTextSize(0.07);
3049   lat->SetTextColor(2);
3050   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
3051   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
3052   gPad->Divide(3,3,0.,0.);
3053   TList* l=gPad->GetListOfPrimitives();
3054   // eta-phi distr. for positive TPC tracks
3055   TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
3056   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3057   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3058   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3059   if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
3060   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
3061   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
3062   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
3063   rangeEtaPhi->SetStats(kFALSE);
3064   rangeEtaPhi->Draw();
3065   lat->DrawLatex(-0.9, 3.6, "TPC positive ref. tracks");
3066
3067   TH3F* h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass));
3068   TH2F* h2FtpcP = 0x0;
3069   Float_t nada=0.0;
3070   if(h3F && h3F->GetEntries()>10) {
3071     h2FtpcP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3072     h2FtpcP->SetStats(kFALSE);
3073     h2FtpcP->Draw("samecolz"); isGoodForSaving = kTRUE;
3074     isGoodForSaving = kTRUE;
3075   }
3076   //-----------------
3077   // eta-phi distr. for negative TPC tracks
3078   pad = ((TVirtualPad*)l->At(1)); pad->cd();
3079   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3080   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3081   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3082   rangeEtaPhi->Draw();
3083   lat->DrawLatex(-0.9, 3.6, "TPC negative ref. tracks");
3084
3085   h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass));
3086   TH2F* h2FtpcN = 0x0;
3087   if(h3F && h3F->GetEntries()>10) {
3088     h2FtpcN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3089     h2FtpcN->SetStats(kFALSE);
3090     h2FtpcN->Draw("samecolz");
3091     isGoodForSaving = kTRUE;
3092   }
3093   //----------------------------------------------
3094   // eta-phi distr. for positive TRD tracks
3095   pad = ((TVirtualPad*)l->At(3)); pad->cd();
3096   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3097   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3098   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3099   rangeEtaPhi->Draw();
3100   lat->DrawLatex(-0.9, 3.6, "TRD positive ref. tracks");
3101
3102   h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass));
3103   TH2F* h2FtrdP = 0x0;
3104   if(h3F && h3F->GetEntries()>10) {
3105     h2FtrdP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3106     h2FtrdP->SetStats(kFALSE);
3107     h2FtrdP->SetMaximum((h2FtpcP ? h2FtpcP->GetMaximum() : h2FtrdP->GetMaximum()));
3108     h2FtrdP->Draw("samecolz");
3109     isGoodForSaving=kTRUE;
3110   }
3111   //--------------------------------------------
3112   // eta-phi distr. for negative TRD tracks
3113   pad = ((TVirtualPad*)l->At(4)); pad->cd();
3114   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3115   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3116   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3117   rangeEtaPhi->Draw();
3118   lat->DrawLatex(-0.9, 3.6, "TRD negative ref. tracks");
3119
3120   h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass));
3121   TH2F* h2FtrdN = 0x0;
3122   if(h3F && h3F->GetEntries()>10) {
3123     h2FtrdN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3124     h2FtrdN->SetStats(kFALSE);
3125     h2FtrdN->SetMaximum(h2FtpcN ? h2FtpcN->GetMaximum() : h2FtrdN->GetMaximum());
3126     h2FtrdN->Draw("samecolz");
3127     isGoodForSaving=kTRUE;
3128   }
3129   //----------------------------------------------
3130   // eta-phi efficiency for positive TRD tracks
3131   pad = ((TVirtualPad*)l->At(6)); pad->cd();
3132   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3133   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3134   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3135   rangeEtaPhi->Draw();
3136   lat->DrawLatex(-0.9, 3.6, "Efficiency positive tracks");
3137
3138   TH2F* h2Feff = (h2FtrdP ? (TH2F*)h2FtrdP->Clone("h2FeffPos") : 0x0);
3139   if(h2Feff) {
3140     h2Feff->Reset();
3141     h2Feff->SetStats(kFALSE);
3142     h2Feff->Divide(h2FtrdP, h2FtpcP);
3143     h2Feff->SetMaximum(1.0);
3144     if(h2Feff->GetEntries()>1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; }
3145   }
3146   //-------------------------------------------------
3147   // eta-phi efficiency for negative TRD tracks
3148   pad = ((TVirtualPad*)l->At(7)); pad->cd();
3149   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3150   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3151   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3152   rangeEtaPhi->Draw();
3153   lat->DrawLatex(-0.9, 3.6, "Efficiency negative tracks");
3154
3155   h2Feff = (h2FtrdN ? (TH2F*)h2FtrdN->Clone("h2FeffNeg") : 0x0);
3156   if(h2Feff) {
3157     h2Feff->Reset();
3158     h2Feff->SetStats(kFALSE);
3159     h2Feff->Divide(h2FtrdN, h2FtpcN);
3160     h2Feff->SetMaximum(1.0);
3161     if(h2Feff->GetEntries()>0.1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; }
3162   }
3163   //-----------------------------------------------------
3164   // <ntracklets> vs (phi,eta)
3165   pad = ((TVirtualPad*)l->At(2)); pad->cd();
3166   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3167   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3168   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3169   rangeEtaPhi->Draw();
3170   lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>");
3171
3172   TProfile2D* hProf2D;
3173   if((hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvNtrkl+centralityClass)))) {
3174     if(hProf2D->GetEntries()>10) {
3175       hProf2D->SetStats(kFALSE);
3176       hProf2D->SetMinimum(0.);
3177       hProf2D->SetMaximum(6.);
3178       if(hProf2D->GetEntries()>1) { hProf2D->Draw("samecolz"); isGoodForSaving = kTRUE; }
3179     }
3180   }
3181   //---------------------------------------------------------
3182   // TPC-TRD matching efficiency vs pt
3183   pad = ((TVirtualPad*)l->At(5)); pad->cd();
3184   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
3185   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3186   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3187   TH1F* hFeffP = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3188               dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass)), kTRUE);
3189   TH1F* hFeffN = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3190               dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass)), kTRUE);
3191   TH1F* hFeffP4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3192         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+centralityClass)), kTRUE);
3193   TH1F* hFeffN4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3194         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+centralityClass)), kTRUE);
3195   TH1F* hFeffP5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3196         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+centralityClass)), kTRUE);
3197   TH1F* hFeffN5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3198         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+centralityClass)), kTRUE);
3199   TH1F* hFeffP6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3200         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+centralityClass)), kTRUE);
3201   TH1F* hFeffN6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3202         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+centralityClass)), kTRUE);
3203
3204   TF1* funcConst = new TF1("funcConst", "[0]", 1.0, 3.0);
3205
3206   if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
3207   TH2F* rangeEffPt2=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
3208   rangeEffPt2->SetStats(kFALSE);
3209   SetStyle(rangeEffPt2->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3210   SetStyle(rangeEffPt2->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
3211   rangeEffPt2->Draw();
3212   lat->DrawLatex(0.5, 1.42, "TRD-TPC matching efficiency");
3213   //++++++++++++++++++
3214   TLine line;
3215   line.SetLineStyle(2);
3216   line.SetLineWidth(2);
3217   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.7, rangeEffPt2->GetXaxis()->GetXmax(), 0.7);
3218   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.9, rangeEffPt2->GetXaxis()->GetXmax(), 0.9);
3219   line.SetLineStyle(1);
3220   line.SetLineWidth(1);
3221   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 1.0, rangeEffPt2->GetXaxis()->GetXmax(), 1.0);
3222   TLegend* leg=new TLegend(0.2, 0.7, 0.6, 0.89);
3223   leg->SetNColumns(2);
3224   leg->SetFillColor(0);
3225   if(hFeffP){
3226     hFeffP->SetMarkerStyle(24);
3227     hFeffP->SetMarkerColor(2);
3228     hFeffP->SetLineColor(2);
3229     if(trendValues && hFeffP->GetEntries()>1) {
3230       hFeffP->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3231       trendValues[0] = funcConst->GetParameter(0);
3232       trendValues[1] = funcConst->GetParError(0);
3233     }
3234     if(hFeffP->Integral()>0.001) {
3235       hFeffP->Draw("same");
3236       leg->AddEntry(hFeffP, "positives (#geq 1 tracklet)", "p");
3237     }
3238   }
3239   if(hFeffN){
3240     hFeffN->SetMarkerStyle(24);
3241     hFeffN->SetMarkerColor(4);
3242     hFeffN->SetLineColor(4);
3243     if(trendValues && hFeffN->GetEntries()>1) {
3244       hFeffN->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3245       trendValues[2] = funcConst->GetParameter(0);
3246       trendValues[3] = funcConst->GetParError(0);
3247     }
3248     if(hFeffN->Integral()>0.001) {
3249       hFeffN->Draw("same");
3250       leg->AddEntry(hFeffN, "negatives (#geq 1 tracklet)", "p");
3251     }
3252   }
3253   if(hFeffP4){
3254     hFeffP4->SetMarkerStyle(25);
3255     hFeffP4->SetMarkerColor(2);
3256     hFeffP4->SetLineColor(2);
3257     if(hFeffP4->Integral()>0.001) {
3258       hFeffP4->Draw("same");
3259       leg->AddEntry(hFeffP4, "positives (4 tracklets)", "p");
3260     }
3261   }
3262   if(hFeffN4){
3263     hFeffN4->SetMarkerStyle(25);
3264     hFeffN4->SetMarkerColor(4);
3265     hFeffN4->SetLineColor(4);
3266     if(hFeffN4->Integral()>0.001) {
3267       hFeffN4->Draw("same");
3268       leg->AddEntry(hFeffN4, "negatives (4 tracklets)", "p");
3269     }
3270   }
3271   if(hFeffP5){
3272     hFeffP5->SetMarkerStyle(26);
3273     hFeffP5->SetMarkerColor(2);
3274     hFeffP5->SetLineColor(2);
3275     if(hFeffP5->Integral()>0.001) {
3276       hFeffP5->Draw("same");
3277       leg->AddEntry(hFeffP5, "positives (5 tracklets)", "p");
3278     }
3279   }
3280   if(hFeffN5){
3281     hFeffN5->SetMarkerStyle(26);
3282     hFeffN5->SetMarkerColor(4);
3283     hFeffN5->SetLineColor(4);
3284     if(hFeffN5->Integral()>0.001) {
3285       hFeffN5->Draw("same");
3286       leg->AddEntry(hFeffN5, "negatives (5 tracklets)", "p");
3287     }
3288   }
3289   if(hFeffP6){
3290     hFeffP6->SetMarkerStyle(27);
3291     hFeffP6->SetMarkerColor(2);
3292     hFeffP6->SetLineColor(2);
3293     if(hFeffP6->Integral()>0.001) {
3294       hFeffP6->Draw("same");
3295       leg->AddEntry(hFeffP6, "positives (6 tracklets)", "p");
3296     }
3297   }
3298   if(hFeffN6){
3299     hFeffN6->SetMarkerStyle(27);
3300     hFeffN6->SetMarkerColor(4);
3301     hFeffN6->SetLineColor(4);
3302     if(hFeffN6->Integral()>0.001) {
3303       hFeffN6->Draw("same");
3304       leg->AddEntry(hFeffN6, "negatives (6 tracklets)", "p");
3305     }
3306   }
3307   leg->Draw();
3308
3309   //--------------------------------------------------------------
3310   // Nclusters per TRD track
3311   pad = ((TVirtualPad*)l->At(8)); pad->cd();
3312   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
3313   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3314   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3315   pad->SetLogz();
3316   if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
3317   TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
3318   SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3319   SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
3320   rangeNclsP->SetStats(kFALSE);
3321   rangeNclsP->Draw();
3322   lat->DrawLatex(1.0, 205., "TRD Clusters / track");
3323
3324   TH2F* hNclsVsP=0x0;
3325   if((hNclsVsP = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+centralityClass)))) {
3326     hNclsVsP->SetStats(kFALSE);
3327     if(hNclsVsP->GetEntries()>10) {
3328       hNclsVsP->Draw("samecolz"); isGoodForSaving=kTRUE;
3329       if(trendValues) {
3330         TProfile* h2FProf = hNclsVsP->ProfileX("nclsVsPprof");
3331         h2FProf->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3332         trendValues[4] = funcConst->GetParameter(0);
3333         trendValues[5] = funcConst->GetParError(0);
3334       }
3335     }
3336   }
3337
3338   delete funcConst;
3339   return isGoodForSaving;
3340 }
3341
3342
3343 //_________________________________________________________________
3344 Bool_t AliTRDcheckESD::PlotPidSummary(Int_t centralityClass, Double_t* trendValues) {
3345
3346   Bool_t isGoodForSaving=kFALSE;
3347
3348   TLatex *lat=new TLatex();
3349   lat->SetTextSize(0.07);
3350   lat->SetTextColor(2);
3351   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
3352   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
3353   gPad->Divide(3,3,0.,0.);
3354   TList* l=gPad->GetListOfPrimitives();
3355   // eta-phi distr. for <Qtot> in layer 0
3356   TVirtualPad* pad;
3357   TProfile2D* hProf2D;
3358   if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
3359   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
3360   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
3361   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
3362   rangeEtaPhi->SetStats(kFALSE);
3363
3364   for(Int_t iLayer=0; iLayer<6; ++iLayer) {
3365     pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
3366     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3367     pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3368     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3369     rangeEtaPhi->Draw();
3370     lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer));
3371
3372     if(!(hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvQtot+6*centralityClass+iLayer)))) continue;
3373     if(hProf2D && hProf2D->GetEntries()>10) {
3374       hProf2D->SetStats(kFALSE);
3375       hProf2D->SetMinimum(0.);
3376       hProf2D->SetMaximum(4.);
3377       if(hProf2D->GetEntries()>10) { hProf2D->Draw("samecolz"); isGoodForSaving=kTRUE; }
3378     }
3379   }
3380
3381   // PH versus slice number
3382   pad = ((TVirtualPad*)l->At(2)); pad->cd();
3383   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3384   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3385   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3386   if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
3387   TH2F* rangePHslice = new TH2F("rangePHslice", "", 10, -0.5, 7.5, 10, 0.0, 2000.0);
3388   SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
3389   SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
3390   rangePHslice->SetStats(kFALSE);
3391   rangePHslice->Draw();
3392
3393   TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
3394
3395   TH2F* h2F;
3396   TH1D* hF;
3397   if((h2F = dynamic_cast<TH2F*>(fHistos->At(kPHSlice+centralityClass)))) {
3398     if(h2F && h2F->GetEntries()>10) {
3399       hF = Proj2D(h2F);
3400       h2F->SetStats(kFALSE);
3401       h2F->Draw("samecolz");
3402       isGoodForSaving=kTRUE;
3403       if(trendValues) {
3404         hF->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
3405         trendValues[6] = funcPol1->GetParameter(0);
3406         trendValues[7] = funcPol1->GetParError(0);
3407         trendValues[8] = funcPol1->GetParameter(1);
3408         trendValues[9] = funcPol1->GetParError(1);
3409       }
3410       hF->SetLineWidth(2);
3411       hF->Draw("same");
3412     }
3413   }
3414   delete funcPol1;
3415
3416   // Qtot vs P
3417   pad = ((TVirtualPad*)l->At(5)); pad->cd();
3418   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3419   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3420   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3421   pad->SetLogz();
3422   if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
3423   TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99);
3424   SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3425   SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
3426   rangeQtotP->SetStats(kFALSE);
3427   rangeQtotP->Draw();
3428
3429   if((h2F = dynamic_cast<TH2F*>(fHistos->At(kQtotP+centralityClass)))) {
3430     if(h2F && h2F->GetEntries()>10) {
3431       h2F->SetStats(kFALSE);
3432       h2F->Draw("samecolz");
3433       isGoodForSaving=kTRUE;
3434       hF = Proj2D(h2F);
3435       hF->SetLineWidth(2);
3436       hF->Draw("same");
3437       if(trendValues) {
3438         trendValues[10] = hF->GetBinContent(hF->FindBin(1.0));
3439         trendValues[11] = hF->GetBinError(hF->FindBin(1.0));
3440       }
3441     }
3442   }
3443   return isGoodForSaving;
3444 }
3445
3446 //__________________________________________________________________________________________________
3447 void AliTRDcheckESD::DrawTRDGrid() {
3448   //
3449   //   Draw a grid of lines showing the TRD supermodule and stack structure in (eta,phi) coordinates.
3450   //   The canvas on which to draw must already exist.
3451   //
3452   TLine line;
3453   line.SetLineColor(2);
3454   line.SetLineWidth(1);
3455   line.SetLineStyle(2);
3456   for(Int_t i=0; i<=9; ++i) {
3457     line.DrawLine(-1.0, 2.0*TMath::Pi()/18.0*i, +1.0, 2.0*TMath::Pi()/18.0*i);
3458     line.DrawLine(-1.0, -2.0*TMath::Pi()/18.0*i, +1.0, -2.0*TMath::Pi()/18.0*i);
3459   }
3460   line.DrawLine(-0.85, -3.2, -0.85, +3.2);
3461   line.DrawLine(-0.54, -3.2, -0.54, +3.2);
3462   line.DrawLine(-0.16, -3.2, -0.16, +3.2);
3463   line.DrawLine(+0.16, -3.2, +0.16, +3.2);
3464   line.DrawLine(+0.54, -3.2, +0.54, +3.2);
3465   line.DrawLine(+0.85, -3.2, +0.85, +3.2);
3466 }
3467
3468 //_________________________________________________________________
3469 void AliTRDcheckESD::SetStyle(TH1* hist,
3470                               Int_t lineStyle, Int_t lineColor, Int_t lineWidth,
3471                               Int_t markerStyle, Int_t markerColor, Int_t markerSize) {
3472   //
3473   // Set style settings for histograms
3474   //
3475   hist->SetLineStyle(lineStyle);
3476   hist->SetLineColor(lineColor);
3477   hist->SetLineWidth(lineWidth);
3478   hist->SetMarkerStyle(markerStyle);
3479   hist->SetMarkerColor(markerColor);
3480   hist->SetMarkerSize(markerSize);
3481 }
3482
3483 //____________________________________________________________________
3484 void AliTRDcheckESD::SetStyle(TAxis* axis, const Char_t* title, Float_t titleSize, Float_t titleOffset, Bool_t centerTitle,
3485                               Float_t labelSize) {
3486   //
3487   // Set style settings for axes
3488   //
3489   axis->SetTitle(title);
3490   axis->SetTitleSize(titleSize);
3491   axis->SetTitleOffset(titleOffset);
3492   axis->CenterTitle(centerTitle);
3493   axis->SetLabelSize(labelSize);
3494 }
3495
3496 //____________________________________________________________________
3497 void AliTRDcheckESD::FindIsolatedBCs(TH1D* bcHist, Bool_t isIsolated[3500]) {
3498   //
3499   // Find the isolated bunch crossings
3500   //
3501   Int_t isolationSize = 10;      // number of free bunches in both directions
3502   for(Int_t bcBin=1; bcBin<=bcHist->GetXaxis()->GetNbins(); ++bcBin) {
3503     Int_t bc = TMath::Nint(bcHist->GetBinCenter(bcBin));
3504     if(bc<-0.001 || bc>3499.01) {
3505       isIsolated[bc] = kFALSE;
3506       continue;
3507     }
3508     Double_t entries = bcHist->GetBinContent(bcBin);
3509     if(entries<0.001) {
3510       isIsolated[bc] = kFALSE;
3511       continue;     // no entries
3512     }
3513
3514     // check isolation
3515     isIsolated[bc] = kTRUE;
3516     for(Int_t ibc = TMath::Max(1,bcBin-isolationSize); ibc <= TMath::Min(3499, bcBin+isolationSize); ++ibc) {
3517       if(ibc==bcBin) continue;
3518       if(bcHist->GetBinContent(ibc)>0.01) {
3519         isIsolated[bc] = kFALSE;
3520         break;
3521       }
3522     }
3523   }   // end loop over BC bins
3524
3525   cout << "Isolated bunches: " << endl;
3526   for(Int_t ibc=0; ibc<3500; ++ibc)
3527     if(isIsolated[ibc]) cout << "BC #" << ibc << endl;
3528 }