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