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