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   //
 515   for(Int_t i=0; i<nTrigFired; ++i)
 516     ((TH1F*)fHistos->At(kTriggerDefs))->Fill(triggerIndices[i]);
 517
 518   if(!hasGoodTriggers) {
 519     PostData(1, fHistos);
 520     delete triggers;
 521     delete userTriggers;
 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 triggers;
 822   delete userTriggers;
 823   delete [] valuesMatchingPhiEtaCF;
 824   delete [] valuesMatchingPtCF;
 825   delete [] valuesBCCF;
 826   delete [] valuesCentCF;
 827   delete [] valuesQtotCF;
 828   delete [] valuesPHCF;
 829   if(valuesExpertCF) delete [] valuesExpertCF;
 830
 831   PostData(1, fHistos);
 832 }
 833
 834 //____________________________________________________________________
 835 TObjArray* AliTRDcheckESD::Histos()
 836 {
 837 // Retrieve histograms array if already build or build it
 838
 839   if(fHistos) return fHistos;
 840
 841   fHistos = new TObjArray(kNhistos+1);
 842   fHistos->SetOwner(kTRUE);
 843
 844   TH1 *h = NULL;
 845
 846   // clusters per track
 847   const Int_t kNpt(30);
 848   Float_t pt(0.2);
 849   Float_t binsPt[kNpt+1];
 850   for(Int_t i=0;i<kNpt+1; i++,pt+=(TMath::Exp(i*i*.001)-1.)) binsPt[i]=pt;
 851   if(!(h = (TH2I*)gROOT->FindObject("hNCl"))){
 852     h = new TH2I("hNCl", "Clusters per TRD track;N_{cl}^{TRD};SPECIES;entries", 60, 0., 180., 10, -0.5, 9.5);
 853     TAxis *ay(h->GetYaxis());
 854     ay->SetLabelOffset(0.015);
 855     for(Int_t i(0); i<AliPID::kSPECIES; i++){
 856       ay->SetBinLabel(2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i)));
 857       ay->SetBinLabel(2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i)));
 858     }
 859   } else h->Reset();
 860   fHistos->AddAt(h, kNCl); fNRefFigures++;
 861
 862   // status bits histogram
 863   const Int_t kNbits(5);
 864   Float_t bits(.5);
 865   Float_t binsBits[kNbits+1];
 866   for(Int_t i=0; i<kNbits+1; i++,bits+=1.) binsBits[i]=bits;
 867   if(!(h = (TH2I*)gROOT->FindObject("hTRDstat"))){
 868     h = new TH2I("hTRDstat", "TRD status bits;p_{t} @ TRD [GeV/c];status;entries", kNpt, binsPt, kNbits, binsBits);
 869     TAxis *ay(h->GetYaxis());
 870     ay->SetBinLabel(1, "kTPCout");
 871     ay->SetBinLabel(2, "kTRDin");
 872     ay->SetBinLabel(3, "kTRDout");
 873     ay->SetBinLabel(4, "kTRDpid");
 874     ay->SetBinLabel(5, "kTRDrefit");
 875   } else h->Reset();
 876   fHistos->AddAt(h, kTRDstat);
 877
 878   // energy loss
 879   if(!(h = (TH2I*)gROOT->FindObject("hTRDmom"))){
 880     h = new TH2I("hTRDmom", "TRD energy loss;p_{inner} - p_{ly} [GeV/c];ly;entries", 100, -1., 2., 6, -0.5, 5.5);
 881   } else h->Reset();
 882   fHistos->AddAt(h, kTRDmom);
 883   //if(!HasMC()) return fHistos;
 884
 885   // pt resolution
 886   const Int_t kNdpt(100), kNspec(4*AliPID::kSPECIES);
 887   Float_t dpt(-3.), spec(-0.5);
 888   Float_t binsDPt[kNdpt+1], binsSpec[kNspec+1];
 889   for(Int_t i=0; i<kNdpt+1; i++,dpt+=6.e-2) binsDPt[i]=dpt;
 890   for(Int_t i=0; i<kNspec+1; i++,spec+=1.) binsSpec[i]=spec;
 891   if(!(h = (TH3S*)gROOT->FindObject("hPtRes"))){
 892     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);
 893     TAxis *az(h->GetZaxis());
 894     az->SetLabelOffset(0.015);
 895     for(Int_t i(0); i<AliPID::kSPECIES; i++){
 896       az->SetBinLabel(2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i)));
 897       az->SetBinLabel(2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i)));
 898       az->SetBinLabel(10+2*i+1, Form("%s^{-}", AliPID::ParticleLatexName(i)));
 899       az->SetBinLabel(10+2*i+2, Form("%s^{+}", AliPID::ParticleLatexName(i)));
 900     }
 901   } else h->Reset();
 902   fHistos->AddAt(h, kPtRes);
 903
 904   // TPC event vertex distribution
 905   if(!(h = (TH1F*)gROOT->FindObject("hTPCVertex"))){
 906     h = new TH1F("hTPCVertex", "Event vertex Z coord. from TPC tracks", 100, -25., 25.);
 907   } else h->Reset();
 908   fHistos->AddAt(h, kTPCVertex);
 909
 910   // Event vertex
 911   if(!(h = (TH1F*)gROOT->FindObject("hEventVertex"))){
 912     h = new TH1F("hEventVertex", "Event vertex Z coord.", 100, -25., 25.);
 913   } else h->Reset();
 914   fHistos->AddAt(h, kEventVertex);
 915
 916   // Number of all tracks
 917   if(!(h = (TH1I*)gROOT->FindObject("hNTracksAll"))){
 918     h = new TH1I("hNTracksAll", "Number of tracks per event, event vertex cuts", 5000, 0, 5000);
 919   } else h->Reset();
 920   fHistos->AddAt(h, kNTracksAll);
 921
 922   // Number of tracks in acceptance and DCA cut
 923   if(!(h = (TH1I*)gROOT->FindObject("hNTracksAcc"))){
 924     h = new TH1I("hNTracksAcc", Form("Number of tracks per event, |#eta|<%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
 925                                      fgkEta, fgkTrkDCAxy, fgkTrkDCAz), 5000, 0, 5000);
 926   } else h->Reset();
 927   fHistos->AddAt(h, kNTracksAcc);
 928
 929   // Number of tracks in TPC (Ncls>10)
 930   if(!(h = (TH1I*)gROOT->FindObject("hNTracksTPC"))){
 931     h = new TH1I("hNTracksTPC", Form("Number of tracks per event, |#eta|<%.1f, pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 932                                      fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 5000, 0, 5000);
 933   } else h->Reset();
 934   fHistos->AddAt(h, kNTracksTPC);
 935
 936   // Distribution of DCA-xy
 937   if(!(h = (TH1F*)gROOT->FindObject("hDCAxy"))){
 938     h = new TH1F("hDCAxy", "Distribution of transverse DCA", 100, -100., 100.);
 939   } else h->Reset();
 940   fHistos->AddAt(h, kDCAxy);
 941
 942   // Distribution of DCA-z
 943   if(!(h = (TH1F*)gROOT->FindObject("hDCAz"))){
 944     h = new TH1F("hDCAz", "Distribution of longitudinal DCA", 100, -100., 100.);
 945   } else h->Reset();
 946   fHistos->AddAt(h, kDCAz);
 947
 948   Double_t binPtLimits[33] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
 949                              1.0, 1.1, 1.2, 1.3, 1.4,
 950                              1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0,
 951                              3.4, 3.8, 4.2, 4.6, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
 952   // Pt distributions
 953   if(!(h = (TH1F*)gROOT->FindObject("hPt1"))){
 954     h = new TH1F("hPt1", Form("dN/dpt, |#eta|<%.1f and pt>%.1f", fgkEta, fgkPt), 32, binPtLimits);
 955   } else h->Reset();
 956   fHistos->AddAt(h, kPt1);
 957
 958   if(!(h = (TH1F*)gROOT->FindObject("hPt2"))){
 959     h = new TH1F("hPt2", Form("dN/dpt, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
 960                               fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 32, binPtLimits);
 961   } else h->Reset();
 962   fHistos->AddAt(h, kPt2);
 963
 964   if(!(h = (TH1F*)gROOT->FindObject("hPt3pos"))){
 965     h = new TH1F("hPt3pos", Form("dN/dpt (positives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 966                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 967   } else h->Reset();
 968   fHistos->AddAt(h, kPt3pos);
 969
 970   if(!(h = (TH1F*)gROOT->FindObject("hPt3neg"))){
 971     h = new TH1F("hPt3neg", Form("dN/dpt (negatives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
 972                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 973   } else h->Reset();
 974   fHistos->AddAt(h, kPt3neg);
 975
 976   if(!(h = (TH1F*)gROOT->FindObject("hPt4pos"))){
 977     h = new TH1F("hPt4pos", Form("dN/dpt (positives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 978                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 979   } else h->Reset();
 980   fHistos->AddAt(h, kPt4pos);
 981
 982   if(!(h = (TH1F*)gROOT->FindObject("hPt4neg"))){
 983     h = new TH1F("hPt4pos", Form("dN/dpt (negatives), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 984                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 32, binPtLimits);
 985   } else h->Reset();
 986   fHistos->AddAt(h, kPt4neg);
 987
 988   // theta distribution of TRD tracks
 989   if(!(h = (TH1F*)gROOT->FindObject("hTheta"))){
 990     h = new TH1F("hTheta", Form("dN/d#theta, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 991                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 220,.5,2.7);
 992   } else h->Reset();
 993   fHistos->AddAt(h, kTheta);
 994
 995   // phi distribution of TRD tracks
 996   if(!(h = (TH1F*)gROOT->FindObject("hPhi"))){
 997     h = new TH1F("hPhi", Form("dN/d#varphi, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d, nTRDtracklets#geq 1",
 998                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 157,0,6.28);
 999   } else h->Reset();
1000   fHistos->AddAt(h, kPhi);
1001
1002   // TPC cluster distribution
1003   if(!(h = (TH1F*)gROOT->FindObject("hNTPCCl"))){
1004     h = new TH1I("hNTPCCl", Form("Number of TPC clusters/track, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
1005                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 160, 0, 160);
1006   } else h->Reset();
1007   fHistos->AddAt(h, kNTPCCl);
1008
1009   if(!(h = (TH1I*)gROOT->FindObject("hNTPCCl2"))){
1010     h = new TH1F("hNTPCCl2", Form("Number of TPC clusters/track, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, pt>1.0 GeV/c",
1011                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 160, 0, 160);
1012   } else h->Reset();
1013   fHistos->AddAt(h, kNTPCCl2);
1014
1015   // dE/dx vs P for TPC reference tracks
1016   if(!(h = (TH2F*)gROOT->FindObject("hTPCDedx"))){
1017     h = new TH2F("hTPCDedx", Form("TPC dE/dx vs P, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
1018                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 150, 0, 150.);
1019   } else h->Reset();
1020   fHistos->AddAt(h, kTPCDedx);
1021
1022   // eta,phi distribution of TPC reference tracks
1023   if(!(h = (TH2F*)gROOT->FindObject("hEtaPhi"))){
1024     h = new TH2F("hEtaPhi", Form("TPC (#eta,#varphi), |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f, TPC nclusters>%d",
1025                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 50, -1, 1, 157, 0, 6.28);
1026   } else h->Reset();
1027   fHistos->AddAt(h, kEtaPhi);
1028
1029   // Nclusters vs eta distribution for TPC tracks
1030   if(!(h = (TH2F*)gROOT->FindObject("hEtaNclsTPC"))){
1031     h = new TH2F("hEtaNclsTPC", Form("TPC Nclusters vs. #eta, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
1032                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 50, -1, 1, 160, 0, 160.);
1033   } else h->Reset();
1034   fHistos->AddAt(h, kEtaNclsTPC);
1035
1036   // Nclusters vs phi distribution for TPC reference tracks
1037   if(!(h = (TH2F*)gROOT->FindObject("hPhiNclsTPC"))){
1038     h = new TH2F("hPhiNclsTPC", Form("TPC Nclusters vs. #varphi, |#eta|<%.1f and pt>%.1f, |DCAxy|<%.1f, |DCAz|<%.1f",
1039                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz), 157, 0, 6.28, 160, 0, 160.);
1040   } else h->Reset();
1041   fHistos->AddAt(h, kPhiNclsTPC);
1042
1043   // SPD multiplicity distribution
1044   if(!(h = (TH1F*)gROOT->FindObject("hSPDMult"))){
1045     h = new TH1F("hSPDMult", "SPD multiplicity", 10000, -0.5, 9999.5);
1046   } else h->Reset();
1047   fHistos->AddAt(h, kSPDMult);
1048
1049   // Ntracklets/track vs P for TRD reference tracks
1050   Double_t binsP[19] = {0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.7, 2.0,
1051                         2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 9.0, 12.0};
1052   for(Int_t iCent=0; iCent<=5; ++iCent) {
1053     if(!(h = (TH2F*)gROOT->FindObject(Form("hNTrackletsTRD_cent%d",iCent+1)))){
1054       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",
1055                                                                iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 7, -0.5, 6.5);
1056     } else h->Reset();
1057     fHistos->AddAt(h, kNTrackletsTRD+iCent);
1058   }
1059
1060   // Nclusters/track vs P for TRD reference tracks
1061   for(Int_t iCent=0; iCent<=5; ++iCent) {
1062     if(!(h = (TH2F*)gROOT->FindObject(Form("hNClsTrackTRD_cent%d",iCent+1)))){
1063       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",
1064                                                               iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 300, 0., 300.);
1065     } else h->Reset();
1066     fHistos->AddAt(h, kNClsTrackTRD+iCent);
1067   }
1068
1069   // <PH> vs slice number for TRD reference tracklets
1070   for(Int_t iCent=0; iCent<=5; ++iCent) {
1071     if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSlice_cent%d",iCent+1)))){
1072       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",
1073                                     iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 200, 0., 2000.);
1074     } else h->Reset();
1075     fHistos->AddAt(h, kPHSlice+iCent);
1076   }
1077
1078   // <PH> vs slice number for TRD reference tracklets, from TPC pions
1079   for(Int_t iCent=0; iCent<=5; ++iCent) {
1080     if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSliceTPCpions_cent%d",iCent+1)))){
1081       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",
1082                                                                  iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 100, 0., 2000.);
1083     } else h->Reset();
1084     fHistos->AddAt(h, kPHSliceTPCpions+iCent);
1085   }
1086
1087   // TPC dE/dx vs P for TRD reference tracks, pions
1088   for(Int_t iCent=0; iCent<=5; ++iCent) {
1089     if(!(h = (TH2F*)gROOT->FindObject(Form("hTPCdedxPions_cent%d",iCent+1)))){
1090       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",
1091                                          iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 100, 0,100.);
1092     } else h->Reset();
1093     fHistos->AddAt(h, kTPCdedxPions+iCent);
1094   }
1095
1096   // <PH> vs slice number for TRD reference tracklets, from TPC electrons
1097   for(Int_t iCent=0; iCent<=5; ++iCent) {
1098     if(!(h = (TH2F*)gROOT->FindObject(Form("hPHSliceTPCelectrons_cent%d",iCent+1)))){
1099       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",
1100                                                 iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 8, -0.5, 7.5, 100, 0., 2000.);
1101     } else h->Reset();
1102     fHistos->AddAt(h, kPHSliceTPCelectrons+iCent);
1103   }
1104
1105   // TPC dE/dx vs P for TRD reference tracks, electrons
1106   for(Int_t iCent=0; iCent<=5; ++iCent) {
1107     if(!(h = (TH2F*)gROOT->FindObject(Form("hTPCdedxElectrons_cent%d",iCent+1)))){
1108       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",
1109                                              iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, 0.1,10.1, 100, 0,100.);
1110     } else h->Reset();
1111     fHistos->AddAt(h, kTPCdedxElectrons+iCent);
1112   }
1113
1114   // Qtot vs P for TRD reference tracklets
1115   for(Int_t iCent=0; iCent<=5; ++iCent) {
1116     if(!(h = (TH2F*)gROOT->FindObject(Form("hQtotP_cent%d",iCent+1)))){
1117       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",
1118                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 18, binsP, 400, 0., 20);
1119     } else h->Reset();
1120     fHistos->AddAt(h, kQtotP+iCent);
1121   }
1122
1123   // (X,Y,momentum) distribution after AliESDtrack::PropagateTo(r=300.)
1124   if(!(h = (TH3F*)gROOT->FindObject("hPropagXYvsP"))){
1125     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",
1126                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100,-500,500, 100,-500,500, 10, 0.,10.);
1127   } else h->Reset();
1128   fHistos->AddAt(h, kPropagXYvsP);
1129
1130   // (R,Z,momentum) distribution after AliESDtrack::PropagateTo(r=300.)
1131   if(!(h = (TH3F*)gROOT->FindObject("hPropagRZvsP"))){
1132     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",
1133                  fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100,-350., 350., 100,0.,500., 10, 0.,10.);
1134   } else h->Reset();
1135   fHistos->AddAt(h, kPropagRZvsP);
1136
1137   Double_t etaBinLimits[101];
1138   for(Int_t i=0; i<101; i++) etaBinLimits[i] = -1.0 + i*2.0/100.;
1139   Double_t phiBinLimits[151];
1140   for(Int_t i=0; i<151; i++) phiBinLimits[i] = -1.1*TMath::Pi() + i*2.2*TMath::Pi()/150.;
1141   // (eta,detector phi,P) distribution of reference TPC positive tracks
1142   for(Int_t iCent=0; iCent<=5; ++iCent) {
1143     if(!(h = (TH3F*)gROOT->FindObject(Form("hTPCRefTracksPos_cent%d",iCent+1)))){
1144       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",
1145                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1146     } else h->Reset();
1147     fHistos->AddAt(h, kTPCRefTracksPos+iCent);
1148   }
1149
1150   // (eta,detector phi,P) distribution of reference TPC negative tracks
1151   for(Int_t iCent=0; iCent<=5; ++iCent) {
1152     if(!(h = (TH3F*)gROOT->FindObject(Form("hTPCRefTracksNeg_cent%d",iCent+1)))){
1153       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",
1154                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1155     } else h->Reset();
1156     fHistos->AddAt(h, kTPCRefTracksNeg+iCent);
1157   }
1158
1159   // (eta,detector phi,P) distribution of reference TRD positive tracks
1160   for(Int_t iCent=0; iCent<=5; ++iCent) {
1161     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos_cent%d",iCent+1)))){
1162       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",
1163                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1164     } else h->Reset();
1165     fHistos->AddAt(h, kTRDRefTracksPos+iCent);
1166   }
1167
1168   // (eta,detector phi,P) distribution of reference TRD negative tracks
1169   for(Int_t iCent=0; iCent<=5; ++iCent) {
1170     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg_cent%d",iCent+1)))){
1171       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",
1172                                             iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1173     } else h->Reset();
1174     fHistos->AddAt(h, kTRDRefTracksNeg+iCent);
1175   }
1176
1177   // (eta,detector phi,P) distribution of reference TRD positive tracks with 4 tracklets
1178   for(Int_t iCent=0; iCent<=5; ++iCent) {
1179     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos4_cent%d",iCent+1)))){
1180       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",
1181                                                                  iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1182     } else h->Reset();
1183     fHistos->AddAt(h, kTRDRefTracksPos4+iCent);
1184   }
1185
1186   // (eta,detector phi,P) distribution of reference TRD positive tracks with 5 tracklets
1187   for(Int_t iCent=0; iCent<=5; ++iCent) {
1188     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos5_cent%d",iCent+1)))){
1189       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",
1190                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1191     } else h->Reset();
1192     fHistos->AddAt(h, kTRDRefTracksPos5+iCent);
1193   }
1194
1195   // (eta,detector phi,P) distribution of reference TRD positive tracks with 6 tracklets
1196   for(Int_t iCent=0; iCent<=5; ++iCent) {
1197     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksPos6_cent%d",iCent+1)))){
1198       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",
1199                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1200     } else h->Reset();
1201     fHistos->AddAt(h, kTRDRefTracksPos6+iCent);
1202   }
1203
1204   // (eta,detector phi,P) distribution of reference TRD negative tracks with 4 tracklets
1205   for(Int_t iCent=0; iCent<=5; ++iCent) {
1206     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg4_cent%d",iCent+1)))){
1207       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",
1208                                                                  iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1209     } else h->Reset();
1210     fHistos->AddAt(h, kTRDRefTracksNeg4+iCent);
1211   }
1212
1213   // (eta,detector phi,P) distribution of reference TRD negative tracks with 5 tracklets
1214   for(Int_t iCent=0; iCent<=5; ++iCent) {
1215     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg5_cent%d",iCent+1)))){
1216       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",
1217                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1218     } else h->Reset();
1219     fHistos->AddAt(h, kTRDRefTracksNeg5+iCent);
1220   }
1221
1222   // (eta,detector phi,P) distribution of reference TRD negative tracks with 6 tracklets
1223   for(Int_t iCent=0; iCent<=5; ++iCent) {
1224     if(!(h = (TH3F*)gROOT->FindObject(Form("hTRDRefTracksNeg6_cent%d",iCent+1)))){
1225       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",
1226                                                                   iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, etaBinLimits, 150, phiBinLimits, 32, binPtLimits);
1227     } else h->Reset();
1228     fHistos->AddAt(h, kTRDRefTracksNeg6+iCent);
1229   }
1230
1231
1232   // (eta,detector phi) profile of average number of TRD tracklets/track
1233   for(Int_t iCent=0; iCent<=5; ++iCent) {
1234     if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaPhiAvNtrkl_cent%d",iCent+1)))){
1235       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",
1236                                                    iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 150, -1.1*TMath::Pi(), 1.1*TMath::Pi());
1237     } else h->Reset();
1238     fHistos->AddAt(h, kTRDEtaPhiAvNtrkl+iCent);
1239   }
1240
1241   // (eta,delta phi) profile of average number of TRD tracklets/track
1242   for(Int_t iCent=0; iCent<=5; ++iCent) {
1243     if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaDeltaPhiAvNtrkl_cent%d",iCent+1)))){
1244       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",
1245                                                         iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 50, -0.4*TMath::Pi(), 0.4*TMath::Pi());
1246     } else h->Reset();
1247     fHistos->AddAt(h, kTRDEtaDeltaPhiAvNtrkl+iCent);
1248   }
1249
1250   // (eta, detector phi) profile of average tracklet Qtot from slices
1251   for(Int_t iCent=0; iCent<=5; ++iCent) {
1252     for(Int_t iLayer=0;iLayer<6;iLayer++) {
1253       if(!(h = (TProfile2D*)gROOT->FindObject(Form("hTRDEtaPhiAvQtot_Layer%d_cent%d",iLayer,iCent+1)))) {
1254         h = new TProfile2D(Form("hTRDEtaPhiAvQtot_Layer%d_cent%d",iLayer,iCent+1),
1255                            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",
1256                                 iLayer, iCent+1, fgkEta, fgkPt, fgkTrkDCAxy, fgkTrkDCAz, fgkNclTPC), 100, -1.0, 1.0, 150, -1.1*TMath::Pi(), 1.1*TMath::Pi());
1257       } else h->Reset();
1258       fHistos->AddAt(h, kTRDEtaPhiAvQtot+iCent*6+iLayer);
1259     }
1260   }
1261
1262   // Trigger definitions
1263   if(!(h=(TH1F*)gROOT->FindObject("hTriggerDefs"))) {
1264     h = new TH1F("hTriggerDefs", "Trigger definitions", kNMaxAssignedTriggers, 0.5, 0.5+Float_t(kNMaxAssignedTriggers));
1265   }
1266   else h->Reset();
1267   fHistos->AddAt(h, kTriggerDefs);
1268
1269   // dummy histo
1270   if(!(h=(TH1F*)gROOT->FindObject("hDummy"))) {
1271     h = new TH1F("hDummy", "Dummy hist", 10, 0., 1.);
1272   }
1273   else h->Reset();
1274   fHistos->AddAt(h, 0);
1275
1276   fMatchingPhiEtaCF = CreateCFContainer("MatchingPhiEta", "CF container with TRD-TPC matching data");
1277   fHistos->AddAt(fMatchingPhiEtaCF, kMatchingPhiEtaCF);
1278   fMatchingPtCF = CreateCFContainer("MatchingPt", "CF container with TRD-TPC matching data");
1279   fHistos->AddAt(fMatchingPtCF, kMatchingPtCF);
1280   fBunchCrossingsCF = CreateCFContainer("BunchCrossingsCF", "CF container with bunch crossings dependent data");
1281   fHistos->AddAt(fBunchCrossingsCF, kBunchCrossingsCF);
1282   fCentralityCF = CreateCFContainer("CentralityCF", "CF container with TRD-TPC matching data");
1283   fHistos->AddAt(fCentralityCF, kCentralityCF);
1284   fQtotCF = CreateCFContainer("QtotCF", "CF container with TRD tracklet charge data");
1285   fHistos->AddAt(fQtotCF, kQtotCF);
1286   fPulseHeightCF = CreateCFContainer("PulseHeightCF", "CF container with TRD tracklet PH data");
1287   fHistos->AddAt(fPulseHeightCF, kPulseHeightCF);
1288   fExpertCF = CreateCFContainer("ExpertCF", "CF container with customized information");
1289   if(fExpertCF) fHistos->AddAt(fExpertCF, kExpertCF);
1290
1291   return fHistos;
1292 }
1293
1294
1295 //__________________________________________________________________________________________________________
1296 void AliTRDcheckESD::InitializeCFContainers() {
1297   //
1298   //  Initialize the CF container
1299   //
1300   AliAnalysisManager* man=AliAnalysisManager::GetAnalysisManager();
1301   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
1302   if(!inputHandler) return;
1303
1304   GetTriggerIndex("All triggers", kTRUE);
1305
1306   AliPhysicsSelection* physSel = (AliPhysicsSelection*)inputHandler->GetEventSelection();
1307   const TList* trigList = (physSel ? physSel->GetCollisionTriggerClasses() : 0x0);
1308   const TList* bgTrigList = (physSel ? physSel->GetBGTriggerClasses() : 0x0);
1309
1310   // Add collision triggers from PhysicsSelection
1311   if(trigList) {
1312     for(Int_t it=0; it<trigList->GetEntries(); ++it) {
1313       TString trigName = trigList->At(it)->GetName();
1314       TObjArray* arr = trigName.Tokenize(" ");
1315       trigName = arr->At(0)->GetName();
1316       trigName.Remove(0,1);
1317       TObjArray* arr2 = trigName.Tokenize(",");
1318       for(Int_t jt=0; jt<arr2->GetEntries(); ++jt) {
1319         // Assign an index into the trigger histogram and the CF container for this trigger
1320         GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
1321       }
1322       delete arr;
1323     }
1324   }
1325   // Add background triggers from PhysicsSelection
1326   if(bgTrigList) {
1327     for(Int_t it=0; it<bgTrigList->GetEntries(); ++it) {
1328       TString trigName = bgTrigList->At(it)->GetName();
1329       TObjArray* arr = trigName.Tokenize(" ");
1330       trigName = arr->At(0)->GetName();
1331       trigName.Remove(0,1);
1332       TObjArray* arr2 = trigName.Tokenize(",");
1333       for(Int_t jt=0; jt<arr2->GetEntries(); ++jt) {
1334         // Assign an index into the trigger histogram and the CF container for this trigger
1335         GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
1336       }
1337       delete arr;
1338     }
1339   }
1340
1341   // Add user enabled triggers
1342   TObjArray* arr = fUserEnabledTriggers.Tokenize(";");
1343   for(Int_t it=0; it<arr->GetEntries(); ++it) {
1344     GetTriggerIndex(arr->At(it)->GetName(), kTRUE);
1345   }
1346   delete arr;
1347 }
1348
1349
1350 //__________________________________________________________________________________________________________
1351 AliCFContainer* AliTRDcheckESD::CreateCFContainer(const Char_t* name, const Char_t* title) {
1352   //
1353   //  make a CF container
1354   //
1355   // create a CF container and add it to the list of histograms
1356   Int_t nbinsCf[kNTrdCfVariables];
1357   for(Int_t i=0;i<kNTrdCfVariables;++i) nbinsCf[i]=0;
1358   nbinsCf[kEventVtxZ]         =    5;
1359   nbinsCf[kEventMult]         =    5;
1360   nbinsCf[kEventTrigger]      =    kNMaxAssignedTriggers;
1361   nbinsCf[kEventBC]           = 3500;
1362   nbinsCf[kTrackTOFBC]        =    2;
1363   nbinsCf[kTrackDCAxy]        =    9;
1364   nbinsCf[kTrackDCAz]         =    5;
1365   nbinsCf[kTrackCharge]       =    2;
1366   nbinsCf[kTrackPhi]          =  180;
1367   nbinsCf[kTrackEta]          =   90;
1368   nbinsCf[kTrackPt]           =   18;
1369   nbinsCf[kTrackP]            =   17;
1370   nbinsCf[kTrackTrdTracklets] =    7;
1371   nbinsCf[kTrackTrdClusters]  =  200;
1372   for(Int_t i=0;i<6;++i) nbinsCf[kTrackQtot+i] = 100;
1373   for(Int_t i=0;i<8;++i) nbinsCf[kTrackPHslice+i] = 400;
1374   //Double_t evVtxLims[2]      = {-10.,+10.};
1375   Double_t evMultLims[6]     = {0.0, 700., 1400., 2100., 2800., 3500.};
1376   Double_t evTriggerLims[2]  = {0.5, 0.5+Float_t(kNMaxAssignedTriggers)};
1377   Double_t evBCLims[2]       = {-0.5, +3499.5};
1378   //Double_t trkTOFBClims[3]   = {-0.5, 0.5, 5.5};
1379   //Double_t trkDCAxyLims[10]  = {-10.0,  -6.0, -3.0,  -2.0,  -1.0,
1380   //                               +1.0, +2.0,  +3.0,  +6.0, +10.0};
1381   //Double_t trkDCAzLims[2]    = {-15.0, +15.0};
1382   Double_t trkChargeLims[2]  = {-1.5, +1.5};
1383   Double_t trkPhiLims[2]     = {-1.001*TMath::Pi(), +1.001*TMath::Pi()};
1384   Double_t trkEtaLims[2]     = {-0.9, +0.9};
1385   Double_t trkPtLims[19]     = {0.0, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.5, 3.0,
1386                                 3.5, 4.0, 4.5,  5.0, 6.0,  7.0, 8.0,  9.0, 10.0};
1387   Double_t trkPLims[18]      = {0.0, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.7, 2.0, 2.5,
1388                                 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 9.0, 12.0};
1389   Double_t trkTrdNLims[2]    = {-0.5, 6.5};
1390   Double_t trkTrdNclsLims[2] = {-0.5, 199.5};
1391   Double_t trkQtotLims[2]    = {0.0, 20.};
1392   /*Double_t trkQtotLims[20]   = {0.0, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0,
1393                                 5.5, 6.0, 6.5, 7.0, 8.0, 9.0,10.0,12.0,15.0,20.0};*/
1394   const Char_t* varNames[kNTrdCfVariables] = {"vtxZ", "multiplicity", "trigger", "BC", "TOFBC", "DCAxy", "DCAz",
1395     "charge", "phi", "eta", "pt", "P", "tracklets", "clusters",
1396     "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7",
1397     "Qtot0", "Qtot1", "Qtot2", "Qtot3", "Qtot4", "Qtot5"};
1398
1399   AliCFContainer* cf;
1400   TString nameStr=name;
1401   if(nameStr.Contains("MatchingPhiEta")) {
1402     fMatchingPhiEtaCFVars[0] = kTrackCharge;       fMatchingPhiEtaCFVars[1] = kTrackPhi; fMatchingPhiEtaCFVars[2] = kTrackEta;
1403     fMatchingPhiEtaCFVars[3] = kTrackTrdTracklets; fMatchingPhiEtaCFVars[4] = kEventTrigger;
1404     const Int_t nVars = 5;
1405     Int_t nBins[nVars]; for(Int_t i=0; i<nVars; ++i) nBins[i] = nbinsCf[fMatchingPhiEtaCFVars[i]];
1406     cf = new AliCFContainer(name, title, 3, nVars, nBins);
1407     cf->SetBinLimits(0, trkChargeLims[0], trkChargeLims[1]);
1408     cf->SetBinLimits(1, trkPhiLims[0], trkPhiLims[1]);
1409     cf->SetBinLimits(2, trkEtaLims[0], trkEtaLims[1]);
1410     cf->SetBinLimits(3, trkTrdNLims[0], trkTrdNLims[1]);
1411     cf->SetBinLimits(4, evTriggerLims[0], evTriggerLims[1]);
1412     for(Int_t i=0; i<nVars; ++i) cf->SetVarTitle(i, varNames[fMatchingPhiEtaCFVars[i]]);
1413     cf->SetStepTitle(0, "TPC");
1414     cf->SetStepTitle(1, "TRD");
1415     cf->SetStepTitle(2, "TOF");
1416     return cf;
1417   }
1418   if(nameStr.Contains("MatchingPt")) {
1419     fMatchingPtCFVars[0] = kEventMult; fMatchingPtCFVars[1] = kTrackCharge;        fMatchingPtCFVars[2] = kTrackPhi;
1420     fMatchingPtCFVars[3] = kTrackPt;   fMatchingPtCFVars[4] = kTrackTrdTracklets;  fMatchingPtCFVars[5] = kEventTrigger;
1421     const Int_t nVars = 6;
1422     Int_t nBins[nVars]; for(Int_t i=0; i<nVars; ++i) nBins[i] = nbinsCf[fMatchingPtCFVars[i]];
1423     cf = new AliCFContainer(name, title, 3, nVars, nBins);
1424     cf->SetBinLimits(0, evMultLims);
1425     cf->SetBinLimits(1, trkChargeLims[0], trkChargeLims[1]);
1426     cf->SetBinLimits(2, trkPhiLims[0], trkPhiLims[1]);
1427     cf->SetBinLimits(3, trkPtLims);
1428     cf->SetBinLimits(4, trkTrdNLims[0], trkTrdNLims[1]);
1429     cf->SetBinLimits(5, evTriggerLims[0], evTriggerLims[1]);
1430     for(Int_t i=0; i<nVars; ++i) cf->SetVarTitle(i, varNames[fMatchingPtCFVars[i]]);
1431     cf->SetStepTitle(0, "TPC");
1432     cf->SetStepTitle(1, "TRD");
1433     cf->SetStepTitle(2, "TOF");
1434     return cf;
1435   }
1436   if(nameStr.Contains("BunchCrossings")) {
1437     fBunchCrossingsCFVars[0] = kEventBC; fBunchCrossingsCFVars[1] = kTrackPhi;
1438     const Int_t nVars = 2;
1439     Int_t nBins[nVars]; for(Int_t i=0; i<nVars; ++i) nBins[i] = nbinsCf[fBunchCrossingsCFVars[i]];
1440     cf = new AliCFContainer(name, title, 3, nVars, nBins);
1441     cf->SetBinLimits(0, evBCLims[0], evBCLims[1]);
1442     cf->SetBinLimits(1, trkPhiLims[0], trkPhiLims[1]);
1443     for(Int_t i=0; i<nVars; ++i) cf->SetVarTitle(i, varNames[fBunchCrossingsCFVars[i]]);
1444     cf->SetStepTitle(0, "TPC");
1445     cf->SetStepTitle(1, "TRD");
1446     cf->SetStepTitle(2, "TOF");
1447     return cf;
1448   }
1449   if(nameStr.Contains("Centrality")) {
1450     fCentralityCFVars[0] = kEventMult; fCentralityCFVars[1] = kTrackP; fCentralityCFVars[2] = kTrackTrdClusters;
1451     fCentralityCFVars[3] = kTrackQtot; fCentralityCFVars[4] = kEventTrigger;
1452     const Int_t nVars = 5;
1453     Int_t nBins[nVars]; for(Int_t i=0; i<nVars; ++i) nBins[i] = nbinsCf[fCentralityCFVars[i]];
1454     cf = new AliCFContainer(name, title, 1, nVars, nBins);
1455     cf->SetBinLimits(0, evMultLims);
1456     cf->SetBinLimits(1, trkPLims);
1457     cf->SetBinLimits(2, trkTrdNclsLims[0], trkTrdNclsLims[1]);
1458     cf->SetBinLimits(3, trkQtotLims[0], trkQtotLims[1]);
1459     cf->SetBinLimits(4, evTriggerLims[0], evTriggerLims[1]);
1460     for(Int_t i=0; i<nVars; ++i) cf->SetVarTitle(i, varNames[fCentralityCFVars[i]]);
1461     cf->SetStepTitle(0, "TRD");
1462     return cf;
1463   }
1464   if(nameStr.Contains("Qtot")) {
1465     fQtotCFVars[0] = kTrackPhi; fQtotCFVars[1] = kTrackEta; fQtotCFVars[2] = kTrackQtot;
1466     fQtotCFVars[3] = kEventTrigger;
1467     const Int_t nVars = 5;
1468     Int_t nBins[nVars]; for(Int_t i=0; i<nVars-1; ++i) nBins[i] = nbinsCf[fQtotCFVars[i]];
1469     nBins[2] = 50;
1470     nBins[nVars-1] = 6;
1471     cf = new AliCFContainer(name, title, 1, nVars, nBins);
1472     cf->SetBinLimits(0, trkPhiLims[0], trkPhiLims[1]);
1473     cf->SetBinLimits(1, trkEtaLims[0], trkEtaLims[1]);
1474     cf->SetBinLimits(2, trkQtotLims[0], trkQtotLims[1]);
1475     cf->SetBinLimits(3, evTriggerLims[0], evTriggerLims[1]);
1476     cf->SetBinLimits(4, -0.5, 5.5);
1477     for(Int_t i=0; i<nVars-1; ++i) cf->SetVarTitle(i, varNames[fQtotCFVars[i]]);
1478     cf->SetVarTitle(nVars-1, "layer");
1479     cf->SetStepTitle(0, "TRD");
1480     return cf;
1481   }
1482   if(nameStr.Contains("PulseHeight")) {
1483     fPulseHeightCFVars[0] = kTrackP; fPulseHeightCFVars[1] = kTrackPHslice; fPulseHeightCFVars[2] = kEventTrigger;
1484     const Int_t nVars = 4;
1485     Int_t nBins[nVars]; for(Int_t i=0; i<nVars-1; ++i) nBins[i] = nbinsCf[fPulseHeightCFVars[i]];
1486     nBins[nVars-1] = 8;
1487     cf = new AliCFContainer(name, title, 1, nVars, nBins);
1488     //cf->SetBinLimits(0, evTriggerLims[0], evTriggerLims[1]);
1489     cf->SetBinLimits(0, trkPLims);
1490     cf->SetBinLimits(1, trkQtotLims[0], trkQtotLims[1]);
1491     cf->SetBinLimits(2, evTriggerLims[0], evTriggerLims[1]);
1492     cf->SetBinLimits(3, -0.5, 7.5);
1493     for(Int_t i=0; i<nVars-1; ++i) cf->SetVarTitle(i, varNames[fPulseHeightCFVars[i]]);
1494     cf->SetVarTitle(nVars-1, "slice");
1495     cf->SetStepTitle(0, "TRD");
1496     return cf;
1497   }
1498   if(nameStr.Contains("Expert")) {
1499     Int_t nVars = 0;
1500     Int_t nBins[kNTrdCfVariables];
1501     for(Int_t ivar=0; ivar<kNTrdCfVariables; ++ivar) {
1502       if(!fExpertCFVarsEnabled[ivar]) continue;
1503       if(fExpertCFVarBins[ivar][0]=='\0') {
1504         nBins[nVars] = fExpertCFVarNBins[ivar];
1505         nVars++;
1506       }
1507       else {
1508         TObjArray* arr = fExpertCFVarBins[ivar].Tokenize(";");
1509         nBins[nVars] = arr->GetEntries()-1;
1510         if(nBins[nVars]>0) nVars++;
1511         delete arr;
1512       }
1513     }
1514     if(nVars<1) return 0x0;
1515     Int_t nSteps = 0; for(Int_t i=0; i<3; ++i) if(fExpertCFEnabledSteps[i]) nSteps++;
1516     if(nSteps<1) return 0x0;
1517     cf = new AliCFContainer(name, title, nSteps, nVars, nBins);
1518     Int_t iUsedVar = 0;
1519     for(Int_t ivar=0; ivar<kNTrdCfVariables; ++ivar) {
1520       if(!fExpertCFVarsEnabled[ivar]) continue;
1521       if(fExpertCFVarBins[ivar][0]=='\0')
1522         cf->SetBinLimits(iUsedVar, fExpertCFVarRanges[ivar][0], fExpertCFVarRanges[ivar][1]);
1523       else {
1524         TObjArray* arr = fExpertCFVarBins[ivar].Tokenize(";");
1525         if(arr->GetEntries()-1>0) {
1526           Double_t* binLims = new Double_t[arr->GetEntries()];
1527           for(Int_t ib=0;ib<arr->GetEntries();++ib) {
1528             TString binStr = arr->At(ib)->GetName();
1529             binLims[ib] = binStr.Atof();
1530           }
1531           cf->SetBinLimits(iUsedVar++, binLims);
1532         }
1533         delete arr;
1534       }
1535       cf->SetVarTitle(iUsedVar, varNames[ivar]);
1536     }
1537     const Char_t* stepNames[3] = {"TPC","TRD","TOF"};
1538     Int_t iUsedStep = 0;
1539     for(Int_t istep=0; istep<3; ++istep) {
1540       if(fExpertCFEnabledSteps[istep]) cf->SetStepTitle(iUsedStep++, stepNames[istep]);
1541     }
1542     return cf;
1543   }
1544   return 0x0;
1545 }
1546
1547
1548 //____________________________________________________________________
1549 Bool_t AliTRDcheckESD::Load(const Char_t *file, const Char_t *dir, const Char_t *name)
1550 {
1551 // Load data from performance file
1552
1553   if(!TFile::Open(file)){
1554     AliWarning(Form("Couldn't open file %s.", file));
1555     return kFALSE;
1556   }
1557   if(dir){
1558     if(!gFile->cd(dir)){
1559       AliWarning(Form("Couldn't cd to %s in %s.", dir, file));
1560       return kFALSE;
1561     }
1562   }
1563   TObjArray *o(NULL);
1564   const Char_t *tn=(name ? name : GetName());
1565   if(!(o = (TObjArray*)gDirectory->Get(tn))){
1566     AliWarning(Form("Missing histogram container %s.", tn));
1567     return kFALSE;
1568   }
1569   fHistos = (TObjArray*)o->Clone(GetName());
1570   fMatchingPhiEtaCF = (AliCFContainer*)fHistos->At(kMatchingPhiEtaCF);
1571   fMatchingPtCF = (AliCFContainer*)fHistos->At(kMatchingPtCF);
1572   fBunchCrossingsCF = (AliCFContainer*)fHistos->At(kBunchCrossingsCF);
1573   fCentralityCF = (AliCFContainer*)fHistos->At(kCentralityCF);
1574   fQtotCF = (AliCFContainer*)fHistos->At(kQtotCF);
1575   fPulseHeightCF = (AliCFContainer*)fHistos->At(kPulseHeightCF);
1576   fExpertCF = (AliCFContainer*)fHistos->At(kExpertCF);
1577
1578   /*
1579   TObjArray *cfs(NULL);
1580   if(!(cfs = (TObjArray*)gDirectory->Get(Form("%s_CF", tn)))){
1581     AliWarning(Form("Missing CFs container %s_CF.", tn));
1582     fCfList = NULL;
1583     //return kFALSE;
1584   }
1585   else
1586     fCfList = (TObjArray*)cfs->Clone(Form("%s_CF_clone", GetName()));
1587   */
1588
1589   gFile->Close();
1590   return kTRUE;
1591 }
1592
1593 //_______________________________________________________
1594 Bool_t AliTRDcheckESD::PutTrendValue(const Char_t *name, Double_t val)
1595 {
1596 // Dump trending value to default file
1597
1598   if(!fgFile){
1599     fgFile = fopen("TRD.Performance.txt", "at");
1600   }
1601   fprintf(fgFile, "%s_%s %f\n", GetName(), name, val);
1602   return kTRUE;
1603 }
1604
1605 //____________________________________________________________________
1606 void AliTRDcheckESD::Terminate(Option_t *)
1607 {
1608   // Steer post-processing
1609   if(!fHistos){
1610     fHistos = dynamic_cast<TObjArray *>(GetOutputData(1));
1611     if(!fHistos){
1612       AliError("Histogram container not found in output");
1613       return;
1614     }
1615   }
1616
1617   //  fNRefFigures = 15;
1618   //  return;
1619
1620   const Char_t *name[kNrefs] = {
1621     "Ncl", "Eff", "Eloss", "PtResDCA"
1622   };
1623
1624   TObjArray *arr(NULL); TGraph *g(NULL);
1625   if(!fResults){
1626     fResults = new TObjArray(kNrefs);
1627     fResults->SetOwner();
1628     fResults->SetName("results");
1629     for(Int_t iref(0); iref<kNrefs; iref++){
1630       fResults->AddAt(arr = new TObjArray(fgkNgraph[iref]), iref);
1631       arr->SetName(name[iref]);  arr->SetOwner();
1632       switch(iref+1){
1633       case kNCl:
1634         for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){
1635           arr->AddAt(g = new TGraphErrors(), ig);
1636           g->SetLineColor(ig+1);
1637           g->SetMarkerColor(ig+1);
1638           g->SetMarkerStyle(ig+20);
1639           g->SetName(Form("s%d", ig));
1640           switch(ig){
1641           case 0: g->SetTitle("ALL"); break;
1642           case 1: g->SetTitle("NEG"); break;
1643           case 2: g->SetTitle("POS"); break;
1644           default: g->SetTitle(AliPID::ParticleLatexName(ig-3)); break;
1645           };
1646         }
1647         break;
1648       case kTRDmom:
1649         for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){
1650           arr->AddAt(g = new TGraphAsymmErrors(), ig);
1651           g->SetLineColor(ig+1);
1652           g->SetMarkerColor(ig+1);
1653           g->SetMarkerStyle(ig+20);
1654         }
1655         break;
1656       case kPtRes:
1657         for(Int_t idx(0); idx<AliPID::kSPECIES; idx++){
1658           Int_t ig(2*idx);
1659           arr->AddAt(g = new TGraphErrors(), ig);
1660           g->SetLineColor(kRed-idx);
1661           g->SetMarkerColor(kRed-idx);
1662           g->SetMarkerStyle(20+idx);
1663           g->SetNameTitle(Form("s%d", ig), Form("res %s", AliPID::ParticleLatexName(idx)));
1664           arr->AddAt(g = new TGraphErrors(), ig+1);
1665           g->SetLineColor(kBlue-idx);
1666           g->SetMarkerColor(kBlue-idx);
1667           g->SetMarkerStyle(20+idx);
1668           g->SetNameTitle(Form("m%d", ig+1), Form("sys %s", AliPID::ParticleLatexName(idx)));
1669
1670           ig+=10;
1671           arr->AddAt(g = new TGraphErrors(), ig);
1672           g->SetLineColor(kRed-idx);
1673           g->SetMarkerColor(kRed-idx);
1674           g->SetMarkerStyle(20+idx);
1675           g->SetNameTitle(Form("s%d", ig), Form("sigma %s", AliPID::ParticleLatexName(idx)));
1676           arr->AddAt(g = new TGraphErrors(), ig+1);
1677           g->SetLineColor(kBlue-idx);
1678           g->SetMarkerColor(kBlue-idx);
1679           g->SetMarkerStyle(20+idx);
1680           g->SetNameTitle(Form("m%d", ig+1), Form("mean %s", AliPID::ParticleLatexName(idx)));
1681         }
1682         break;
1683       default:
1684         for(Int_t ig(0); ig<fgkNgraph[iref]; ig++){
1685           arr->AddAt(g = new TGraphErrors(), ig);
1686           g->SetLineColor(ig+1);
1687           g->SetMarkerColor(ig+1);
1688           g->SetMarkerStyle(ig+20);
1689         }
1690         break;
1691       }
1692     }
1693   }
1694   TH1 *h1[2] = {NULL, NULL};
1695   TH2I *h2(NULL);
1696   TAxis *ax(NULL);
1697
1698   // No of clusters
1699   if(!(h2 = (TH2I*)fHistos->At(kNCl))) return;
1700   ax = h2->GetXaxis();
1701   arr = (TObjArray*)fResults->At(kNCl);
1702
1703   // All tracks
1704   h1[0] = h2->ProjectionX("Ncl_px");
1705   TGraphErrors *ge=(TGraphErrors*)arr->At(0);
1706   if (ge) {
1707     for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1708       ge->SetPoint(ib-2, ax->GetBinCenter(ib), h1[0]->GetBinContent(ib));
1709     }
1710   }
1711
1712   // All charged tracks
1713   TH1 *hNclCh[2] = {(TH1D*)h1[0]->Clone("NEG"), (TH1D*)h1[0]->Clone("POS")};
1714   hNclCh[0]->Reset();hNclCh[1]->Reset();
1715   for(Int_t is(1); is<=AliPID::kSPECIES; is++){
1716     hNclCh[0]->Add(h2->ProjectionX("Ncl_px", 2*is-1, 2*is-1)); // neg
1717     hNclCh[1]->Add(h2->ProjectionX("Ncl_px", 2*is, 2*is));     // pos
1718   }
1719   if(Int_t(hNclCh[0]->GetEntries())){
1720     ge=(TGraphErrors*)arr->At(1);
1721     if (ge) {
1722       for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1723         ge->SetPoint(ib-2, ax->GetBinCenter(ib), hNclCh[0]->GetBinContent(ib));
1724       }
1725     }
1726   }
1727
1728   if(Int_t(hNclCh[1]->GetEntries())){
1729     ge=(TGraphErrors*)arr->At(2);
1730     if (ge) {
1731       for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1732         ge->SetPoint(ib-2, ax->GetBinCenter(ib), hNclCh[1]->GetBinContent(ib));
1733       }
1734     }
1735   }
1736   // Species wise
1737   for(Int_t is(1); is<=AliPID::kSPECIES; is++){
1738     h1[0] = h2->ProjectionX("Ncl_px", 2*is-1, 2*is);
1739     if(!Int_t(h1[0]->GetEntries())) continue;
1740     ge=(TGraphErrors*)arr->At(2+is);
1741     if (ge) {
1742       for(Int_t ib=2; ib<=ax->GetNbins(); ib++){
1743         ge->SetPoint(ib-2, ax->GetBinCenter(ib), h1[0]->GetBinContent(ib));
1744       }
1745     }
1746   }
1747
1748   fNRefFigures = 1;
1749
1750   // EFFICIENCY
1751   // geometrical efficiency
1752   if(!(h2 = (TH2I*)fHistos->At(kTRDstat))) return;
1753   arr = (TObjArray*)fResults->At(kTRDstat-1);
1754   h1[0] = h2->ProjectionX("checkESDx0", kTPCout, kTPCout);
1755   h1[1] = h2->ProjectionX("checkESDx1", kTRDin, kTRDin);
1756   Process(h1, (TGraphErrors*)arr->At(0));
1757   delete h1[0];delete h1[1];
1758   // tracking efficiency
1759   h1[0] = h2->ProjectionX("checkESDx0", kTRDin, kTRDin);
1760   h1[1] = h2->ProjectionX("checkESDx1", kTRDout, kTRDout);
1761   Process(h1, (TGraphErrors*)arr->At(1));
1762   delete h1[1];
1763   // PID efficiency
1764   h1[1] = h2->ProjectionX("checkESDx1", kTRDpid, kTRDpid);
1765   Process(h1, (TGraphErrors*)arr->At(2));
1766   delete h1[1];
1767   // Refit efficiency
1768   h1[1] = h2->ProjectionX("checkESDx1", kTRDref, kTRDref);
1769   Process(h1, (TGraphErrors*)arr->At(3));
1770   delete h1[1];
1771   fNRefFigures++;
1772
1773   // ENERGY LOSS
1774   if(!(h2 = dynamic_cast<TH2I*>(fHistos->At(kTRDmom)))) return;
1775   arr = (TObjArray*)fResults->At(kTRDmom-1);
1776   TGraphAsymmErrors *g06 = (TGraphAsymmErrors*)arr->At(0), *g09 = (TGraphAsymmErrors*)arr->At(1);
1777   ax=h2->GetXaxis();
1778   const Int_t nq(4);
1779   const Double_t xq[nq] = {0.05, 0.2, 0.8, 0.95};
1780   Double_t yq[nq];
1781   for(Int_t ily=6; ily--;){
1782     h1[0] = h2->ProjectionX("checkESDp0", ily+1, ily+1);
1783     h1[0]->GetQuantiles(nq,yq,xq);
1784     g06->SetPoint(ily, Float_t(ily), ax->GetBinCenter(h1[0]->GetMaximumBin()));
1785     g06->SetPointError(ily, 0., 0., TMath::Abs(yq[0]), yq[3]);
1786     g09->SetPoint(ily, Float_t(ily), h1[0]->GetMean());
1787     g09->SetPointError(ily, 0., 0., TMath::Abs(yq[1]), yq[2]);
1788
1789     //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]);
1790     delete h1[0];
1791   }
1792   fNRefFigures++;
1793 //  if(!HasMC()) return;
1794
1795   // Pt RESOLUTION @ DCA
1796   TH3S* h3(NULL); TGraphErrors *gg[2] = {NULL,NULL};
1797   if(!(h3 = dynamic_cast<TH3S*>(fHistos->At(kPtRes)))) return;
1798   arr = (TObjArray*)fResults->At(kPtRes-1);
1799   TAxis *az(h3->GetZaxis());
1800   for(Int_t i(0); i<AliPID::kSPECIES; i++){
1801     Int_t idx(2*i);
1802     az->SetRange(idx+1, idx+2);
1803     gg[1] = (TGraphErrors*)arr->At(idx);
1804     gg[0] = (TGraphErrors*)arr->At(idx+1);
1805     Process2D((TH2*)h3->Project3D("yx"), gg);
1806
1807     idx+=10;
1808     az->SetRange(idx+1, idx+2);
1809     gg[1] = (TGraphErrors*)arr->At(idx);
1810     gg[0] = (TGraphErrors*)arr->At(idx+1);
1811     Process2D((TH2*)h3->Project3D("yx"), gg);
1812   }
1813   fNRefFigures++;
1814
1815   fNRefFigures++;
1816   // 3x3 tracking summary canvases for every centrality class
1817   fNRefFigures++;
1818   // 3x3 PID summary canvases for every centrality class
1819   fNRefFigures++;
1820   // 3x3 for centrality dependent pictures
1821   fNRefFigures++;
1822
1823   //DoTrending();
1824 }
1825
1826 //____________________________________________________________________
1827 Int_t AliTRDcheckESD::Pdg2Idx(Int_t pdg) const
1828 {
1829   //
1830   // Helper function converting PDG code into AliPID index
1831   //
1832   switch(pdg){
1833   case kElectron:
1834   case kPositron: return AliPID::kElectron;
1835   case kMuonPlus:
1836   case kMuonMinus: return AliPID::kMuon;
1837   case kPiPlus:
1838   case kPiMinus: return AliPID::kPion;
1839   case kKPlus:
1840   case kKMinus: return AliPID::kKaon;
1841   case kProton:
1842   case kProtonBar: return AliPID::kProton;
1843   }
1844   return -1;
1845 }
1846
1847 //____________________________________________________________________
1848 void AliTRDcheckESD::Process(TH1 **h1, TGraphErrors *g)
1849 {
1850 // Generic function to process one reference plot
1851
1852   Int_t n1 = 0, n2 = 0, ip=0;
1853   Double_t eff = 0.;
1854
1855   TAxis *ax = h1[0]->GetXaxis();
1856   for(Int_t ib=1; ib<=ax->GetNbins(); ib++){
1857     if(!(n1 = (Int_t)h1[0]->GetBinContent(ib))) continue;
1858     n2 = (Int_t)h1[1]->GetBinContent(ib);
1859     eff = n2/Float_t(n1);
1860
1861     ip=g->GetN();
1862     g->SetPoint(ip, ax->GetBinCenter(ib), eff);
1863     g->SetPointError(ip, 0., n2 ? eff*TMath::Sqrt(1./n1+1./n2) : 0.);
1864   }
1865 }
1866 //________________________________________________________
1867 void AliTRDcheckESD::Process2D(TH2 * const h2, TGraphErrors **g)
1868 {
1869   //
1870   // Do the processing
1871   //
1872
1873   Int_t n = 0;
1874   if((n=g[0]->GetN())) for(;n--;) g[0]->RemovePoint(n);
1875   if((n=g[1]->GetN())) for(;n--;) g[1]->RemovePoint(n);
1876   TF1 f("fg", "gaus", -3.,3.);
1877   for(Int_t ibin = 1; ibin <= h2->GetNbinsX(); ibin++){
1878     Double_t x = h2->GetXaxis()->GetBinCenter(ibin);
1879     TH1D *h = h2->ProjectionY("py", ibin, ibin);
1880     if(h->GetEntries()<100) continue;
1881     //AdjustF1(h, f);
1882
1883     h->Fit(&f, "QN");
1884     Int_t ip = g[0]->GetN();
1885     g[0]->SetPoint(ip, x, f.GetParameter(1));
1886     g[0]->SetPointError(ip, 0., f.GetParError(1));
1887     g[1]->SetPoint(ip, x, f.GetParameter(2));
1888     g[1]->SetPointError(ip, 0., f.GetParError(2));
1889   }
1890   return;
1891 }
1892 //____________________________________________________________________
1893 void AliTRDcheckESD::PrintStatus(ULong_t status)
1894 {
1895 // Dump track status to stdout
1896
1897   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"
1898     ,Bool_t(status & AliESDtrack::kITSin)
1899     ,Bool_t(status & AliESDtrack::kITSout)
1900     ,Bool_t(status & AliESDtrack::kITSrefit)
1901     ,Bool_t(status & AliESDtrack::kTPCin)
1902     ,Bool_t(status & AliESDtrack::kTPCout)
1903     ,Bool_t(status & AliESDtrack::kTPCrefit)
1904     ,Bool_t(status & AliESDtrack::kTPCpid)
1905     ,Bool_t(status & AliESDtrack::kTRDin)
1906     ,Bool_t(status & AliESDtrack::kTRDout)
1907     ,Bool_t(status & AliESDtrack::kTRDrefit)
1908     ,Bool_t(status & AliESDtrack::kTRDpid)
1909     ,Bool_t(status & AliESDtrack::kTRDStop)
1910     ,Bool_t(status & AliESDtrack::kHMPIDout)
1911     ,Bool_t(status & AliESDtrack::kHMPIDpid)
1912   );
1913 }
1914
1915 //____________________________________________________________________
1916 TH1D* AliTRDcheckESD::Proj2D(TH2* hist, TH1* fitErr) {
1917   //
1918   // project the PH vs Slice 2D-histo into a 1D histo
1919   //
1920
1921   TH1D* hProjection = (TH1D*)hist->ProjectionX(Form("hProjection_%f", gRandom->Rndm()));
1922   hProjection->Reset();
1923
1924   TF1* fitLandau = new TF1("landauFunc","landau",0.,2000.);
1925   TH1D *hD;
1926   for(Int_t iBin=1;iBin<=hist->GetXaxis()->GetNbins();iBin++) {
1927     if(gROOT->FindObject("projection"))
1928       delete gROOT->FindObject("projection");
1929     hD = (TH1D*)hist->ProjectionY("projection",iBin,iBin);
1930     hD->Rebin(4);
1931     if(hD->Integral()>10) {
1932       fitLandau->SetParameter(1, hD->GetBinCenter(hD->GetMaximumBin()));
1933       fitLandau->SetParLimits(1, 0.2*hD->GetBinCenter(hD->GetMaximumBin()), 3.0*hD->GetBinCenter(hD->GetMaximumBin()));
1934       fitLandau->SetParameter(0, 1000.);
1935       fitLandau->SetParLimits(0, 1., 10000000.);
1936       fitLandau->SetParameter(2, 0.5*hD->GetBinCenter(hD->GetMaximumBin()));
1937       fitLandau->SetParLimits(2, 0.01*hD->GetBinCenter(hD->GetMaximumBin()), 1.0*hD->GetBinCenter(hD->GetMaximumBin()));
1938       hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
1939       hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
1940       hProjection->SetBinContent(iBin, fitLandau->GetParameter(1));
1941       hProjection->SetBinError(iBin, fitLandau->GetParameter(2));
1942       if(fitErr) {
1943         fitErr->SetBinContent(iBin, fitLandau->GetParameter(1));
1944         fitErr->SetBinError(iBin, fitLandau->GetParError(1));
1945       }
1946     }
1947     else{
1948       hProjection->SetBinContent(iBin, 0);
1949       hProjection->SetBinError(iBin, 0);
1950     }
1951   }
1952   return hProjection;
1953 }
1954
1955 //____________________________________________________________________
1956 TH2F* AliTRDcheckESD::Proj3D(TH3* hist, TH2* accMap, Int_t zbinLow, Int_t zbinHigh, Float_t &entries) {
1957   //
1958   //  Project a 3D histogram to a 2D histogram in the Z axis interval [zbinLow,zbinHigh]
1959   //  Return the 2D histogram and also the number of entries into this projection (entries)
1960
1961   Int_t nBinsX = hist->GetXaxis()->GetNbins();   // X and Y axis bins are assumed to be all equal
1962   Float_t minX = hist->GetXaxis()->GetXmin();
1963   Float_t maxX = hist->GetXaxis()->GetXmax();
1964   Int_t nBinsY = hist->GetYaxis()->GetNbins();
1965   Float_t minY = hist->GetYaxis()->GetXmin();
1966   Float_t maxY = hist->GetYaxis()->GetXmax();
1967   Int_t nBinsZ = hist->GetZaxis()->GetNbins();  // Z axis bins (pt) might have different widths
1968
1969   TH2F* projHisto = (TH2F*)gROOT->FindObject("projHisto");
1970   if(projHisto)
1971     projHisto->Reset();
1972   else
1973     projHisto = new TH2F("projHisto", "projection", nBinsX, minX, maxX, nBinsY, minY, maxY);
1974
1975   for(Int_t iZ=1; iZ<=nBinsZ; iZ++) {
1976     if(iZ<zbinLow) continue;
1977     if(iZ>zbinHigh) continue;
1978     for(Int_t iX=1; iX<=nBinsX; iX++) {
1979       for(Int_t iY=1; iY<=nBinsY; iY++) {
1980         if(accMap) {
1981           if(accMap->GetBinContent(iX,iY)>0.1)
1982             projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
1983         }
1984         else    // no acc. cut
1985           projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
1986         // count only the entries which are inside the acceptance map
1987         if(accMap) {
1988           if(accMap->GetBinContent(iX,iY)>0.1)
1989             entries+=hist->GetBinContent(iX,iY,iZ);
1990         }
1991         else    // no acc. cut
1992           entries+=hist->GetBinContent(iX,iY,iZ);
1993       }
1994     }
1995   }
1996   return projHisto;
1997 }
1998
1999 //____________________________________________________________________
2000 void AliTRDcheckESD::CheckActiveSM(TH1D* phiProj, Bool_t activeSM[18]) {
2001   //
2002   // Check the active super-modules
2003   //
2004   Double_t entries[18] = {0.0};
2005   Double_t smPhiLimits[19];
2006   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
2007   for(Int_t phiBin=1; phiBin<=phiProj->GetXaxis()->GetNbins(); ++phiBin) {
2008     Double_t phi = phiProj->GetBinCenter(phiBin);
2009     Int_t sm = -1;
2010     for(Int_t ism=0; ism<18; ++ism)
2011       if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1]) sm = ism;
2012     if(sm==-1) continue;
2013     entries[sm] += phiProj->GetBinContent(phiBin);
2014   }
2015   Double_t avEntries = Double_t(phiProj->Integral())/18.0;
2016   for(Int_t ism=0; ism<18; ++ism)
2017     if(entries[ism]>0.5*avEntries) activeSM[ism] = kTRUE;
2018 }
2019
2020
2021 //__________________________________________________________________________________________________
2022 TH1F* AliTRDcheckESD::EfficiencyFromPhiPt(AliCFContainer* cf, Int_t minNtrkl, Int_t maxNtrkl,
2023                                           Int_t stepNom, Int_t stepDenom, const Char_t* varStr/*="pt"*/, const Char_t* type/*="TPCTRD"*/) {
2024   //
2025   // Use the CF container to extract the efficiency vs pt
2026   //
2027   Int_t varTrackPhi = cf->GetVar("phi");
2028   Int_t var = cf->GetVar(varStr);
2029
2030   TH1D* phiProj = (TH1D*)cf->Project(1, varTrackPhi);
2031   Bool_t activeSM[18] = {kFALSE};
2032   CheckActiveSM(phiProj, activeSM); delete phiProj;
2033   Double_t smPhiLimits[19];
2034   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
2035
2036   TString effTypeStr = type;
2037   if(effTypeStr.Contains("TRDTOF")) {
2038     if(minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7)
2039       cf->SetRangeUser(cf->GetVar("tracklets"), Double_t(minNtrkl), Double_t(maxNtrkl));
2040   }
2041   TH2D* hDenomPhiVar = (TH2D*)cf->Project(stepDenom, var, varTrackPhi);
2042   if(effTypeStr.Contains("TPCTRD")) {
2043     if(minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7)
2044       cf->SetRangeUser(cf->GetVar("tracklets"), Double_t(minNtrkl), Double_t(maxNtrkl));
2045   }
2046   TH2D* hNomPhiVar = (TH2D*)cf->Project(stepNom, var, varTrackPhi);
2047   cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2048
2049   TH1F* hEff = new TH1F(Form("hEff%s_%d_%d_%f", varStr, stepNom, stepDenom, gRandom->Rndm()), "",
2050                         hNomPhiVar->GetXaxis()->GetNbins(), hNomPhiVar->GetXaxis()->GetXbins()->GetArray());
2051   for(Int_t ivar=1; ivar<=hEff->GetXaxis()->GetNbins(); ++ivar) {
2052     Double_t nom = 0.0; Double_t denom = 0.0;
2053     Double_t eff = 0.0; Double_t err = 0.0;
2054     for(Int_t iphi=1; iphi<=hNomPhiVar->GetYaxis()->GetNbins(); ++iphi) {
2055       Double_t phi = hNomPhiVar->GetYaxis()->GetBinCenter(iphi);
2056       Bool_t isActive = kFALSE;
2057       for(Int_t ism=0; ism<18; ++ism)
2058         if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism])
2059           isActive = kTRUE;
2060       if(!isActive) continue;
2061       nom += hNomPhiVar->GetBinContent(ivar, iphi);
2062       denom += hDenomPhiVar->GetBinContent(ivar, iphi);
2063     }
2064     eff = (denom>0.001 ? nom/denom : 0.0);
2065     err = (denom>0.001 && (denom-nom)>0.001 && nom>0.001 ? (TMath::Sqrt(nom*(denom-nom)/denom/denom/denom)) : 0.0);
2066     hEff->SetBinContent(ivar, eff);
2067     hEff->SetBinError(ivar, err);
2068   }   // end loop over pt bins
2069   delete hNomPhiVar; delete hDenomPhiVar;
2070   return hEff;
2071 }
2072
2073
2074 //____________________________________________________________________
2075 TH1F* AliTRDcheckESD::EfficiencyTRD(TH3* tpc3D, TH3* trd3D, Bool_t useAcceptance) {
2076   //
2077   // Calculate the TRD-TPC matching efficiency as function of pt
2078   //
2079
2080   if(!tpc3D || !trd3D) return NULL;
2081   Int_t nBinsZ = trd3D->GetZaxis()->GetNbins();
2082   // project everything on the eta-phi map to obtain an acceptance map
2083   Float_t nada = 0.;
2084   TH2F *trdAcc = (useAcceptance ? (TH2F*)Proj3D(trd3D, 0x0, 1, nBinsZ, nada)->Clone(Form("trdAcc%f", gRandom->Rndm())) : 0x0);
2085   TH1D *phiProj = (trdAcc ? trdAcc->ProjectionY(Form("phiProj%f", gRandom->Rndm())) : 0x0);
2086
2087   // prepare the acceptance map
2088   Bool_t activeSM[18] = {kFALSE};
2089   Double_t smPhiLimits[19];
2090   for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
2091   if(phiProj) {
2092     CheckActiveSM(phiProj, activeSM);   // get the active SMs
2093     trdAcc->Reset();
2094     // Put 1 entry in every bin which belongs to an active SM
2095     for(Int_t iY=1; iY<=trdAcc->GetYaxis()->GetNbins(); ++iY) {
2096       Double_t phi = trdAcc->GetYaxis()->GetBinCenter(iY);
2097       Bool_t isActive = kFALSE;
2098       for(Int_t ism=0; ism<18; ++ism) {
2099         if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) {
2100           isActive = kTRUE;
2101         }
2102       }
2103       if(!isActive) continue;
2104       for(Int_t iX=1; iX<=trdAcc->GetXaxis()->GetNbins(); ++iX)
2105         if(trdAcc->GetXaxis()->GetBinCenter(iX)>=-0.85 && trdAcc->GetXaxis()->GetBinCenter(iX)<=0.85) trdAcc->SetBinContent(iX, iY, 1.0);
2106     }  // end for over Y(phi) bins
2107   }  // end if phiProj
2108
2109   // get the bin limits from the Z axis of 3D histos
2110   Float_t *ptBinLimits = new Float_t[nBinsZ+1];
2111   for(Int_t i=1; i<=nBinsZ; i++) {
2112     ptBinLimits[i-1] = trd3D->GetZaxis()->GetBinLowEdge(i);
2113   }
2114   ptBinLimits[nBinsZ] = trd3D->GetZaxis()->GetBinUpEdge(nBinsZ);
2115
2116   TH1F *efficiency = new TH1F(Form("eff%d", Int_t(1000000.0*gRandom->Rndm())), "TRD-TPC matching efficiency", nBinsZ, ptBinLimits);
2117
2118   // loop over Z bins
2119   Bool_t effGood = kFALSE;
2120   for(Int_t i=1; i<=nBinsZ; i++) {
2121     Float_t tpcEntries = 0.0; Float_t trdEntries = 0.0;
2122     Proj3D(tpc3D, trdAcc, i, i, tpcEntries);
2123     Proj3D(trd3D, trdAcc, i, i, trdEntries);
2124     Float_t ratio = 0;
2125     if(tpcEntries>0) ratio = trdEntries/tpcEntries;
2126     Float_t error = 0;
2127     if(tpcEntries>0 && trdEntries>0 && (tpcEntries-trdEntries)>=0.0)
2128       error = TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries);
2129     if(ratio>0.001) {
2130       efficiency->SetBinContent(i,ratio);
2131       efficiency->SetBinError(i,error);
2132       effGood = kTRUE;
2133     }
2134   }     // end loop over Z bins
2135   if(!effGood) return 0x0;
2136
2137   return efficiency;
2138 }
2139
2140 //__________________________________________________________________________________________________
2141 void AliTRDcheckESD::PlotCentSummaryFromCF(Double_t* /*trendValues*/, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
2142   //
2143   // Make the centrality summary figure from the CF container
2144   //
2145   if(!fMatchingPtCF) return;
2146   AliCFContainer* cf = 0x0;
2147
2148   TLatex* lat=new TLatex();
2149   lat->SetTextSize(0.06);
2150   lat->SetTextColor(2);
2151
2152   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2153   gPad->Divide(3,3,0.,0.);
2154   TList* l=gPad->GetListOfPrimitives();
2155   TVirtualPad* pad=0x0;
2156
2157   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, 0.0, 0.0);
2158
2159   if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
2160   TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.3);
2161   rangeEffPt->SetStats(kFALSE);
2162   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2163   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2164
2165   Int_t padsForEffs[5] = {0,3,6,1,4};
2166   for(Int_t iCent=1; iCent<6; ++iCent) {
2167     pad = ((TVirtualPad*)l->At(padsForEffs[iCent-1])); pad->cd();
2168     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2169     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2170     rangeEffPt->Draw();
2171     TLine line;
2172     line.SetLineStyle(2);
2173     line.SetLineWidth(2);
2174     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2175     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2176
2177     cf = fMatchingPtCF;
2178     cf->SetRangeUser(cf->GetVar("multiplicity"), Double_t(iCent), Double_t(iCent), kTRUE);
2179
2180     cf->SetRangeUser(cf->GetVar("charge"), +1.0, +1.0);
2181     TH1F* hEffPosAll = EfficiencyFromPhiPt(cf,  0,  6, 1, 0);
2182     TH1F* hEffPosTrk4 = EfficiencyFromPhiPt(cf, 4,  4, 1, 0);
2183     TH1F* hEffPosTrk5 = EfficiencyFromPhiPt(cf, 5,  5, 1, 0);
2184     TH1F* hEffPosTrk6 = EfficiencyFromPhiPt(cf, 6,  6, 1, 0);
2185
2186     cf->SetRangeUser(cf->GetVar("charge"), -1.0, -1.0);
2187     TH1F* hEffNegAll = EfficiencyFromPhiPt(cf, 0, 6, 1, 0);
2188     TH1F* hEffNegTrk4 = EfficiencyFromPhiPt(cf, 4, 4, 1, 0);
2189     TH1F* hEffNegTrk5 = EfficiencyFromPhiPt(cf, 5, 5, 1, 0);
2190     TH1F* hEffNegTrk6 = EfficiencyFromPhiPt(cf, 6, 6, 1, 0);
2191     cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2192     cf->SetRangeUser(cf->GetVar("charge"), -1.0, +1.0);
2193
2194     SetStyle(hEffPosAll,  1, kRed, 1, 24, kRed, 1);
2195     SetStyle(hEffPosTrk4, 1, kRed, 1, 25, kRed, 1);
2196     SetStyle(hEffPosTrk5, 1, kRed, 1, 26, kRed, 1);
2197     SetStyle(hEffPosTrk6, 1, kRed, 1, 27, kRed, 1);
2198     SetStyle(hEffNegAll,  1, kBlue, 1, 24, kBlue, 1);
2199     SetStyle(hEffNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2200     SetStyle(hEffNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2201     SetStyle(hEffNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2202     hEffPosAll->Draw("same");
2203     hEffNegAll->Draw("same");
2204     hEffPosTrk4->Draw("same");
2205     hEffNegTrk4->Draw("same");
2206     hEffPosTrk5->Draw("same");
2207     hEffNegTrk5->Draw("same");
2208     hEffPosTrk6->Draw("same");
2209     hEffNegTrk6->Draw("same");
2210
2211     TLegend* leg=new TLegend(0.18, 0.7, 0.77, 0.89);
2212     if(iCent==1) {
2213       leg->SetFillColor(0);
2214       leg->SetNColumns(2);
2215       leg->SetMargin(0.1);
2216       leg->SetBorderSize(0);
2217       leg->AddEntry(hEffPosAll,  "pos. (#geq 1 tracklet)", "p");
2218       leg->AddEntry(hEffNegAll,  "neg. (#geq 1 tracklet)", "p");
2219       leg->AddEntry(hEffPosTrk4, "pos. (4 tracklets)", "p");
2220       leg->AddEntry(hEffNegTrk4, "neg. (4 tracklets)", "p");
2221       leg->AddEntry(hEffPosTrk5, "pos. (5 tracklets)", "p");
2222       leg->AddEntry(hEffNegTrk5, "neg. (5 tracklets)", "p");
2223       leg->AddEntry(hEffPosTrk6, "pos. (6 tracklets)", "p");
2224       leg->AddEntry(hEffNegTrk6, "neg. (6 tracklets)", "p");
2225       leg->Draw();
2226     }
2227     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)));
2228   }   // end for loop over multiplicity classes
2229
2230   // Reset the modified user ranges of the CF container
2231   cf->SetRangeUser(cf->GetVar("multiplicity"), 0., 3500.);
2232
2233   // Cluster distributions in all multiplicity classes
2234   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2235   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2236   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2237   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2238   if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
2239   TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
2240   SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
2241   SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2242   rangeNcls->SetStats(kFALSE);
2243   rangeNcls->Draw();
2244
2245   TH1D* hNcls[6]={0x0};
2246   TLegend* legCls=new TLegend(0.7, 0.75, 0.97, 0.97);
2247   legCls->SetBorderSize(0);
2248   legCls->SetFillColor(0);
2249   legCls->SetMargin(0.15);
2250   cf = fCentralityCF;
2251   for(Int_t iCent=0; iCent<6; ++iCent) {
2252     if(iCent>0)
2253       cf->SetRangeUser(cf->GetVar("multiplicity"), Double_t(iCent), Double_t(iCent), kTRUE);
2254     hNcls[iCent] = (TH1D*)cf->Project(0, cf->GetVar("clusters"));
2255     if(!hNcls[iCent]) continue;
2256
2257     hNcls[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2258     Double_t maximum = hNcls[iCent]->GetMaximum();
2259     if(maximum>1.0)
2260       hNcls[iCent]->Scale(1.0/maximum);
2261     hNcls[iCent]->SetStats(kFALSE);
2262     hNcls[iCent]->SetTitle("");
2263     hNcls[iCent]->SetLineWidth(2);
2264
2265     if(hNcls[iCent]->Integral()>0.01) {
2266       hNcls[iCent]->Draw("same");
2267       legCls->AddEntry(hNcls[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinLowEdge(iCent),
2268                                                                            cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinUpEdge(iCent))), "l");
2269     }
2270   }
2271   legCls->Draw();
2272   cf->SetRangeUser(cf->GetVar("multiplicity"), 0.0, 6.0, kTRUE);
2273
2274   // Qtot vs P
2275   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2276   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2277   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2278   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2279   if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
2280   TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
2281   SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2282   SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2283   rangeQtot->SetStats(kFALSE);
2284   rangeQtot->Draw();
2285
2286   TH1D* hQtot[6]={0x0};
2287   TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.97);
2288   leg2->SetFillColor(0);
2289   leg2->SetBorderSize(0);
2290
2291   for(Int_t iCent=0; iCent<6; ++iCent) {
2292     if(iCent>0)
2293       cf->SetRangeUser(cf->GetVar("multiplicity"), Double_t(iCent), Double_t(iCent), kTRUE);
2294
2295     hQtot[iCent] = (TH1D*)cf->Project(0, cf->GetVar("Qtot0"));
2296     if(!hQtot[iCent]) continue;
2297     hQtot[iCent]->SetBinContent(1, 0);
2298
2299     Double_t maximum = hQtot[iCent]->GetMaximum();
2300     if(maximum>1.0)
2301       hQtot[iCent]->Scale(1.0/maximum);
2302     hQtot[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2303     hQtot[iCent]->SetStats(kFALSE);
2304     hQtot[iCent]->SetTitle("");
2305     hQtot[iCent]->SetLineWidth(2);
2306     if(hQtot[iCent]->Integral()>0.01) {
2307       hQtot[iCent]->Draw(iCent==0 ? "" : "same");
2308       leg2->AddEntry(hQtot[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinLowEdge(iCent),
2309                                                                            cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinUpEdge(iCent))), "l");
2310     }
2311   }
2312   leg2->Draw();
2313   cf->SetRangeUser(cf->GetVar("multiplicity"), 0.0, 5.0, kTRUE);
2314   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2315 }
2316
2317
2318 //_________________________________________________________________
2319 void AliTRDcheckESD::PlotTrackingSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
2320   //
2321   //  Plot tracking summary
2322   //
2323   if(!fMatchingPhiEtaCF || !fMatchingPtCF || !fCentralityCF || !fBunchCrossingsCF) return;
2324   AliCFContainer* cf = 0x0;
2325
2326   TLatex *lat=new TLatex();
2327   lat->SetTextSize(0.06);
2328   lat->SetTextColor(2);
2329
2330   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2331   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2332   gPad->Divide(3,3,0.,0.);
2333   TList* l=gPad->GetListOfPrimitives();
2334
2335   // eta-phi distr. for positive TPC tracks
2336   TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
2337   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2338   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2339   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2340
2341   //cf->SetRangeUser(stepDCAxy, -0.999, +0.999);
2342   //cf->SetRangeUser(stepDCAz, -3.0, +3.0);
2343   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, 0.0, 0.0);
2344
2345   // find all the isolated bunch crossings with entries
2346   TH2D* hTPCrefPos = 0x0; TH2D* hTRDrefPos = 0x0; TH2D* hTOFrefPos = 0x0;
2347   TH2D* hTPCrefNeg = 0x0; TH2D* hTRDrefNeg = 0x0; TH2D* hTOFrefNeg = 0x0;
2348   cf = fMatchingPhiEtaCF;
2349   cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2350   cf->SetRangeUser(cf->GetVar("charge"), +1.0, +1.0);      // positive charges
2351   hTPCrefPos = (TH2D*)cf->Project(0, cf->GetVar("eta"), cf->GetVar("phi"));
2352   hTRDrefPos = (TH2D*)cf->Project(1, cf->GetVar("eta"), cf->GetVar("phi"));
2353   hTOFrefPos = (TH2D*)cf->Project(2, cf->GetVar("eta"), cf->GetVar("phi"));
2354   cf->SetRangeUser(cf->GetVar("charge"), -1.0, -1.0);      // negative charges
2355   hTPCrefNeg = (TH2D*)cf->Project(0, cf->GetVar("eta"), cf->GetVar("phi"));
2356   hTRDrefNeg = (TH2D*)cf->Project(1, cf->GetVar("eta"), cf->GetVar("phi"));
2357   hTOFrefNeg = (TH2D*)cf->Project(2, cf->GetVar("eta"), cf->GetVar("phi"));
2358   cf->SetRangeUser(cf->GetVar("charge"), -1.0, +1.0);      // reset charge cut
2359
2360   if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
2361   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
2362   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
2363   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
2364   rangeEtaPhi->SetStats(kFALSE);
2365
2366   //----------------------------------------------
2367   // eta-phi efficiency for positive TRD tracks
2368   pad = ((TVirtualPad*)l->At(0)); pad->cd();
2369   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2370   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2371   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2372   rangeEtaPhi->Draw();
2373
2374   TH2D* hTRDeffPos = (hTRDrefPos ? (TH2D*)hTRDrefPos->Clone("hTRDeffPos") : 0x0);
2375   if(hTRDeffPos) {
2376     hTRDeffPos->Reset();
2377     hTRDeffPos->SetStats(kFALSE);
2378     hTRDeffPos->Divide(hTRDrefPos, hTPCrefPos);
2379     hTRDeffPos->SetMaximum(1.0);
2380     hTRDeffPos->Draw("samecolz");
2381     lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for positive tracks");
2382     DrawTRDGrid();
2383   }
2384
2385   //----------------------------------------------
2386   // eta-phi efficiency for negative TRD tracks
2387   pad = ((TVirtualPad*)l->At(3)); pad->cd();
2388   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2389   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2390   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2391   rangeEtaPhi->Draw();
2392
2393   TH2D* hTRDeffNeg = (hTRDrefNeg ? (TH2D*)hTRDrefNeg->Clone("hTRDeffNeg") : 0x0);
2394   if(hTRDeffNeg) {
2395     hTRDeffNeg->Reset();
2396     hTRDeffNeg->SetStats(kFALSE);
2397     hTRDeffNeg->Divide(hTRDrefNeg, hTPCrefNeg);
2398     hTRDeffNeg->SetMaximum(1.0);
2399     hTRDeffNeg->Draw("samecolz");
2400     lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for negative tracks");
2401     DrawTRDGrid();
2402   }
2403
2404   //----------------------------------------------
2405   // eta-phi TRD-TOF matching efficiency for positive tracks
2406   pad = ((TVirtualPad*)l->At(1)); pad->cd();
2407   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2408   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2409   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2410   rangeEtaPhi->Draw();
2411
2412   TH2D* hTOFeffPos = (hTOFrefPos ? (TH2D*)hTOFrefPos->Clone("hTOFeffPos") : 0x0);
2413   if(hTOFeffPos) {
2414     hTOFeffPos->Reset();
2415     hTOFeffPos->SetStats(kFALSE);
2416     hTOFeffPos->Divide(hTOFrefPos, hTRDrefPos);
2417     hTOFeffPos->SetMaximum(1.0);
2418     hTOFeffPos->Draw("samecolz");
2419     lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for positive tracks");
2420     DrawTRDGrid();
2421   }
2422
2423   //----------------------------------------------
2424   // eta-phi TRD-TOF matching efficiency for negative tracks
2425   pad = ((TVirtualPad*)l->At(4)); pad->cd();
2426   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2427   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2428   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2429   rangeEtaPhi->Draw();
2430
2431   TH2D* hTOFeffNeg = (hTOFrefNeg ? (TH2D*)hTOFrefNeg->Clone("hTOFeffNeg") : 0x0);
2432   if(hTOFeffNeg) {
2433     hTOFeffNeg->Reset();
2434     hTOFeffNeg->SetStats(kFALSE);
2435     hTOFeffNeg->Divide(hTOFrefNeg, hTRDrefNeg);
2436     hTOFeffNeg->SetMaximum(1.0);
2437     hTOFeffNeg->Draw("samecolz");
2438     lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for negative tracks");
2439     DrawTRDGrid();
2440   }
2441
2442   if(hTRDrefPos) delete hTRDrefPos; if(hTPCrefPos) delete hTPCrefPos; if(hTOFrefPos) delete hTOFrefPos;
2443   if(hTRDrefNeg) delete hTRDrefNeg; if(hTPCrefNeg) delete hTPCrefNeg; if(hTOFrefNeg) delete hTOFrefNeg;
2444
2445   // switch to the Pt cf container
2446   cf = fMatchingPtCF;
2447   cf->SetRangeUser(cf->GetVar("charge"), +1.0, +1.0);
2448   TH1F* hTRDEffPtPosAll = EfficiencyFromPhiPt(cf, 0, 6, 1, 0);
2449   TH1F* hTOFEffPtPosAll = EfficiencyFromPhiPt(cf, 0, 6, 2, 1, "pt", "TRDTOF");
2450   TH1F* hTRDEffPtPosTrk4 = EfficiencyFromPhiPt(cf, 4, 4, 1, 0);
2451   TH1F* hTOFEffPtPosTrk4 = EfficiencyFromPhiPt(cf, 4, 4, 2, 1, "pt", "TRDTOF");
2452   TH1F* hTRDEffPtPosTrk5 = EfficiencyFromPhiPt(cf, 5, 5, 1, 0);
2453   TH1F* hTOFEffPtPosTrk5 = EfficiencyFromPhiPt(cf, 5, 5, 2, 1, "pt", "TRDTOF");
2454   TH1F* hTRDEffPtPosTrk6 = EfficiencyFromPhiPt(cf, 6, 6, 1, 0);
2455   TH1F* hTOFEffPtPosTrk6 = EfficiencyFromPhiPt(cf, 6, 6, 2, 1, "pt", "TRDTOF");
2456
2457   cf->SetRangeUser(cf->GetVar("charge"), -1.0, -1.0);
2458   TH1F* hTRDEffPtNegAll = EfficiencyFromPhiPt(cf, 0, 6, 1, 0);
2459   TH1F* hTOFEffPtNegAll = EfficiencyFromPhiPt(cf, 0, 6, 2, 1, "pt", "TRDTOF");
2460   TH1F* hTRDEffPtNegTrk4 = EfficiencyFromPhiPt(cf, 4, 4, 1, 0);
2461   TH1F* hTOFEffPtNegTrk4 = EfficiencyFromPhiPt(cf, 4, 4, 2, 1, "pt", "TRDTOF");
2462   TH1F* hTRDEffPtNegTrk5 = EfficiencyFromPhiPt(cf, 5, 5, 1, 0);
2463   TH1F* hTOFEffPtNegTrk5 = EfficiencyFromPhiPt(cf, 5, 5, 2, 1, "pt", "TRDTOF");
2464   TH1F* hTRDEffPtNegTrk6 = EfficiencyFromPhiPt(cf, 6, 6, 1, 0);
2465   TH1F* hTOFEffPtNegTrk6 = EfficiencyFromPhiPt(cf, 6, 6, 2, 1, "pt", "TRDTOF");
2466   cf->SetRangeUser(cf->GetVar("charge"), -1.0, +1.0);
2467
2468   TF1* funcConst = new TF1("constFunc", "[0]", 1.0, 3.0);
2469   if(trendValues) {
2470     if(hTRDEffPtPosAll && hTRDEffPtPosAll->Integral()>0.1) {
2471       hTRDEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2472       trendValues[0] = funcConst->GetParameter(0);
2473       trendValues[1] = funcConst->GetParError(0);
2474     }
2475   }
2476   if(trendValues) {
2477     if(hTRDEffPtNegAll && hTRDEffPtNegAll->Integral()>0.1) {
2478       hTRDEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2479       trendValues[2] = funcConst->GetParameter(0);
2480       trendValues[3] = funcConst->GetParError(0);
2481     }
2482   }
2483   if(trendValues) {
2484     if(hTOFEffPtPosAll && hTOFEffPtPosAll->Integral()>0.1) {
2485       hTOFEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2486       trendValues[4] = funcConst->GetParameter(0);
2487       trendValues[5] = funcConst->GetParError(0);
2488     }
2489   }
2490   if(trendValues) {
2491     if(hTOFEffPtNegAll && hTOFEffPtNegAll->Integral()>0.1) {
2492       hTOFEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2493       trendValues[6] = funcConst->GetParameter(0);
2494       trendValues[7] = funcConst->GetParError(0);
2495     }
2496   }
2497
2498   //---------------------------------------------------------
2499   // TPC-TRD matching efficiency vs pt
2500   pad = ((TVirtualPad*)l->At(6)); pad->cd();
2501   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2502   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2503   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2504
2505   if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
2506   TH2F* rangeEffPt=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
2507   rangeEffPt->SetStats(kFALSE);
2508   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2509   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2510   rangeEffPt->Draw();
2511   lat->DrawLatex(0.2, 1.42, "TPC-TRD matching efficiency");
2512   //++++++++++++++++++
2513   TLine line;
2514   line.SetLineStyle(2);
2515   line.SetLineWidth(2);
2516   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2517   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2518   TLegend* leg=new TLegend(0.2, 0.7, 0.7, 0.89);
2519   leg->SetNColumns(2);
2520   leg->SetMargin(0.15);
2521   leg->SetBorderSize(0);
2522   leg->SetFillColor(0);
2523
2524   SetStyle(hTRDEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
2525   SetStyle(hTRDEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
2526   SetStyle(hTRDEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
2527   SetStyle(hTRDEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2528   SetStyle(hTRDEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
2529   SetStyle(hTRDEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2530   SetStyle(hTRDEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
2531   SetStyle(hTRDEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2532   if(hTRDEffPtPosAll) {hTRDEffPtPosAll->Draw("same"); leg->AddEntry(hTRDEffPtPosAll, "pos. (#geq 1 tracklet)", "p");}
2533   if(hTRDEffPtNegAll) {hTRDEffPtNegAll->Draw("same"); leg->AddEntry(hTRDEffPtNegAll, "neg. (#geq 1 tracklet)", "p");}
2534   hTRDEffPtPosTrk4->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4, "pos. (4 tracklets)", "p");
2535   hTRDEffPtNegTrk4->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4, "neg. (4 tracklets)", "p");
2536   hTRDEffPtPosTrk5->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5, "pos. (5 tracklets)", "p");
2537   hTRDEffPtNegTrk5->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5, "neg. (5 tracklets)", "p");
2538   hTRDEffPtPosTrk6->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6, "pos. (6 tracklets)", "p");
2539   hTRDEffPtNegTrk6->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6, "neg. (6 tracklets)", "p");
2540
2541   leg->Draw();
2542
2543   //---------------------------------------------------------
2544   // TRD-TOF matching efficiency vs pt
2545   pad = ((TVirtualPad*)l->At(7)); pad->cd();
2546   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2547   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2548   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2549
2550   rangeEffPt->Draw();
2551   lat->DrawLatex(0.2, 1.42, "TRD-TOF matching efficiency");
2552   SetStyle(hTOFEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
2553   SetStyle(hTOFEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
2554   SetStyle(hTOFEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
2555   SetStyle(hTOFEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
2556   SetStyle(hTOFEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
2557   SetStyle(hTOFEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2558   SetStyle(hTOFEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2559   SetStyle(hTOFEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2560   if(hTOFEffPtPosAll) hTOFEffPtPosAll->Draw("same");
2561   hTOFEffPtPosTrk4->Draw("same");
2562   hTOFEffPtPosTrk5->Draw("same");
2563   hTOFEffPtPosTrk6->Draw("same");
2564   if(hTOFEffPtNegAll) hTOFEffPtNegAll->Draw("same");
2565   hTOFEffPtNegTrk4->Draw("same");
2566   hTOFEffPtNegTrk5->Draw("same");
2567   hTOFEffPtNegTrk6->Draw("same");
2568
2569   //-----------------------------------------------------
2570   // <ntracklets> vs (phi,eta)
2571   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2572   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2573   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2574   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2575
2576   rangeEtaPhi->Draw();
2577   lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>");
2578
2579   cf = fMatchingPhiEtaCF;
2580   TH3D* hNtracklets = (TH3D*)cf->Project(1, cf->GetVar("phi"), cf->GetVar("eta"), cf->GetVar("tracklets"));
2581
2582   TProfile2D* hNtrackletsProf = hNtracklets->Project3DProfile();
2583   delete hNtracklets;
2584   if(hNtrackletsProf) {
2585     hNtrackletsProf->SetStats(kFALSE);
2586     hNtrackletsProf->SetMinimum(0.);
2587     hNtrackletsProf->SetMaximum(6.);
2588     hNtrackletsProf->Draw("samecolz");
2589     DrawTRDGrid();
2590   }
2591
2592   // calculate the trend value for tracklets/track
2593   cf = fMatchingPtCF;
2594   TH2D* hNtrackletsVsP = (TH2D*)cf->Project(1, cf->GetVar("pt"), cf->GetVar("tracklets"));
2595   if(trendValues &&  hNtrackletsVsP && hNtrackletsVsP->GetEntries()>0.1) {
2596     TProfile* hNtrackletsVsPprof = hNtrackletsVsP->ProfileX("hNtrackletsVsPprof");
2597     hNtrackletsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2598     trendValues[8] = funcConst->GetParameter(0);
2599     trendValues[9] = funcConst->GetParError(0);
2600     delete hNtrackletsVsP;
2601   }
2602
2603   //--------------------------------------------------------------
2604   // Nclusters per TRD track vs momentum
2605   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2606   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
2607   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2608   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2609   pad->SetLogz();
2610
2611   if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
2612   TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
2613   SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2614   SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
2615   rangeNclsP->SetStats(kFALSE);
2616   rangeNclsP->Draw();
2617   lat->DrawLatex(1.0, 205., "TRD Clusters / track");
2618
2619   cf = fCentralityCF;
2620   TH2D* hNclsVsP = (TH2D*)cf->Project(0, cf->GetVar("P"), cf->GetVar("clusters"));
2621   if(hNclsVsP) {
2622     hNclsVsP->SetStats(kFALSE);
2623     hNclsVsP->Draw("samecolz");
2624   }
2625
2626   if(trendValues && hNclsVsP && hNclsVsP->GetEntries()>10) {
2627     TProfile* hNclsVsPprof = hNclsVsP->ProfileX("hNclsVsPprof");
2628     hNclsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2629     trendValues[10] = funcConst->GetParameter(0);
2630     trendValues[11] = funcConst->GetParError(0);
2631   }
2632
2633   //--------------------------------------------------------------
2634   // TRD-TPC and TOF-TRD matching efficiency vs bunch crossing
2635   pad = ((TVirtualPad*)l->At(8)); pad->cd();
2636   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2637   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2638   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2639
2640   cf = fBunchCrossingsCF;
2641   TH1F* hTRDEffBC = EfficiencyFromPhiPt(cf, 0, 6, 1, 0, "BC", "TPCTRD");
2642   TH1F* hTOFEffBC = EfficiencyFromPhiPt(cf, 0, 6, 2, 1, "BC", "TRDTOF");
2643
2644   if(gROOT->FindObject("rangeBC")) delete gROOT->FindObject("rangeBC");
2645   TH2F* rangeBC = new TH2F("rangeBC", "", 10, -0.5, 3499.5, 10, 0.0, 1.4);
2646   rangeBC->SetStats(kFALSE);
2647   SetStyle(rangeBC->GetXaxis(), "Bunch crossing", 0.07, 0.8, kTRUE, 0.05);
2648   SetStyle(rangeBC->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2649   rangeBC->Draw();
2650
2651   TLegend* legBC=new TLegend(0.8, 0.7, 0.95, 0.89);
2652   legBC->SetBorderSize(0);
2653   legBC->SetMargin(0.15);
2654   legBC->SetFillColor(0);
2655   if(hTRDEffBC) {
2656     hTRDEffBC->SetStats(kFALSE);
2657     SetStyle(hTRDEffBC, 1, kRed, 2, 24, kRed, 1); legBC->AddEntry(hTRDEffBC, "TPC-TRD", "p");
2658     SetStyle(hTOFEffBC, 1, kBlue, 2, 24, kBlue, 1); legBC->AddEntry(hTOFEffBC, "TRD-TOF", "p");
2659     hTRDEffBC->Draw("same");
2660     hTOFEffBC->Draw("same");
2661     legBC->Draw();
2662     lat->DrawLatex(200., 1.42, "Matching efficiency at 1<p_{T}<3 GeV/c");
2663   }
2664
2665   // reset the user range on the event multiplicity
2666   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2667
2668   delete funcConst;
2669 }
2670
2671
2672 //_________________________________________________________________
2673 void AliTRDcheckESD::PlotPidSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
2674   //
2675   // Centrality summary
2676   //
2677   if(!fQtotCF || !fPulseHeightCF || !fCentralityCF) return;
2678
2679   AliCFContainer* cf = 0x0;
2680
2681   TLatex *lat=new TLatex();
2682   lat->SetTextSize(0.07);
2683   lat->SetTextColor(2);
2684   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2685   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2686   gPad->Divide(3,3,0.,0.);
2687   TList* l=gPad->GetListOfPrimitives();
2688
2689   //cf->SetRangeUser(stepDCAxy, -0.999, +0.999);
2690   //cf->SetRangeUser(stepDCAz, -3.0, +3.0);
2691   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, 0.0, 0.0);
2692
2693   if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
2694   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
2695   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
2696   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
2697   rangeEtaPhi->SetStats(kFALSE);
2698
2699   // eta-phi distr. for <Qtot> in layer 0
2700   TVirtualPad* pad;
2701   TProfile2D* hProf2D;
2702   cf = fQtotCF;
2703   for(Int_t iLayer=0; iLayer<6; ++iLayer) {
2704     pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
2705     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2706     pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2707     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2708     rangeEtaPhi->Draw();
2709
2710     cf->SetRangeUser(cf->GetVar("layer"), Double_t(iLayer), Double_t(iLayer));
2711     TH3D* hQtotEtaPhi = (TH3D*)cf->Project(0, cf->GetVar("phi"), cf->GetVar("eta"), cf->GetVar("Qtot0"));
2712     hProf2D = (hQtotEtaPhi ? hQtotEtaPhi->Project3DProfile() : 0x0);
2713     if(hQtotEtaPhi) delete hQtotEtaPhi;
2714
2715     if(hProf2D) {
2716       hProf2D->SetName(Form("Qtot_layer%d",iLayer));
2717       hProf2D->SetStats(kFALSE);
2718       hProf2D->SetMinimum(0.);
2719       hProf2D->SetMaximum(4.);
2720       hProf2D->Draw("samecolz");
2721     }
2722     lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer));
2723     DrawTRDGrid();
2724   }
2725   cf->SetRangeUser(cf->GetVar("layer"), 0.0, 5.0);
2726
2727   // PH versus slice number
2728   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2729   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2730   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
2731   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2732
2733   if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
2734   TH2F* rangePHslice=new TH2F("rangePHslice", "", 8, -0.5, 7.5, 10, 0.0, 6.);
2735   rangePHslice->SetStats(kFALSE);
2736   SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
2737   SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
2738   rangePHslice->Draw();
2739
2740   TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
2741
2742   cf = fPulseHeightCF;
2743   TH2D* hPH = (TH2D*)cf->Project(0, cf->GetVar("slice"), cf->GetVar("PH0"));
2744   TH1D* hSliceErr = new TH1D(Form("hSliceErr%f", gRandom->Rndm()), "", hPH->GetXaxis()->GetNbins(), hPH->GetXaxis()->GetXbins()->GetArray());
2745   TH1D* hLandauFit = Proj2D(hPH, hSliceErr);
2746   hPH->SetStats(kFALSE);
2747   hPH->Draw("samecolz");
2748   if(trendValues) {
2749     hSliceErr->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
2750     trendValues[12] = funcPol1->GetParameter(0);  // PH plateau
2751     trendValues[13] = funcPol1->GetParError(0);   // PH plateau
2752     trendValues[14] = funcPol1->GetParameter(1);  // PH slope
2753     trendValues[15] = funcPol1->GetParError(1);   // PH slope
2754   }
2755   hLandauFit->SetLineWidth(2);
2756   hLandauFit->SetLineStyle(2);
2757   hLandauFit->Draw("same");
2758
2759   delete funcPol1; delete hSliceErr;
2760
2761   // Qtot vs P
2762   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2763   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2764   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
2765   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2766   pad->SetLogz();
2767
2768   if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
2769   TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99);
2770   SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2771   SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
2772   rangeQtotP->SetStats(kFALSE);
2773   rangeQtotP->Draw();
2774
2775   cf = fCentralityCF;
2776   TH2D* hQtotP = (TH2D*)cf->Project(0, cf->GetVar("P"), cf->GetVar("Qtot0"));
2777
2778   if(hQtotP)
2779     for(Int_t i=1; i<=hQtotP->GetXaxis()->GetNbins(); ++i)
2780       hQtotP->SetBinContent(i, 1, 0.0);
2781   TH1D* hQtotProj = (hQtotP ? Proj2D(hQtotP) : 0x0);
2782   if(hQtotProj) SetStyle(hQtotProj, 2, kBlue, 2, 1, kBlue, 1);
2783   if(trendValues && hQtotProj && hQtotProj->GetEntries()>2) {
2784     trendValues[16] = hQtotProj->GetBinContent(hQtotProj->FindBin(1.0));   // Landau MPV at 1GeV/c
2785     trendValues[17] = hQtotProj->GetBinError(hQtotProj->FindBin(1.0));     // Landau width at 1 GeV/c
2786   }
2787   if(hQtotP) {
2788     hQtotP->SetStats(kFALSE);
2789     hQtotP->Draw("samecolz");
2790     hQtotProj->Draw("same");
2791   }
2792   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2793 }
2794
2795
2796 //_________________________________________________________________
2797 Bool_t AliTRDcheckESD::PlotCentSummary(Double_t* /*trendValues*/) {
2798
2799   Bool_t isGoodForSaving=kFALSE;
2800
2801   TLatex* lat=new TLatex();
2802   lat->SetTextSize(0.06);
2803   lat->SetTextColor(2);
2804
2805   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2806   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2807   gPad->Divide(3,3,0.,0.);
2808   TList* l=gPad->GetListOfPrimitives();
2809
2810   TPad* pad=0x0;
2811
2812   if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
2813   TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.4);
2814   rangeEffPt->SetStats(kFALSE);
2815   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2816   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2817
2818   TH3F *h3(NULL), *h3p(NULL), *h3n(NULL);
2819   Int_t padsForEffs[5] = {0,3,6,1,4};
2820   for(Int_t iCent=1; iCent<6; ++iCent) {
2821     // TPC-TRD matching efficiencies
2822     pad = ((TPad*)l->At(padsForEffs[iCent-1])); pad->cd();
2823     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2824     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2825
2826     if(!(h3p = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+iCent)))) continue;
2827     if(!(h3n = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+iCent)))) continue;
2828     // =============================================
2829     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+iCent)))) continue;
2830     TH1F* hFeffP = EfficiencyTRD(h3p, h3, kTRUE);
2831     //
2832     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+iCent)))) continue;
2833     TH1F* hFeffN = EfficiencyTRD(h3n, h3, kTRUE);
2834     // =============================================
2835     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+iCent)))) continue;
2836     TH1F* hFeffP4 = EfficiencyTRD(h3p, h3, kTRUE);
2837     //
2838     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+iCent)))) continue;
2839     TH1F* hFeffN4 = EfficiencyTRD(h3n, h3, kTRUE);
2840     // =============================================
2841     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+iCent)))) continue;
2842     TH1F* hFeffP5 = EfficiencyTRD(h3p, h3, kTRUE);
2843     //
2844     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+iCent)))) continue;
2845     TH1F* hFeffN5 = EfficiencyTRD(h3n, h3, kTRUE);
2846     // =============================================
2847     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+iCent)))) continue;
2848     TH1F* hFeffP6 = EfficiencyTRD(h3p, h3, kTRUE);
2849     //
2850     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+iCent)))) continue;
2851     TH1F* hFeffN6 = EfficiencyTRD(h3n, h3, kTRUE);
2852
2853     rangeEffPt->Draw();
2854
2855     TLine line;
2856     line.SetLineStyle(2);
2857     line.SetLineWidth(2);
2858     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2859     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2860     line.SetLineStyle(1);
2861     line.SetLineWidth(1);
2862     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 1.0, rangeEffPt->GetXaxis()->GetXmax(), 1.0);
2863     if(hFeffP) SetStyle(hFeffP, 1, kRed, 1, 24, kRed, 1);
2864     if(hFeffP4) SetStyle(hFeffP4, 1, kRed, 1, 25, kRed, 1);
2865     if(hFeffP5) SetStyle(hFeffP5, 1, kRed, 1, 26, kRed, 1);
2866     if(hFeffP6) SetStyle(hFeffP6, 1, kRed, 1, 27, kRed, 1);
2867     if(hFeffN) SetStyle(hFeffN, 1, kBlue, 1, 24, kBlue, 1);
2868     if(hFeffN4) SetStyle(hFeffN4, 1, kBlue, 1, 25, kBlue, 1);
2869     if(hFeffN5) SetStyle(hFeffN5, 1, kBlue, 1, 26, kBlue, 1);
2870     if(hFeffN6) SetStyle(hFeffN6, 1, kBlue, 1, 27, kBlue, 1);
2871
2872     TLegend* leg=new TLegend(0.16, 0.7, 0.61, 0.89);
2873     leg->SetFillColor(0);
2874     leg->SetNColumns(2);
2875     leg->SetTextSize(0.039);
2876     leg->SetMargin(0.1);
2877     if(hFeffP && hFeffP->Integral()>0.001) {
2878       isGoodForSaving = kTRUE;
2879       hFeffP->Draw("same");
2880       leg->AddEntry(hFeffP, "pos. (#geq 1 trcklt)", "p");
2881     }
2882     if(hFeffN && hFeffN->Integral()>0.001) {
2883       isGoodForSaving = kTRUE;
2884       hFeffN->Draw("same");
2885       leg->AddEntry(hFeffN, "neg. (#geq 1 trcklt)", "p");
2886     }
2887     if(hFeffP4 && hFeffP4->Integral()>0.001) {
2888       isGoodForSaving = kTRUE;
2889       hFeffP4->Draw("same");
2890       leg->AddEntry(hFeffP4, "pos. (4 trcklts)", "p");
2891     }
2892     if(hFeffN4 && hFeffN4->Integral()>0.001) {
2893       isGoodForSaving = kTRUE;
2894       hFeffN4->Draw("same");
2895       leg->AddEntry(hFeffN4, "neg. (4 trcklts)", "p");
2896     }
2897     if(hFeffP5 && hFeffP5->Integral()>0.001) {
2898       isGoodForSaving = kTRUE;
2899       hFeffP5->Draw("same");
2900       leg->AddEntry(hFeffP5, "pos. (5 trcklts)", "p");
2901     }
2902     if(hFeffN5 && hFeffN5->Integral()>0.001) {
2903       isGoodForSaving = kTRUE;
2904       hFeffN5->Draw("same");
2905       leg->AddEntry(hFeffN5, "neg. (5 trcklts)", "p");
2906     }
2907     if(hFeffP6 && hFeffP6->Integral()>0.001) {
2908       isGoodForSaving = kTRUE;
2909       hFeffP6->Draw("same");
2910       leg->AddEntry(hFeffP6, "pos. (6 trcklts)", "p");
2911     }
2912     if(hFeffN6 && hFeffN6->Integral()>0.001) {
2913       isGoodForSaving = kTRUE;
2914       hFeffN6->Draw("same");
2915       leg->AddEntry(hFeffN6, "neg. (6 trklts)", "p");
2916     }
2917
2918     if(isGoodForSaving) {
2919       if(iCent==1) leg->Draw();
2920       lat->DrawLatex(5.6, 1.3, Form("Centrality class %d", iCent));
2921       lat->DrawLatex(0.5, 1.42, "TPC-TRD matching efficiency");
2922     }
2923   }   // end loop over multiplicity intervals
2924
2925   // Number of clusters per TRD track
2926   pad = ((TPad*)l->At(2)); pad->cd();
2927   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2928   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2929   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2930   if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
2931   TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
2932   SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
2933   SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2934   rangeNcls->SetStats(kFALSE);
2935   rangeNcls->Draw();
2936
2937   TH2F* h2F[6]; TH1D* proj[6];
2938   TLegend* leg=new TLegend(0.2, 0.7, 0.5, 0.95);
2939   leg->SetFillColor(0);
2940   Bool_t isGood=kFALSE;
2941   for(Int_t iCent=0; iCent<6; ++iCent) {
2942     h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+iCent));
2943     proj[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projCent%d",iCent)) : 0x0);
2944     if(proj[iCent]) {
2945       proj[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2946       Double_t maximum = proj[iCent]->GetMaximum();
2947       if(maximum>1.0)
2948         proj[iCent]->Scale(1.0/maximum);
2949       proj[iCent]->SetStats(kFALSE);
2950       proj[iCent]->Draw("same");
2951       leg->AddEntry(proj[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
2952       isGood = kTRUE;
2953     }
2954   }
2955   if(isGood) leg->Draw();
2956   isGoodForSaving = isGoodForSaving || isGood;
2957
2958   // Qtot vs P
2959   pad = ((TPad*)l->At(5)); pad->cd();
2960   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2961   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2962   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2963   if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
2964   TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
2965   SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2966   SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2967   rangeQtot->SetStats(kFALSE);
2968   rangeQtot->Draw();
2969
2970   TH1D* projQ[6];
2971   TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.95);
2972   leg2->SetFillColor(0);
2973   isGood = kFALSE;
2974   for(Int_t iCent=0; iCent<6; ++iCent) {
2975     h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kQtotP+iCent));
2976     projQ[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projQCent%d",iCent)) : 0x0);
2977     if(projQ[iCent]) {
2978       projQ[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2979       Double_t maximum = projQ[iCent]->GetMaximum();
2980       if(maximum>1.0)
2981         projQ[iCent]->Scale(1.0/maximum);
2982       projQ[iCent]->SetStats(kFALSE);
2983       projQ[iCent]->Draw("same");
2984       leg2->AddEntry(projQ[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
2985       isGood = kTRUE;
2986     }
2987   }
2988   if(isGood) leg2->Draw();
2989   isGoodForSaving = isGoodForSaving || isGood;
2990   return isGoodForSaving;
2991 }
2992
2993
2994 //_________________________________________________________________
2995 Bool_t AliTRDcheckESD::PlotTrackingSummary(Int_t centralityClass, Double_t* trendValues) {
2996
2997   Bool_t isGoodForSaving=kFALSE;
2998
2999   TLatex *lat=new TLatex();
3000   lat->SetTextSize(0.07);
3001   lat->SetTextColor(2);
3002   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
3003   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
3004   gPad->Divide(3,3,0.,0.);
3005   TList* l=gPad->GetListOfPrimitives();
3006   // eta-phi distr. for positive TPC tracks
3007   TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
3008   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3009   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3010   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3011   if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
3012   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
3013   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
3014   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
3015   rangeEtaPhi->SetStats(kFALSE);
3016   rangeEtaPhi->Draw();
3017   lat->DrawLatex(-0.9, 3.6, "TPC positive ref. tracks");
3018
3019   TH3F* h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass));
3020   TH2F* h2FtpcP = 0x0;
3021   Float_t nada=0.0;
3022   if(h3F && h3F->GetEntries()>10) {
3023     h2FtpcP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3024     h2FtpcP->SetStats(kFALSE);
3025     h2FtpcP->Draw("samecolz"); isGoodForSaving = kTRUE;
3026     isGoodForSaving = kTRUE;
3027   }
3028   //-----------------
3029   // eta-phi distr. for negative TPC tracks
3030   pad = ((TVirtualPad*)l->At(1)); pad->cd();
3031   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3032   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3033   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3034   rangeEtaPhi->Draw();
3035   lat->DrawLatex(-0.9, 3.6, "TPC negative ref. tracks");
3036
3037   h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass));
3038   TH2F* h2FtpcN = 0x0;
3039   if(h3F && h3F->GetEntries()>10) {
3040     h2FtpcN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3041     h2FtpcN->SetStats(kFALSE);
3042     h2FtpcN->Draw("samecolz");
3043     isGoodForSaving = kTRUE;
3044   }
3045   //----------------------------------------------
3046   // eta-phi distr. for positive TRD tracks
3047   pad = ((TVirtualPad*)l->At(3)); pad->cd();
3048   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3049   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3050   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3051   rangeEtaPhi->Draw();
3052   lat->DrawLatex(-0.9, 3.6, "TRD positive ref. tracks");
3053
3054   h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass));
3055   TH2F* h2FtrdP = 0x0;
3056   if(h3F && h3F->GetEntries()>10) {
3057     h2FtrdP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3058     h2FtrdP->SetStats(kFALSE);
3059     h2FtrdP->SetMaximum((h2FtpcP ? h2FtpcP->GetMaximum() : h2FtrdP->GetMaximum()));
3060     h2FtrdP->Draw("samecolz");
3061     isGoodForSaving=kTRUE;
3062   }
3063   //--------------------------------------------
3064   // eta-phi distr. for negative TRD tracks
3065   pad = ((TVirtualPad*)l->At(4)); pad->cd();
3066   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3067   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3068   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3069   rangeEtaPhi->Draw();
3070   lat->DrawLatex(-0.9, 3.6, "TRD negative ref. tracks");
3071
3072   h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass));
3073   TH2F* h2FtrdN = 0x0;
3074   if(h3F && h3F->GetEntries()>10) {
3075     h2FtrdN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3076     h2FtrdN->SetStats(kFALSE);
3077     h2FtrdN->SetMaximum(h2FtpcN ? h2FtpcN->GetMaximum() : h2FtrdN->GetMaximum());
3078     h2FtrdN->Draw("samecolz");
3079     isGoodForSaving=kTRUE;
3080   }
3081   //----------------------------------------------
3082   // eta-phi efficiency for positive TRD tracks
3083   pad = ((TVirtualPad*)l->At(6)); pad->cd();
3084   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3085   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3086   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3087   rangeEtaPhi->Draw();
3088   lat->DrawLatex(-0.9, 3.6, "Efficiency positive tracks");
3089
3090   TH2F* h2Feff = (h2FtrdP ? (TH2F*)h2FtrdP->Clone("h2FeffPos") : 0x0);
3091   if(h2Feff) {
3092     h2Feff->Reset();
3093     h2Feff->SetStats(kFALSE);
3094     h2Feff->Divide(h2FtrdP, h2FtpcP);
3095     h2Feff->SetMaximum(1.0);
3096     if(h2Feff->GetEntries()>1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; }
3097   }
3098   //-------------------------------------------------
3099   // eta-phi efficiency for negative TRD tracks
3100   pad = ((TVirtualPad*)l->At(7)); pad->cd();
3101   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3102   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3103   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3104   rangeEtaPhi->Draw();
3105   lat->DrawLatex(-0.9, 3.6, "Efficiency negative tracks");
3106
3107   h2Feff = (h2FtrdN ? (TH2F*)h2FtrdN->Clone("h2FeffNeg") : 0x0);
3108   if(h2Feff) {
3109     h2Feff->Reset();
3110     h2Feff->SetStats(kFALSE);
3111     h2Feff->Divide(h2FtrdN, h2FtpcN);
3112     h2Feff->SetMaximum(1.0);
3113     if(h2Feff->GetEntries()>0.1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; }
3114   }
3115   //-----------------------------------------------------
3116   // <ntracklets> vs (phi,eta)
3117   pad = ((TVirtualPad*)l->At(2)); pad->cd();
3118   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3119   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3120   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3121   rangeEtaPhi->Draw();
3122   lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>");
3123
3124   TProfile2D* hProf2D;
3125   if((hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvNtrkl+centralityClass)))) {
3126     if(hProf2D->GetEntries()>10) {
3127       hProf2D->SetStats(kFALSE);
3128       hProf2D->SetMinimum(0.);
3129       hProf2D->SetMaximum(6.);
3130       if(hProf2D->GetEntries()>1) { hProf2D->Draw("samecolz"); isGoodForSaving = kTRUE; }
3131     }
3132   }
3133   //---------------------------------------------------------
3134   // TPC-TRD matching efficiency vs pt
3135   pad = ((TVirtualPad*)l->At(5)); pad->cd();
3136   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
3137   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3138   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3139   TH1F* hFeffP = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3140               dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass)), kTRUE);
3141   TH1F* hFeffN = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3142               dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass)), kTRUE);
3143   TH1F* hFeffP4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3144         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+centralityClass)), kTRUE);
3145   TH1F* hFeffN4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3146         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+centralityClass)), kTRUE);
3147   TH1F* hFeffP5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3148         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+centralityClass)), kTRUE);
3149   TH1F* hFeffN5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3150         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+centralityClass)), kTRUE);
3151   TH1F* hFeffP6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3152         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+centralityClass)), kTRUE);
3153   TH1F* hFeffN6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3154         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+centralityClass)), kTRUE);
3155
3156   TF1* funcConst = new TF1("funcConst", "[0]", 1.0, 3.0);
3157
3158   if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
3159   TH2F* rangeEffPt2=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
3160   rangeEffPt2->SetStats(kFALSE);
3161   SetStyle(rangeEffPt2->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3162   SetStyle(rangeEffPt2->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
3163   rangeEffPt2->Draw();
3164   lat->DrawLatex(0.5, 1.42, "TRD-TPC matching efficiency");
3165   //++++++++++++++++++
3166   TLine line;
3167   line.SetLineStyle(2);
3168   line.SetLineWidth(2);
3169   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.7, rangeEffPt2->GetXaxis()->GetXmax(), 0.7);
3170   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.9, rangeEffPt2->GetXaxis()->GetXmax(), 0.9);
3171   line.SetLineStyle(1);
3172   line.SetLineWidth(1);
3173   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 1.0, rangeEffPt2->GetXaxis()->GetXmax(), 1.0);
3174   TLegend* leg=new TLegend(0.2, 0.7, 0.6, 0.89);
3175   leg->SetNColumns(2);
3176   leg->SetFillColor(0);
3177   if(hFeffP){
3178     hFeffP->SetMarkerStyle(24);
3179     hFeffP->SetMarkerColor(2);
3180     hFeffP->SetLineColor(2);
3181     if(trendValues && hFeffP->GetEntries()>1) {
3182       hFeffP->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3183       trendValues[0] = funcConst->GetParameter(0);
3184       trendValues[1] = funcConst->GetParError(0);
3185     }
3186     if(hFeffP->Integral()>0.001) {
3187       hFeffP->Draw("same");
3188       leg->AddEntry(hFeffP, "positives (#geq 1 tracklet)", "p");
3189     }
3190   }
3191   if(hFeffN){
3192     hFeffN->SetMarkerStyle(24);
3193     hFeffN->SetMarkerColor(4);
3194     hFeffN->SetLineColor(4);
3195     if(trendValues && hFeffN->GetEntries()>1) {
3196       hFeffN->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3197       trendValues[2] = funcConst->GetParameter(0);
3198       trendValues[3] = funcConst->GetParError(0);
3199     }
3200     if(hFeffN->Integral()>0.001) {
3201       hFeffN->Draw("same");
3202       leg->AddEntry(hFeffN, "negatives (#geq 1 tracklet)", "p");
3203     }
3204   }
3205   if(hFeffP4){
3206     hFeffP4->SetMarkerStyle(25);
3207     hFeffP4->SetMarkerColor(2);
3208     hFeffP4->SetLineColor(2);
3209     if(hFeffP4->Integral()>0.001) {
3210       hFeffP4->Draw("same");
3211       leg->AddEntry(hFeffP4, "positives (4 tracklets)", "p");
3212     }
3213   }
3214   if(hFeffN4){
3215     hFeffN4->SetMarkerStyle(25);
3216     hFeffN4->SetMarkerColor(4);
3217     hFeffN4->SetLineColor(4);
3218     if(hFeffN4->Integral()>0.001) {
3219       hFeffN4->Draw("same");
3220       leg->AddEntry(hFeffN4, "negatives (4 tracklets)", "p");
3221     }
3222   }
3223   if(hFeffP5){
3224     hFeffP5->SetMarkerStyle(26);
3225     hFeffP5->SetMarkerColor(2);
3226     hFeffP5->SetLineColor(2);
3227     if(hFeffP5->Integral()>0.001) {
3228       hFeffP5->Draw("same");
3229       leg->AddEntry(hFeffP5, "positives (5 tracklets)", "p");
3230     }
3231   }
3232   if(hFeffN5){
3233     hFeffN5->SetMarkerStyle(26);
3234     hFeffN5->SetMarkerColor(4);
3235     hFeffN5->SetLineColor(4);
3236     if(hFeffN5->Integral()>0.001) {
3237       hFeffN5->Draw("same");
3238       leg->AddEntry(hFeffN5, "negatives (5 tracklets)", "p");
3239     }
3240   }
3241   if(hFeffP6){
3242     hFeffP6->SetMarkerStyle(27);
3243     hFeffP6->SetMarkerColor(2);
3244     hFeffP6->SetLineColor(2);
3245     if(hFeffP6->Integral()>0.001) {
3246       hFeffP6->Draw("same");
3247       leg->AddEntry(hFeffP6, "positives (6 tracklets)", "p");
3248     }
3249   }
3250   if(hFeffN6){
3251     hFeffN6->SetMarkerStyle(27);
3252     hFeffN6->SetMarkerColor(4);
3253     hFeffN6->SetLineColor(4);
3254     if(hFeffN6->Integral()>0.001) {
3255       hFeffN6->Draw("same");
3256       leg->AddEntry(hFeffN6, "negatives (6 tracklets)", "p");
3257     }
3258   }
3259   leg->Draw();
3260
3261   //--------------------------------------------------------------
3262   // Nclusters per TRD track
3263   pad = ((TVirtualPad*)l->At(8)); pad->cd();
3264   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
3265   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3266   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3267   pad->SetLogz();
3268   if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
3269   TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
3270   SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3271   SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
3272   rangeNclsP->SetStats(kFALSE);
3273   rangeNclsP->Draw();
3274   lat->DrawLatex(1.0, 205., "TRD Clusters / track");
3275
3276   TH2F* hNclsVsP=0x0;
3277   if((hNclsVsP = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+centralityClass)))) {
3278     hNclsVsP->SetStats(kFALSE);
3279     if(hNclsVsP->GetEntries()>10) {
3280       hNclsVsP->Draw("samecolz"); isGoodForSaving=kTRUE;
3281       if(trendValues) {
3282         TProfile* h2FProf = hNclsVsP->ProfileX("nclsVsPprof");
3283         h2FProf->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3284         trendValues[4] = funcConst->GetParameter(0);
3285         trendValues[5] = funcConst->GetParError(0);
3286       }
3287     }
3288   }
3289
3290   delete funcConst;
3291   return isGoodForSaving;
3292 }
3293
3294
3295 //_________________________________________________________________
3296 Bool_t AliTRDcheckESD::PlotPidSummary(Int_t centralityClass, Double_t* trendValues) {
3297
3298   Bool_t isGoodForSaving=kFALSE;
3299
3300   TLatex *lat=new TLatex();
3301   lat->SetTextSize(0.07);
3302   lat->SetTextColor(2);
3303   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
3304   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
3305   gPad->Divide(3,3,0.,0.);
3306   TList* l=gPad->GetListOfPrimitives();
3307   // eta-phi distr. for <Qtot> in layer 0
3308   TVirtualPad* pad;
3309   TProfile2D* hProf2D;
3310   if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
3311   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
3312   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
3313   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
3314   rangeEtaPhi->SetStats(kFALSE);
3315
3316   for(Int_t iLayer=0; iLayer<6; ++iLayer) {
3317     pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
3318     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3319     pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3320     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3321     rangeEtaPhi->Draw();
3322     lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer));
3323
3324     if(!(hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvQtot+6*centralityClass+iLayer)))) continue;
3325     if(hProf2D && hProf2D->GetEntries()>10) {
3326       hProf2D->SetStats(kFALSE);
3327       hProf2D->SetMinimum(0.);
3328       hProf2D->SetMaximum(4.);
3329       if(hProf2D->GetEntries()>10) { hProf2D->Draw("samecolz"); isGoodForSaving=kTRUE; }
3330     }
3331   }
3332
3333   // PH versus slice number
3334   pad = ((TVirtualPad*)l->At(2)); pad->cd();
3335   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3336   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3337   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3338   if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
3339   TH2F* rangePHslice = new TH2F("rangePHslice", "", 10, -0.5, 7.5, 10, 0.0, 2000.0);
3340   SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
3341   SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
3342   rangePHslice->SetStats(kFALSE);
3343   rangePHslice->Draw();
3344
3345   TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
3346
3347   TH2F* h2F;
3348   TH1D* hF;
3349   if((h2F = dynamic_cast<TH2F*>(fHistos->At(kPHSlice+centralityClass)))) {
3350     if(h2F && h2F->GetEntries()>10) {
3351       hF = Proj2D(h2F);
3352       h2F->SetStats(kFALSE);
3353       h2F->Draw("samecolz");
3354       isGoodForSaving=kTRUE;
3355       if(trendValues) {
3356         hF->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
3357         trendValues[6] = funcPol1->GetParameter(0);
3358         trendValues[7] = funcPol1->GetParError(0);
3359         trendValues[8] = funcPol1->GetParameter(1);
3360         trendValues[9] = funcPol1->GetParError(1);
3361       }
3362       hF->SetLineWidth(2);
3363       hF->Draw("same");
3364     }
3365   }
3366   delete funcPol1;
3367
3368   // Qtot vs P
3369   pad = ((TVirtualPad*)l->At(5)); pad->cd();
3370   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3371   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3372   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3373   pad->SetLogz();
3374   if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
3375   TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99);
3376   SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3377   SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
3378   rangeQtotP->SetStats(kFALSE);
3379   rangeQtotP->Draw();
3380
3381   if((h2F = dynamic_cast<TH2F*>(fHistos->At(kQtotP+centralityClass)))) {
3382     if(h2F && h2F->GetEntries()>10) {
3383       h2F->SetStats(kFALSE);
3384       h2F->Draw("samecolz");
3385       isGoodForSaving=kTRUE;
3386       hF = Proj2D(h2F);
3387       hF->SetLineWidth(2);
3388       hF->Draw("same");
3389       if(trendValues) {
3390         trendValues[10] = hF->GetBinContent(hF->FindBin(1.0));
3391         trendValues[11] = hF->GetBinError(hF->FindBin(1.0));
3392       }
3393     }
3394   }
3395   return isGoodForSaving;
3396 }
3397
3398 //__________________________________________________________________________________________________
3399 void AliTRDcheckESD::DrawTRDGrid() {
3400   //
3401   //   Draw a grid of lines showing the TRD supermodule and stack structure in (eta,phi) coordinates.
3402   //   The canvas on which to draw must already exist.
3403   //
3404   TLine line;
3405   line.SetLineColor(2);
3406   line.SetLineWidth(1);
3407   line.SetLineStyle(2);
3408   for(Int_t i=0; i<=9; ++i) {
3409     line.DrawLine(-1.0, 2.0*TMath::Pi()/18.0*i, +1.0, 2.0*TMath::Pi()/18.0*i);
3410     line.DrawLine(-1.0, -2.0*TMath::Pi()/18.0*i, +1.0, -2.0*TMath::Pi()/18.0*i);
3411   }
3412   line.DrawLine(-0.85, -3.2, -0.85, +3.2);
3413   line.DrawLine(-0.54, -3.2, -0.54, +3.2);
3414   line.DrawLine(-0.16, -3.2, -0.16, +3.2);
3415   line.DrawLine(+0.16, -3.2, +0.16, +3.2);
3416   line.DrawLine(+0.54, -3.2, +0.54, +3.2);
3417   line.DrawLine(+0.85, -3.2, +0.85, +3.2);
3418 }
3419
3420 //_________________________________________________________________
3421 void AliTRDcheckESD::SetStyle(TH1* hist,
3422                               Int_t lineStyle, Int_t lineColor, Int_t lineWidth,
3423                               Int_t markerStyle, Int_t markerColor, Int_t markerSize) {
3424   //
3425   // Set style settings for histograms
3426   //
3427   if(!hist) return;
3428   hist->SetLineStyle(lineStyle);
3429   hist->SetLineColor(lineColor);
3430   hist->SetLineWidth(lineWidth);
3431   hist->SetMarkerStyle(markerStyle);
3432   hist->SetMarkerColor(markerColor);
3433   hist->SetMarkerSize(markerSize);
3434 }
3435
3436 //____________________________________________________________________
3437 void AliTRDcheckESD::SetStyle(TAxis* axis, const Char_t* title, Float_t titleSize, Float_t titleOffset, Bool_t centerTitle,
3438                               Float_t labelSize) {
3439   //
3440   // Set style settings for axes
3441   //
3442   if(!axis) return;
3443   axis->SetTitle(title);
3444   axis->SetTitleSize(titleSize);
3445   axis->SetTitleOffset(titleOffset);
3446   axis->CenterTitle(centerTitle);
3447   axis->SetLabelSize(labelSize);
3448 }
3449
3450 //____________________________________________________________________
3451 void AliTRDcheckESD::FindIsolatedBCs(TH1D* bcHist, Bool_t isIsolated[3500]) {
3452   //
3453   // Find the isolated bunch crossings
3454   //
3455   Int_t isolationSize = 5;      // number of free bunches in both directions
3456   for(Int_t bcBin=1; bcBin<=bcHist->GetXaxis()->GetNbins(); ++bcBin) {
3457     Int_t bc = TMath::Nint(bcHist->GetBinCenter(bcBin));
3458     if(bc<-0.001 || bc>3499.01) {
3459       isIsolated[bc] = kFALSE;
3460       continue;
3461     }
3462     Double_t entries = bcHist->GetBinContent(bcBin);
3463     if(entries<0.001) {
3464       isIsolated[bc] = kFALSE;
3465       continue;     // no entries
3466     }
3467
3468     // check isolation
3469     isIsolated[bc] = kTRUE;
3470     for(Int_t ibc = TMath::Max(1,bcBin-isolationSize); ibc<=TMath::Min(3499, bcBin+isolationSize); ++ibc) {
3471       if(ibc==bcBin) continue;
3472       if(bcHist->GetBinContent(ibc)>0.01) {
3473         isIsolated[bc] = kFALSE;
3474         break;
3475       }
3476     }
3477   }   // end loop over BC bins
3478
3479   cout << "Isolated bunches: " << endl;
3480   for(Int_t ibc=0; ibc<3500; ++ibc)
3481     if(isIsolated[ibc]) cout << "BC #" << ibc << endl;
3482 }
3483
3484
3485 //__________________________________________________________________________________________________
3486 Int_t AliTRDcheckESD::GetTriggerIndex(const Char_t* name, Bool_t createNew/*=kTRUE*/) {
3487   //
3488   //  Return the index of trigger "name" in the trigger histogram.
3489   //  If the index for this trigger does not exist yet, then assign one if createNew is set to TRUE
3490   //
3491   //cout << "GetTriggerIndex for " << name << endl;
3492   TH1F* triggerHist = (TH1F*)fHistos->At(kTriggerDefs);
3493   TString nameStr=name;
3494   for(Int_t i=1; i<=triggerHist->GetXaxis()->GetNbins(); ++i) {
3495     if(!nameStr.CompareTo(triggerHist->GetXaxis()->GetBinLabel(i))) {
3496       //cout << "       index found: " << i << endl;
3497       return i;
3498     }
3499   }
3500   if(createNew) {
3501     triggerHist->GetXaxis()->SetBinLabel(fNAssignedTriggers+1, name);
3502     if(fMatchingPhiEtaCF->GetVar("trigger")>=0) {
3503       fMatchingPhiEtaCF->GetAxis(fMatchingPhiEtaCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3504       fMatchingPhiEtaCF->GetAxis(fMatchingPhiEtaCF->GetVar("trigger"), 1)->SetBinLabel(fNAssignedTriggers+1, name);
3505       fMatchingPhiEtaCF->GetAxis(fMatchingPhiEtaCF->GetVar("trigger"), 2)->SetBinLabel(fNAssignedTriggers+1, name);
3506     }
3507     if(fMatchingPtCF->GetVar("trigger")>=0) {
3508       fMatchingPtCF->GetAxis(fMatchingPtCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3509       fMatchingPtCF->GetAxis(fMatchingPtCF->GetVar("trigger"), 1)->SetBinLabel(fNAssignedTriggers+1, name);
3510       fMatchingPtCF->GetAxis(fMatchingPtCF->GetVar("trigger"), 2)->SetBinLabel(fNAssignedTriggers+1, name);
3511     }
3512     if(fBunchCrossingsCF->GetVar("trigger")>=0) {
3513       fBunchCrossingsCF->GetAxis(fBunchCrossingsCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3514       fBunchCrossingsCF->GetAxis(fBunchCrossingsCF->GetVar("trigger"), 1)->SetBinLabel(fNAssignedTriggers+1, name);
3515       fBunchCrossingsCF->GetAxis(fBunchCrossingsCF->GetVar("trigger"), 2)->SetBinLabel(fNAssignedTriggers+1, name);
3516     }
3517     if(fCentralityCF->GetVar("trigger")>=0)
3518       fCentralityCF->GetAxis(fCentralityCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3519     if(fQtotCF->GetVar("trigger")>=0)
3520       fQtotCF->GetAxis(fQtotCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3521     if(fPulseHeightCF->GetVar("trigger")>=0)
3522       fPulseHeightCF->GetAxis(fPulseHeightCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3523     if(fExpertCF) {
3524       if(fExpertCF->GetVar("trigger")>=0)
3525         for(Int_t istep=0; istep<fExpertCF->GetNStep(); ++istep)
3526           fExpertCF->GetAxis(fExpertCF->GetVar("trigger"), istep)->SetBinLabel(fNAssignedTriggers+1, name);
3527     }
3528
3529     ++fNAssignedTriggers;
3530     return fNAssignedTriggers+1;
3531   }
3532   else {
3533     return -1;
3534   }
3535 }
3536
3537 //__________________________________________________________________________________________________
3538 void AliTRDcheckESD::PrintTriggers() const {
3539   //
3540   //  Print the available triggers for this run
3541   //
3542   if(!fHistos) {
3543     cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
3544     return;
3545   }
3546   TH1F* hTriggers = (TH1F*)fHistos->At(kTriggerDefs);
3547   cout << "Triggers found in this run" << endl;
3548   cout << "==========================" << endl;
3549   cout << "Name   Index   Entries    " << endl;
3550   for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
3551     if(hTriggers->GetXaxis()->GetBinLabel(it)[0]!='\0') {
3552       cout << hTriggers->GetXaxis()->GetBinLabel(it) << "  " << hTriggers->GetXaxis()->GetBinCenter(it) << "  " << hTriggers->GetBinContent(it) << endl;
3553     }
3554   }
3555 }
3556
3557
3558 //__________________________________________________________________________________________________
3559 Int_t AliTRDcheckESD::GetTriggerCounter(const Char_t* triggerName) const {
3560   //
3561   // Get the number of events for a given trigger name
3562   //
3563   if(!fHistos) {
3564     cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
3565     return -1;
3566   }
3567   TH1F* hTriggers = (TH1F*)fHistos->At(kTriggerDefs);
3568   Int_t counter = -1;
3569   for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
3570     TString trgString = hTriggers->GetXaxis()->GetBinLabel(it);
3571     if(!trgString.CompareTo(triggerName))
3572       counter = (Int_t)hTriggers->GetBinContent(it);
3573   }
3574   if(counter<0) {cout << "AliTRDcheckESD::GetTriggerCounter()  Trigger not found !!";}
3575   return counter;
3576 }
3577
3578
3579 //__________________________________________________________________________________________________________
3580 Int_t AliTRDcheckESD::GetNAssignedTriggers() {
3581   //
3582   // Return the number of assigned triggers
3583   //
3584   return fNAssignedTriggers;
3585 }