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   triggerName = triggerName;
2079   useIsolatedBC = useIsolatedBC;
2080   cutTOFbc = cutTOFbc;
2081
2082   trendValues = trendValues;
2083
2084   TLatex* lat=new TLatex();
2085   lat->SetTextSize(0.06);
2086   lat->SetTextColor(2);
2087
2088   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2089   gPad->Divide(3,3,0.,0.);
2090   TList* l=gPad->GetListOfPrimitives();
2091   TVirtualPad* pad=0x0;
2092
2093   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, 0.0, 0.0);
2094
2095   if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
2096   TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.3);
2097   rangeEffPt->SetStats(kFALSE);
2098   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2099   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2100
2101   Int_t padsForEffs[5] = {0,3,6,1,4};
2102   for(Int_t iCent=1; iCent<6; ++iCent) {
2103     pad = ((TVirtualPad*)l->At(padsForEffs[iCent-1])); pad->cd();
2104     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2105     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2106     rangeEffPt->Draw();
2107     TLine line;
2108     line.SetLineStyle(2);
2109     line.SetLineWidth(2);
2110     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2111     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2112
2113     cf = fMatchingPtCF;
2114     cf->SetRangeUser(cf->GetVar("multiplicity"), Double_t(iCent), Double_t(iCent), kTRUE);
2115
2116     cf->SetRangeUser(cf->GetVar("charge"), +1.0, +1.0);
2117     TH1F* hEffPosAll = EfficiencyFromPhiPt(cf, 1, 0);
2118     cf->SetRangeUser(cf->GetVar("tracklets"), 4.0, 4.0);
2119     TH1F* hEffPosTrk4 = EfficiencyFromPhiPt(cf, 1, 0);
2120     cf->SetRangeUser(cf->GetVar("tracklets"), 5.0, 5.0);
2121     TH1F* hEffPosTrk5 = EfficiencyFromPhiPt(cf, 1, 0);
2122     cf->SetRangeUser(cf->GetVar("tracklets"), 6.0, 6.0);
2123     TH1F* hEffPosTrk6 = EfficiencyFromPhiPt(cf, 1, 0);
2124
2125     cf->SetRangeUser(cf->GetVar("charge"), -1.0, -1.0);
2126     cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2127     TH1F* hEffNegAll = EfficiencyFromPhiPt(cf, 1, 0);
2128     cf->SetRangeUser(cf->GetVar("tracklets"), 4.0, 4.0);
2129     TH1F* hEffNegTrk4 = EfficiencyFromPhiPt(cf, 1, 0);
2130     cf->SetRangeUser(cf->GetVar("tracklets"), 5.0, 5.0);
2131     TH1F* hEffNegTrk5 = EfficiencyFromPhiPt(cf, 1, 0);
2132     cf->SetRangeUser(cf->GetVar("tracklets"), 6.0, 6.0);
2133     TH1F* hEffNegTrk6 = EfficiencyFromPhiPt(cf, 1, 0);
2134     cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2135     cf->SetRangeUser(cf->GetVar("charge"), -1.0, +1.0);
2136
2137     SetStyle(hEffPosAll,  1, kRed, 1, 24, kRed, 1);
2138     SetStyle(hEffPosTrk4, 1, kRed, 1, 25, kRed, 1);
2139     SetStyle(hEffPosTrk5, 1, kRed, 1, 26, kRed, 1);
2140     SetStyle(hEffPosTrk6, 1, kRed, 1, 27, kRed, 1);
2141     SetStyle(hEffNegAll,  1, kBlue, 1, 24, kBlue, 1);
2142     SetStyle(hEffNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2143     SetStyle(hEffNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2144     SetStyle(hEffNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2145     hEffPosAll->Draw("same");
2146     hEffNegAll->Draw("same");
2147     hEffPosTrk4->Draw("same");
2148     hEffNegTrk4->Draw("same");
2149     hEffPosTrk5->Draw("same");
2150     hEffNegTrk5->Draw("same");
2151     hEffPosTrk6->Draw("same");
2152     hEffNegTrk6->Draw("same");
2153
2154     TLegend* leg=new TLegend(0.18, 0.7, 0.77, 0.89);
2155     if(iCent==1) {
2156       leg->SetFillColor(0);
2157       leg->SetNColumns(2);
2158       leg->SetMargin(0.1);
2159       leg->SetBorderSize(0);
2160       leg->AddEntry(hEffPosAll,  "pos. (#geq 1 tracklet)", "p");
2161       leg->AddEntry(hEffNegAll,  "neg. (#geq 1 tracklet)", "p");
2162       leg->AddEntry(hEffPosTrk4, "pos. (4 tracklets)", "p");
2163       leg->AddEntry(hEffNegTrk4, "neg. (4 tracklets)", "p");
2164       leg->AddEntry(hEffPosTrk5, "pos. (5 tracklets)", "p");
2165       leg->AddEntry(hEffNegTrk5, "neg. (5 tracklets)", "p");
2166       leg->AddEntry(hEffPosTrk6, "pos. (6 tracklets)", "p");
2167       leg->AddEntry(hEffNegTrk6, "neg. (6 tracklets)", "p");
2168       leg->Draw();
2169     }
2170     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)));
2171   }   // end for loop over multiplicity classes
2172
2173   // Reset the modified user ranges of the CF container
2174   cf->SetRangeUser(cf->GetVar("multiplicity"), 0., 3500.);
2175
2176   // Cluster distributions in all multiplicity classes
2177   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2178   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2179   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2180   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2181   if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
2182   TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
2183   SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
2184   SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2185   rangeNcls->SetStats(kFALSE);
2186   rangeNcls->Draw();
2187
2188   TH1D* hNcls[6]={0x0};
2189   TLegend* legCls=new TLegend(0.7, 0.75, 0.97, 0.97);
2190   legCls->SetBorderSize(0);
2191   legCls->SetFillColor(0);
2192   legCls->SetMargin(0.15);
2193   cf = fCentralityCF;
2194   for(Int_t iCent=0; iCent<6; ++iCent) {
2195     if(iCent>0)
2196       cf->SetRangeUser(cf->GetVar("multiplicity"), Double_t(iCent), Double_t(iCent), kTRUE);
2197     hNcls[iCent] = (TH1D*)cf->Project(0, cf->GetVar("clusters"));
2198     if(!hNcls[iCent]) continue;
2199
2200     hNcls[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2201     Double_t maximum = hNcls[iCent]->GetMaximum();
2202     if(maximum>1.0)
2203       hNcls[iCent]->Scale(1.0/maximum);
2204     hNcls[iCent]->SetStats(kFALSE);
2205     hNcls[iCent]->SetTitle("");
2206     hNcls[iCent]->SetLineWidth(2);
2207
2208     if(hNcls[iCent]->Integral()>0.01) {
2209       hNcls[iCent]->Draw("same");
2210       legCls->AddEntry(hNcls[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinLowEdge(iCent),
2211                                                                            cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinUpEdge(iCent))), "l");
2212     }
2213   }
2214   legCls->Draw();
2215   cf->SetRangeUser(cf->GetVar("multiplicity"), 0.0, 6.0, kTRUE);
2216
2217   // Qtot vs P
2218   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2219   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2220   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2221   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2222   if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
2223   TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
2224   SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2225   SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2226   rangeQtot->SetStats(kFALSE);
2227   rangeQtot->Draw();
2228
2229   TH1D* hQtot[6]={0x0};
2230   TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.97);
2231   leg2->SetFillColor(0);
2232   leg2->SetBorderSize(0);
2233
2234   for(Int_t iCent=0; iCent<6; ++iCent) {
2235     if(iCent>0)
2236       cf->SetRangeUser(cf->GetVar("multiplicity"), Double_t(iCent), Double_t(iCent), kTRUE);
2237
2238     hQtot[iCent] = (TH1D*)cf->Project(0, cf->GetVar("Qtot0"));
2239     if(!hQtot[iCent]) continue;
2240     hQtot[iCent]->SetBinContent(1, 0);
2241
2242     Double_t maximum = hQtot[iCent]->GetMaximum();
2243     if(maximum>1.0)
2244       hQtot[iCent]->Scale(1.0/maximum);
2245     hQtot[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2246     hQtot[iCent]->SetStats(kFALSE);
2247     hQtot[iCent]->SetTitle("");
2248     hQtot[iCent]->SetLineWidth(2);
2249     if(hQtot[iCent]->Integral()>0.01) {
2250       hQtot[iCent]->Draw(iCent==0 ? "" : "same");
2251       leg2->AddEntry(hQtot[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinLowEdge(iCent),
2252                                                                            cf->GetAxis(cf->GetVar("multiplicity"),0)->GetBinUpEdge(iCent))), "l");
2253     }
2254   }
2255   leg2->Draw();
2256   cf->SetRangeUser(cf->GetVar("multiplicity"), 0.0, 5.0, kTRUE);
2257   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2258 }
2259
2260
2261 //_________________________________________________________________
2262 void AliTRDcheckESD::PlotTrackingSummaryFromCF(Double_t* trendValues, const Char_t* triggerName, Bool_t useIsolatedBC, Bool_t cutTOFbc) {
2263   //
2264   //  Plot tracking summary
2265   //
2266   if(!fMatchingPhiEtaCF || !fMatchingPtCF || !fCentralityCF || !fBunchCrossingsCF) return;
2267   AliCFContainer* cf = 0x0;
2268   triggerName = triggerName;
2269   useIsolatedBC = useIsolatedBC;
2270   cutTOFbc = cutTOFbc;
2271
2272   TLatex *lat=new TLatex();
2273   lat->SetTextSize(0.06);
2274   lat->SetTextColor(2);
2275
2276   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2277   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2278   gPad->Divide(3,3,0.,0.);
2279   TList* l=gPad->GetListOfPrimitives();
2280
2281   // eta-phi distr. for positive TPC tracks
2282   TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
2283   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2284   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2285   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2286
2287   //cf->SetRangeUser(stepDCAxy, -0.999, +0.999);
2288   //cf->SetRangeUser(stepDCAz, -3.0, +3.0);
2289   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, 0.0, 0.0);
2290
2291   // find all the isolated bunch crossings with entries
2292   TH2D* hTPCrefPos = 0x0; TH2D* hTRDrefPos = 0x0; TH2D* hTOFrefPos = 0x0;
2293   TH2D* hTPCrefNeg = 0x0; TH2D* hTRDrefNeg = 0x0; TH2D* hTOFrefNeg = 0x0;
2294   cf = fMatchingPhiEtaCF;
2295   cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2296   cf->SetRangeUser(cf->GetVar("charge"), +1.0, +1.0);      // positive charges
2297   hTPCrefPos = (TH2D*)cf->Project(0, cf->GetVar("eta"), cf->GetVar("phi"));
2298   hTRDrefPos = (TH2D*)cf->Project(1, cf->GetVar("eta"), cf->GetVar("phi"));
2299   hTOFrefPos = (TH2D*)cf->Project(2, cf->GetVar("eta"), cf->GetVar("phi"));
2300   cf->SetRangeUser(cf->GetVar("charge"), -1.0, -1.0);      // negative charges
2301   hTPCrefNeg = (TH2D*)cf->Project(0, cf->GetVar("eta"), cf->GetVar("phi"));
2302   hTRDrefNeg = (TH2D*)cf->Project(1, cf->GetVar("eta"), cf->GetVar("phi"));
2303   hTOFrefNeg = (TH2D*)cf->Project(2, cf->GetVar("eta"), cf->GetVar("phi"));
2304   cf->SetRangeUser(cf->GetVar("charge"), -1.0, +1.0);      // reset charge cut
2305
2306   if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
2307   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
2308   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
2309   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
2310   rangeEtaPhi->SetStats(kFALSE);
2311
2312   //----------------------------------------------
2313   // eta-phi efficiency for positive TRD tracks
2314   pad = ((TVirtualPad*)l->At(0)); pad->cd();
2315   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2316   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2317   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2318   rangeEtaPhi->Draw();
2319
2320   TH2D* hTRDeffPos = (hTRDrefPos ? (TH2D*)hTRDrefPos->Clone("hTRDeffPos") : 0x0);
2321   if(hTRDeffPos) {
2322     hTRDeffPos->Reset();
2323     hTRDeffPos->SetStats(kFALSE);
2324     hTRDeffPos->Divide(hTRDrefPos, hTPCrefPos);
2325     hTRDeffPos->SetMaximum(1.0);
2326     hTRDeffPos->Draw("samecolz");
2327     lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for positive tracks");
2328     DrawTRDGrid();
2329   }
2330
2331   //----------------------------------------------
2332   // eta-phi efficiency for negative TRD tracks
2333   pad = ((TVirtualPad*)l->At(3)); pad->cd();
2334   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2335   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2336   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2337   rangeEtaPhi->Draw();
2338
2339   TH2D* hTRDeffNeg = (hTRDrefNeg ? (TH2D*)hTRDrefNeg->Clone("hTRDeffNeg") : 0x0);
2340   if(hTRDeffNeg) {
2341     hTRDeffNeg->Reset();
2342     hTRDeffNeg->SetStats(kFALSE);
2343     hTRDeffNeg->Divide(hTRDrefNeg, hTPCrefNeg);
2344     hTRDeffNeg->SetMaximum(1.0);
2345     hTRDeffNeg->Draw("samecolz");
2346     lat->DrawLatex(-0.9, 3.6, "TPC-TRD matching for negative tracks");
2347     DrawTRDGrid();
2348   }
2349
2350   //----------------------------------------------
2351   // eta-phi TRD-TOF matching efficiency for positive tracks
2352   pad = ((TVirtualPad*)l->At(1)); pad->cd();
2353   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2354   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2355   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2356   rangeEtaPhi->Draw();
2357
2358   TH2D* hTOFeffPos = (hTOFrefPos ? (TH2D*)hTOFrefPos->Clone("hTOFeffPos") : 0x0);
2359   if(hTOFeffPos) {
2360     hTOFeffPos->Reset();
2361     hTOFeffPos->SetStats(kFALSE);
2362     hTOFeffPos->Divide(hTOFrefPos, hTRDrefPos);
2363     hTOFeffPos->SetMaximum(1.0);
2364     hTOFeffPos->Draw("samecolz");
2365     lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for positive tracks");
2366     DrawTRDGrid();
2367   }
2368
2369   //----------------------------------------------
2370   // eta-phi TRD-TOF matching efficiency for negative tracks
2371   pad = ((TVirtualPad*)l->At(4)); pad->cd();
2372   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2373   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2374   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2375   rangeEtaPhi->Draw();
2376
2377   TH2D* hTOFeffNeg = (hTOFrefNeg ? (TH2D*)hTOFrefNeg->Clone("hTOFeffNeg") : 0x0);
2378   if(hTOFeffNeg) {
2379     hTOFeffNeg->Reset();
2380     hTOFeffNeg->SetStats(kFALSE);
2381     hTOFeffNeg->Divide(hTOFrefNeg, hTRDrefNeg);
2382     hTOFeffNeg->SetMaximum(1.0);
2383     hTOFeffNeg->Draw("samecolz");
2384     lat->DrawLatex(-0.9, 3.6, "TRD-TOF matching for negative tracks");
2385     DrawTRDGrid();
2386   }
2387
2388   if(hTRDrefPos) delete hTRDrefPos; if(hTPCrefPos) delete hTPCrefPos; if(hTOFrefPos) delete hTOFrefPos;
2389   if(hTRDrefNeg) delete hTRDrefNeg; if(hTPCrefNeg) delete hTPCrefNeg; if(hTOFrefNeg) delete hTOFrefNeg;
2390
2391   // switch to the Pt cf container
2392   cf = fMatchingPtCF;
2393   cf->SetRangeUser(cf->GetVar("charge"), +1.0, +1.0);
2394   TH1F* hTRDEffPtPosAll = EfficiencyFromPhiPt(cf, 1, 0);
2395   TH1F* hTOFEffPtPosAll = EfficiencyFromPhiPt(cf, 2, 1);
2396   cf->SetRangeUser(cf->GetVar("tracklets"), 4.0, 4.0);
2397   TH1F* hTRDEffPtPosTrk4 = EfficiencyFromPhiPt(cf, 1, 0);
2398   TH1F* hTOFEffPtPosTrk4 = EfficiencyFromPhiPt(cf, 2, 1);
2399   cf->SetRangeUser(cf->GetVar("tracklets"), 5.0, 5.0);
2400   TH1F* hTRDEffPtPosTrk5 = EfficiencyFromPhiPt(cf, 1, 0);
2401   TH1F* hTOFEffPtPosTrk5 = EfficiencyFromPhiPt(cf, 2, 1);
2402   cf->SetRangeUser(cf->GetVar("tracklets"), 6.0, 6.0);
2403   TH1F* hTRDEffPtPosTrk6 = EfficiencyFromPhiPt(cf, 1, 0);
2404   TH1F* hTOFEffPtPosTrk6 = EfficiencyFromPhiPt(cf, 2, 1);
2405
2406   cf->SetRangeUser(cf->GetVar("charge"), -1.0, -1.0);
2407   cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2408   TH1F* hTRDEffPtNegAll = EfficiencyFromPhiPt(cf, 1, 0);
2409   TH1F* hTOFEffPtNegAll = EfficiencyFromPhiPt(cf, 2, 1);
2410   cf->SetRangeUser(cf->GetVar("tracklets"), 4.0, 4.0);
2411   TH1F* hTRDEffPtNegTrk4 = EfficiencyFromPhiPt(cf, 1, 0);
2412   TH1F* hTOFEffPtNegTrk4 = EfficiencyFromPhiPt(cf, 2, 1);
2413   cf->SetRangeUser(cf->GetVar("tracklets"), 5.0, 5.0);
2414   TH1F* hTRDEffPtNegTrk5 = EfficiencyFromPhiPt(cf, 1, 0);
2415   TH1F* hTOFEffPtNegTrk5 = EfficiencyFromPhiPt(cf, 2, 1);
2416   cf->SetRangeUser(cf->GetVar("tracklets"), 6.0, 6.0);
2417   TH1F* hTRDEffPtNegTrk6 = EfficiencyFromPhiPt(cf, 1, 0);
2418   TH1F* hTOFEffPtNegTrk6 = EfficiencyFromPhiPt(cf, 2, 1);
2419   cf->SetRangeUser(cf->GetVar("tracklets"), 0.0, 6.0);
2420   cf->SetRangeUser(cf->GetVar("charge"), -1.0, +1.0);
2421
2422   TF1* funcConst = new TF1("constFunc", "[0]", 1.0, 3.0);
2423   if(trendValues) {
2424     if(hTRDEffPtPosAll && hTRDEffPtPosAll->Integral()>0.1) {
2425       hTRDEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2426       trendValues[0] = funcConst->GetParameter(0);
2427       trendValues[1] = funcConst->GetParError(0);
2428     }
2429   }
2430   if(trendValues) {
2431     if(hTRDEffPtNegAll && hTRDEffPtNegAll->Integral()>0.1) {
2432       hTRDEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2433       trendValues[2] = funcConst->GetParameter(0);
2434       trendValues[3] = funcConst->GetParError(0);
2435     }
2436   }
2437   if(trendValues) {
2438     if(hTOFEffPtPosAll && hTOFEffPtPosAll->Integral()>0.1) {
2439       hTOFEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2440       trendValues[4] = funcConst->GetParameter(0);
2441       trendValues[5] = funcConst->GetParError(0);
2442     }
2443   }
2444   if(trendValues) {
2445     if(hTOFEffPtNegAll && hTOFEffPtNegAll->Integral()>0.1) {
2446       hTOFEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
2447       trendValues[6] = funcConst->GetParameter(0);
2448       trendValues[7] = funcConst->GetParError(0);
2449     }
2450   }
2451
2452   //---------------------------------------------------------
2453   // TPC-TRD matching efficiency vs pt
2454   pad = ((TVirtualPad*)l->At(6)); pad->cd();
2455   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2456   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2457   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2458
2459   if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
2460   TH2F* rangeEffPt=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
2461   rangeEffPt->SetStats(kFALSE);
2462   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2463   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2464   rangeEffPt->Draw();
2465   lat->DrawLatex(0.2, 1.42, "TPC-TRD matching efficiency");
2466   //++++++++++++++++++
2467   TLine line;
2468   line.SetLineStyle(2);
2469   line.SetLineWidth(2);
2470   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2471   line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2472   TLegend* leg=new TLegend(0.2, 0.7, 0.7, 0.89);
2473   leg->SetNColumns(2);
2474   leg->SetMargin(0.15);
2475   leg->SetBorderSize(0);
2476   leg->SetFillColor(0);
2477
2478   SetStyle(hTRDEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
2479   SetStyle(hTRDEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
2480   SetStyle(hTRDEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
2481   SetStyle(hTRDEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2482   SetStyle(hTRDEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
2483   SetStyle(hTRDEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2484   SetStyle(hTRDEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
2485   SetStyle(hTRDEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2486   hTRDEffPtPosAll->Draw("same"); leg->AddEntry(hTRDEffPtPosAll, "pos. (#geq 1 tracklet)", "p");
2487   hTRDEffPtNegAll->Draw("same"); leg->AddEntry(hTRDEffPtNegAll, "neg. (#geq 1 tracklet)", "p");
2488   hTRDEffPtPosTrk4->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4, "pos. (4 tracklets)", "p");
2489   hTRDEffPtNegTrk4->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4, "neg. (4 tracklets)", "p");
2490   hTRDEffPtPosTrk5->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5, "pos. (5 tracklets)", "p");
2491   hTRDEffPtNegTrk5->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5, "neg. (5 tracklets)", "p");
2492   hTRDEffPtPosTrk6->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6, "pos. (6 tracklets)", "p");
2493   hTRDEffPtNegTrk6->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6, "neg. (6 tracklets)", "p");
2494
2495   leg->Draw();
2496
2497   //---------------------------------------------------------
2498   // TRD-TOF matching efficiency vs pt
2499   pad = ((TVirtualPad*)l->At(7)); pad->cd();
2500   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2501   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2502   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2503
2504   rangeEffPt->Draw();
2505   lat->DrawLatex(0.2, 1.42, "TRD-TOF matching efficiency");
2506
2507   SetStyle(hTOFEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
2508   SetStyle(hTOFEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
2509   SetStyle(hTOFEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
2510   SetStyle(hTOFEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
2511   SetStyle(hTOFEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
2512   SetStyle(hTOFEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
2513   SetStyle(hTOFEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
2514   SetStyle(hTOFEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
2515   hTOFEffPtPosAll->Draw("same");
2516   hTOFEffPtPosTrk4->Draw("same");
2517   hTOFEffPtPosTrk5->Draw("same");
2518   hTOFEffPtPosTrk6->Draw("same");
2519   hTOFEffPtNegAll->Draw("same");
2520   hTOFEffPtNegTrk4->Draw("same");
2521   hTOFEffPtNegTrk5->Draw("same");
2522   hTOFEffPtNegTrk6->Draw("same");
2523
2524   //-----------------------------------------------------
2525   // <ntracklets> vs (phi,eta)
2526   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2527   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2528   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2529   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2530
2531   rangeEtaPhi->Draw();
2532   lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>");
2533
2534   cf = fMatchingPhiEtaCF;
2535   TH3D* hNtracklets = (TH3D*)cf->Project(1, cf->GetVar("phi"), cf->GetVar("eta"), cf->GetVar("tracklets"));
2536
2537   TProfile2D* hNtrackletsProf = hNtracklets->Project3DProfile();
2538   delete hNtracklets;
2539   if(hNtrackletsProf) {
2540     hNtrackletsProf->SetStats(kFALSE);
2541     hNtrackletsProf->SetMinimum(0.);
2542     hNtrackletsProf->SetMaximum(6.);
2543     hNtrackletsProf->Draw("samecolz");
2544     DrawTRDGrid();
2545   }
2546
2547   // calculate the trend value for tracklets/track
2548   cf = fMatchingPtCF;
2549   TH2D* hNtrackletsVsP = (TH2D*)cf->Project(1, cf->GetVar("pt"), cf->GetVar("tracklets"));
2550   if(trendValues &&  hNtrackletsVsP && hNtrackletsVsP->GetEntries()>0.1) {
2551     TProfile* hNtrackletsVsPprof = hNtrackletsVsP->ProfileX("hNtrackletsVsPprof");
2552     hNtrackletsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2553     trendValues[8] = funcConst->GetParameter(0);
2554     trendValues[9] = funcConst->GetParError(0);
2555     delete hNtrackletsVsP;
2556   }
2557
2558   //--------------------------------------------------------------
2559   // Nclusters per TRD track vs momentum
2560   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2561   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
2562   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2563   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2564   pad->SetLogz();
2565
2566   if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
2567   TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
2568   SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2569   SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
2570   rangeNclsP->SetStats(kFALSE);
2571   rangeNclsP->Draw();
2572   lat->DrawLatex(1.0, 205., "TRD Clusters / track");
2573
2574   cf = fCentralityCF;
2575   TH2D* hNclsVsP = (TH2D*)cf->Project(0, cf->GetVar("P"), cf->GetVar("clusters"));
2576   if(hNclsVsP) {
2577     hNclsVsP->SetStats(kFALSE);
2578     hNclsVsP->Draw("samecolz");
2579   }
2580
2581   if(trendValues && hNclsVsP && hNclsVsP->GetEntries()>10) {
2582     TProfile* hNclsVsPprof = hNclsVsP->ProfileX("hNclsVsPprof");
2583     hNclsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
2584     trendValues[10] = funcConst->GetParameter(0);
2585     trendValues[11] = funcConst->GetParError(0);
2586   }
2587
2588   //--------------------------------------------------------------
2589   // TRD-TPC and TOF-TRD matching efficiency vs bunch crossing
2590   pad = ((TVirtualPad*)l->At(8)); pad->cd();
2591   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2592   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2593   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2594
2595   cf = fBunchCrossingsCF;
2596   TH1F* hTRDEffBC = EfficiencyFromPhiPt(cf, 1, 0, "BC");
2597   TH1F* hTOFEffBC = EfficiencyFromPhiPt(cf, 2, 1, "BC");
2598
2599   if(gROOT->FindObject("rangeBC")) delete gROOT->FindObject("rangeBC");
2600   TH2F* rangeBC = new TH2F("rangeBC", "", 10, -0.5, 3499.5, 10, 0.0, 1.4);
2601   rangeBC->SetStats(kFALSE);
2602   SetStyle(rangeBC->GetXaxis(), "Bunch crossing", 0.07, 0.8, kTRUE, 0.05);
2603   SetStyle(rangeBC->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2604   rangeBC->Draw();
2605
2606   TLegend* legBC=new TLegend(0.8, 0.7, 0.95, 0.89);
2607   legBC->SetBorderSize(0);
2608   legBC->SetMargin(0.15);
2609   legBC->SetFillColor(0);
2610   if(hTRDEffBC) {
2611     hTRDEffBC->SetStats(kFALSE);
2612     SetStyle(hTRDEffBC, 1, kRed, 2, 24, kRed, 1); legBC->AddEntry(hTRDEffBC, "TPC-TRD", "p");
2613     SetStyle(hTOFEffBC, 1, kBlue, 2, 24, kBlue, 1); legBC->AddEntry(hTOFEffBC, "TRD-TOF", "p");
2614     hTRDEffBC->Draw("same");
2615     hTOFEffBC->Draw("same");
2616     legBC->Draw();
2617     lat->DrawLatex(200., 1.42, "Matching efficiency at 1<p_{T}<3 GeV/c");
2618   }
2619
2620   // reset the user range on the event multiplicity
2621   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2622
2623   delete funcConst;
2624 }
2625
2626
2627 //_________________________________________________________________
2628 void AliTRDcheckESD::PlotPidSummaryFromCF(Double_t* trendValues, const Char_t* triggerName, Bool_t useIsolatedBC, Bool_t cutTOFbc) {
2629   //
2630   // Centrality summary
2631   //
2632   if(!fQtotCF || !fPulseHeightCF || !fCentralityCF) return;
2633
2634   AliCFContainer* cf = 0x0;
2635   triggerName = triggerName;
2636   useIsolatedBC = useIsolatedBC;
2637   cutTOFbc = cutTOFbc;
2638
2639   TLatex *lat=new TLatex();
2640   lat->SetTextSize(0.07);
2641   lat->SetTextColor(2);
2642   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2643   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2644   gPad->Divide(3,3,0.,0.);
2645   TList* l=gPad->GetListOfPrimitives();
2646
2647   //cf->SetRangeUser(stepDCAxy, -0.999, +0.999);
2648   //cf->SetRangeUser(stepDCAz, -3.0, +3.0);
2649   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, 0.0, 0.0);
2650
2651   if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
2652   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
2653   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
2654   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
2655   rangeEtaPhi->SetStats(kFALSE);
2656
2657   // eta-phi distr. for <Qtot> in layer 0
2658   TVirtualPad* pad;
2659   TProfile2D* hProf2D;
2660   cf = fQtotCF;
2661   for(Int_t iLayer=0; iLayer<6; ++iLayer) {
2662     pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
2663     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2664     pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2665     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2666     rangeEtaPhi->Draw();
2667
2668     cf->SetRangeUser(cf->GetVar("layer"), Double_t(iLayer), Double_t(iLayer));
2669     TH3D* hQtotEtaPhi = (TH3D*)cf->Project(0, cf->GetVar("phi"), cf->GetVar("eta"), cf->GetVar("Qtot0"));
2670     hProf2D = (hQtotEtaPhi ? hQtotEtaPhi->Project3DProfile() : 0x0);
2671     if(hQtotEtaPhi) delete hQtotEtaPhi;
2672
2673     if(hProf2D) {
2674       hProf2D->SetStats(kFALSE);
2675       hProf2D->SetMinimum(0.);
2676       hProf2D->SetMaximum(4.);
2677       hProf2D->Draw("samecolz");
2678     }
2679     lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer));
2680     DrawTRDGrid();
2681   }
2682   cf->SetRangeUser(cf->GetVar("layer"), 0.0, 5.0);
2683
2684   // PH versus slice number
2685   pad = ((TVirtualPad*)l->At(2)); pad->cd();
2686   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2687   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
2688   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2689
2690   if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
2691   TH2F* rangePHslice=new TH2F("rangePHslice", "", 8, -0.5, 7.5, 10, 0.0, 6.);
2692   rangePHslice->SetStats(kFALSE);
2693   SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
2694   SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
2695   rangePHslice->Draw();
2696
2697   TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
2698
2699   cf = fPulseHeightCF;
2700   TH2D* hPH = (TH2D*)cf->Project(0, cf->GetVar("slice"), cf->GetVar("PH0"));
2701   TH1D* hSliceErr = new TH1D(Form("hSliceErr%f", gRandom->Rndm()), "", hPH->GetXaxis()->GetNbins(), hPH->GetXaxis()->GetXbins()->GetArray());
2702   TH1D* hLandauFit = Proj2D(hPH, hSliceErr);
2703   hPH->SetStats(kFALSE);
2704   hPH->Draw("samecolz");
2705   if(trendValues) {
2706     hSliceErr->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
2707     trendValues[12] = funcPol1->GetParameter(0);  // PH plateau
2708     trendValues[13] = funcPol1->GetParError(0);   // PH plateau
2709     trendValues[14] = funcPol1->GetParameter(1);  // PH slope
2710     trendValues[15] = funcPol1->GetParError(1);   // PH slope
2711   }
2712   hLandauFit->SetLineWidth(2);
2713   hLandauFit->SetLineStyle(2);
2714   hLandauFit->Draw("same");
2715
2716   delete funcPol1; delete hSliceErr;
2717
2718   // Qtot vs P
2719   pad = ((TVirtualPad*)l->At(5)); pad->cd();
2720   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2721   pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
2722   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2723   pad->SetLogz();
2724
2725   if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
2726   TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99);
2727   SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2728   SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
2729   rangeQtotP->SetStats(kFALSE);
2730   rangeQtotP->Draw();
2731
2732   cf = fCentralityCF;
2733   TH2D* hQtotP = (TH2D*)cf->Project(0, cf->GetVar("P"), cf->GetVar("Qtot0"));
2734
2735   if(hQtotP)
2736     for(Int_t i=1; i<=hQtotP->GetXaxis()->GetNbins(); ++i)
2737       hQtotP->SetBinContent(i, 1, 0.0);
2738   TH1D* hQtotProj = (hQtotP ? Proj2D(hQtotP) : 0x0);
2739   if(hQtotProj) SetStyle(hQtotProj, 2, kBlue, 2, 1, kBlue, 1);
2740   if(trendValues && hQtotProj && hQtotProj->GetEntries()>2) {
2741     trendValues[16] = hQtotProj->GetBinContent(hQtotProj->FindBin(1.0));   // Landau MPV at 1GeV/c
2742     trendValues[17] = hQtotProj->GetBinError(hQtotProj->FindBin(1.0));     // Landau width at 1 GeV/c
2743   }
2744   if(hQtotP) {
2745     hQtotP->SetStats(kFALSE);
2746     hQtotP->Draw("samecolz");
2747     hQtotProj->Draw("same");
2748   }
2749   //if(cutTOFbc) cf->SetRangeUser(stepTOFBC, -1000.0, +1000.0);  // reset the cut on TOFbc
2750 }
2751
2752
2753 //_________________________________________________________________
2754 Bool_t AliTRDcheckESD::PlotCentSummary(Double_t* trendValues) {
2755
2756   Bool_t isGoodForSaving=kFALSE;
2757
2758   trendValues = trendValues;
2759
2760   TLatex* lat=new TLatex();
2761   lat->SetTextSize(0.06);
2762   lat->SetTextColor(2);
2763
2764   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2765   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2766   gPad->Divide(3,3,0.,0.);
2767   TList* l=gPad->GetListOfPrimitives();
2768
2769   TPad* pad=0x0;
2770
2771   if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
2772   TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.4);
2773   rangeEffPt->SetStats(kFALSE);
2774   SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
2775   SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
2776
2777   TH3F *h3(NULL), *h3p(NULL), *h3n(NULL);
2778   Int_t padsForEffs[5] = {0,3,6,1,4};
2779   for(Int_t iCent=1; iCent<6; ++iCent) {
2780     // TPC-TRD matching efficiencies
2781     pad = ((TPad*)l->At(padsForEffs[iCent-1])); pad->cd();
2782     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2783     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2784
2785     if(!(h3p = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+iCent)))) continue;
2786     if(!(h3n = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+iCent)))) continue;
2787     // =============================================
2788     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+iCent)))) continue;
2789     TH1F* hFeffP = EfficiencyTRD(h3p, h3, kTRUE);
2790     //
2791     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+iCent)))) continue;
2792     TH1F* hFeffN = EfficiencyTRD(h3n, h3, kTRUE);
2793     // =============================================
2794     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+iCent)))) continue;
2795     TH1F* hFeffP4 = EfficiencyTRD(h3p, h3, kTRUE);
2796     //
2797     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+iCent)))) continue;
2798     TH1F* hFeffN4 = EfficiencyTRD(h3n, h3, kTRUE);
2799     // =============================================
2800     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+iCent)))) continue;
2801     TH1F* hFeffP5 = EfficiencyTRD(h3p, h3, kTRUE);
2802     //
2803     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+iCent)))) continue;
2804     TH1F* hFeffN5 = EfficiencyTRD(h3n, h3, kTRUE);
2805     // =============================================
2806     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+iCent)))) continue;
2807     TH1F* hFeffP6 = EfficiencyTRD(h3p, h3, kTRUE);
2808     //
2809     if(!(h3 = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+iCent)))) continue;
2810     TH1F* hFeffN6 = EfficiencyTRD(h3n, h3, kTRUE);
2811
2812     rangeEffPt->Draw();
2813
2814     TLine line;
2815     line.SetLineStyle(2);
2816     line.SetLineWidth(2);
2817     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
2818     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
2819     line.SetLineStyle(1);
2820     line.SetLineWidth(1);
2821     line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 1.0, rangeEffPt->GetXaxis()->GetXmax(), 1.0);
2822     if(hFeffP) SetStyle(hFeffP, 1, kRed, 1, 24, kRed, 1);
2823     if(hFeffP4) SetStyle(hFeffP4, 1, kRed, 1, 25, kRed, 1);
2824     if(hFeffP5) SetStyle(hFeffP5, 1, kRed, 1, 26, kRed, 1);
2825     if(hFeffP6) SetStyle(hFeffP6, 1, kRed, 1, 27, kRed, 1);
2826     if(hFeffN) SetStyle(hFeffN, 1, kBlue, 1, 24, kBlue, 1);
2827     if(hFeffN4) SetStyle(hFeffN4, 1, kBlue, 1, 25, kBlue, 1);
2828     if(hFeffN5) SetStyle(hFeffN5, 1, kBlue, 1, 26, kBlue, 1);
2829     if(hFeffN6) SetStyle(hFeffN6, 1, kBlue, 1, 27, kBlue, 1);
2830
2831     TLegend* leg=new TLegend(0.16, 0.7, 0.61, 0.89);
2832     leg->SetFillColor(0);
2833     leg->SetNColumns(2);
2834     leg->SetTextSize(0.039);
2835     leg->SetMargin(0.1);
2836     if(hFeffP && hFeffP->Integral()>0.001) {
2837       isGoodForSaving = kTRUE;
2838       hFeffP->Draw("same");
2839       leg->AddEntry(hFeffP, "pos. (#geq 1 trcklt)", "p");
2840     }
2841     if(hFeffN && hFeffN->Integral()>0.001) {
2842       isGoodForSaving = kTRUE;
2843       hFeffN->Draw("same");
2844       leg->AddEntry(hFeffN, "neg. (#geq 1 trcklt)", "p");
2845     }
2846     if(hFeffP4 && hFeffP4->Integral()>0.001) {
2847       isGoodForSaving = kTRUE;
2848       hFeffP4->Draw("same");
2849       leg->AddEntry(hFeffP4, "pos. (4 trcklts)", "p");
2850     }
2851     if(hFeffN4 && hFeffN4->Integral()>0.001) {
2852       isGoodForSaving = kTRUE;
2853       hFeffN4->Draw("same");
2854       leg->AddEntry(hFeffN4, "neg. (4 trcklts)", "p");
2855     }
2856     if(hFeffP5 && hFeffP5->Integral()>0.001) {
2857       isGoodForSaving = kTRUE;
2858       hFeffP5->Draw("same");
2859       leg->AddEntry(hFeffP5, "pos. (5 trcklts)", "p");
2860     }
2861     if(hFeffN5 && hFeffN5->Integral()>0.001) {
2862       isGoodForSaving = kTRUE;
2863       hFeffN5->Draw("same");
2864       leg->AddEntry(hFeffN5, "neg. (5 trcklts)", "p");
2865     }
2866     if(hFeffP6 && hFeffP6->Integral()>0.001) {
2867       isGoodForSaving = kTRUE;
2868       hFeffP6->Draw("same");
2869       leg->AddEntry(hFeffP6, "pos. (6 trcklts)", "p");
2870     }
2871     if(hFeffN6 && hFeffN6->Integral()>0.001) {
2872       isGoodForSaving = kTRUE;
2873       hFeffN6->Draw("same");
2874       leg->AddEntry(hFeffN6, "neg. (6 trklts)", "p");
2875     }
2876
2877     if(isGoodForSaving) {
2878       if(iCent==1) leg->Draw();
2879       lat->DrawLatex(5.6, 1.3, Form("Centrality class %d", iCent));
2880       lat->DrawLatex(0.5, 1.42, "TPC-TRD matching efficiency");
2881     }
2882   }   // end loop over multiplicity intervals
2883
2884   // Number of clusters per TRD track
2885   pad = ((TPad*)l->At(2)); pad->cd();
2886   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2887   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2888   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2889   if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
2890   TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
2891   SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
2892   SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2893   rangeNcls->SetStats(kFALSE);
2894   rangeNcls->Draw();
2895
2896   TH2F* h2F[6]; TH1D* proj[6];
2897   TLegend* leg=new TLegend(0.2, 0.7, 0.5, 0.95);
2898   leg->SetFillColor(0);
2899   Bool_t isGood=kFALSE;
2900   for(Int_t iCent=0; iCent<6; ++iCent) {
2901     h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+iCent));
2902     proj[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projCent%d",iCent)) : 0x0);
2903     if(proj[iCent]) {
2904       proj[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2905       Double_t maximum = proj[iCent]->GetMaximum();
2906       if(maximum>1.0)
2907         proj[iCent]->Scale(1.0/maximum);
2908       proj[iCent]->SetStats(kFALSE);
2909       proj[iCent]->Draw("same");
2910       leg->AddEntry(proj[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
2911       isGood = kTRUE;
2912     }
2913   }
2914   if(isGood) leg->Draw();
2915   isGoodForSaving = isGoodForSaving || isGood;
2916
2917   // Qtot vs P
2918   pad = ((TPad*)l->At(5)); pad->cd();
2919   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
2920   pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
2921   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2922   if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
2923   TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
2924   SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2925   SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
2926   rangeQtot->SetStats(kFALSE);
2927   rangeQtot->Draw();
2928
2929   TH1D* projQ[6];
2930   TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.95);
2931   leg2->SetFillColor(0);
2932   isGood = kFALSE;
2933   for(Int_t iCent=0; iCent<6; ++iCent) {
2934     h2F[iCent] = dynamic_cast<TH2F*>(fHistos->At(kQtotP+iCent));
2935     projQ[iCent] = (h2F[iCent] && h2F[iCent]->GetEntries()>10 ? h2F[iCent]->ProjectionY(Form("projQCent%d",iCent)) : 0x0);
2936     if(projQ[iCent]) {
2937       projQ[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
2938       Double_t maximum = projQ[iCent]->GetMaximum();
2939       if(maximum>1.0)
2940         projQ[iCent]->Scale(1.0/maximum);
2941       projQ[iCent]->SetStats(kFALSE);
2942       projQ[iCent]->Draw("same");
2943       leg2->AddEntry(projQ[iCent], (iCent==0 ? "all centralities" : Form("centrality class %d", iCent)), "l");
2944       isGood = kTRUE;
2945     }
2946   }
2947   if(isGood) leg2->Draw();
2948   isGoodForSaving = isGoodForSaving || isGood;
2949   return isGoodForSaving;
2950 }
2951
2952
2953 //_________________________________________________________________
2954 Bool_t AliTRDcheckESD::PlotTrackingSummary(Int_t centralityClass, Double_t* trendValues) {
2955
2956   Bool_t isGoodForSaving=kFALSE;
2957
2958   TLatex *lat=new TLatex();
2959   lat->SetTextSize(0.07);
2960   lat->SetTextColor(2);
2961   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
2962   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
2963   gPad->Divide(3,3,0.,0.);
2964   TList* l=gPad->GetListOfPrimitives();
2965   // eta-phi distr. for positive TPC tracks
2966   TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
2967   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2968   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2969   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2970   if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
2971   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
2972   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
2973   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
2974   rangeEtaPhi->SetStats(kFALSE);
2975   rangeEtaPhi->Draw();
2976   lat->DrawLatex(-0.9, 3.6, "TPC positive ref. tracks");
2977
2978   TH3F* h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass));
2979   TH2F* h2FtpcP = 0x0;
2980   Float_t nada=0.0;
2981   if(h3F && h3F->GetEntries()>10) {
2982     h2FtpcP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
2983     h2FtpcP->SetStats(kFALSE);
2984     h2FtpcP->Draw("samecolz"); isGoodForSaving = kTRUE;
2985     isGoodForSaving = kTRUE;
2986   }
2987   //-----------------
2988   // eta-phi distr. for negative TPC tracks
2989   pad = ((TVirtualPad*)l->At(1)); pad->cd();
2990   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
2991   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
2992   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
2993   rangeEtaPhi->Draw();
2994   lat->DrawLatex(-0.9, 3.6, "TPC negative ref. tracks");
2995
2996   h3F = dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass));
2997   TH2F* h2FtpcN = 0x0;
2998   if(h3F && h3F->GetEntries()>10) {
2999     h2FtpcN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3000     h2FtpcN->SetStats(kFALSE);
3001     h2FtpcN->Draw("samecolz");
3002     isGoodForSaving = kTRUE;
3003   }
3004   //----------------------------------------------
3005   // eta-phi distr. for positive TRD tracks
3006   pad = ((TVirtualPad*)l->At(3)); pad->cd();
3007   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3008   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3009   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3010   rangeEtaPhi->Draw();
3011   lat->DrawLatex(-0.9, 3.6, "TRD positive ref. tracks");
3012
3013   h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass));
3014   TH2F* h2FtrdP = 0x0;
3015   if(h3F && h3F->GetEntries()>10) {
3016     h2FtrdP = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3017     h2FtrdP->SetStats(kFALSE);
3018     h2FtrdP->SetMaximum((h2FtpcP ? h2FtpcP->GetMaximum() : h2FtrdP->GetMaximum()));
3019     h2FtrdP->Draw("samecolz");
3020     isGoodForSaving=kTRUE;
3021   }
3022   //--------------------------------------------
3023   // eta-phi distr. for negative TRD tracks
3024   pad = ((TVirtualPad*)l->At(4)); pad->cd();
3025   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3026   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3027   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3028   rangeEtaPhi->Draw();
3029   lat->DrawLatex(-0.9, 3.6, "TRD negative ref. tracks");
3030
3031   h3F = dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass));
3032   TH2F* h2FtrdN = 0x0;
3033   if(h3F && h3F->GetEntries()>10) {
3034     h2FtrdN = (TH2F*)Proj3D((TH3F*)h3F, 0x0, 1, h3F->GetZaxis()->GetNbins(), nada)->Clone();
3035     h2FtrdN->SetStats(kFALSE);
3036     h2FtrdN->SetMaximum(h2FtpcN ? h2FtpcN->GetMaximum() : h2FtrdN->GetMaximum());
3037     h2FtrdN->Draw("samecolz");
3038     isGoodForSaving=kTRUE;
3039   }
3040   //----------------------------------------------
3041   // eta-phi efficiency for positive TRD tracks
3042   pad = ((TVirtualPad*)l->At(6)); pad->cd();
3043   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3044   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3045   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3046   rangeEtaPhi->Draw();
3047   lat->DrawLatex(-0.9, 3.6, "Efficiency positive tracks");
3048
3049   TH2F* h2Feff = (h2FtrdP ? (TH2F*)h2FtrdP->Clone("h2FeffPos") : 0x0);
3050   if(h2Feff) {
3051     h2Feff->Reset();
3052     h2Feff->SetStats(kFALSE);
3053     h2Feff->Divide(h2FtrdP, h2FtpcP);
3054     h2Feff->SetMaximum(1.0);
3055     if(h2Feff->GetEntries()>1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; }
3056   }
3057   //-------------------------------------------------
3058   // eta-phi efficiency for negative TRD tracks
3059   pad = ((TVirtualPad*)l->At(7)); pad->cd();
3060   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3061   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3062   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3063   rangeEtaPhi->Draw();
3064   lat->DrawLatex(-0.9, 3.6, "Efficiency negative tracks");
3065
3066   h2Feff = (h2FtrdN ? (TH2F*)h2FtrdN->Clone("h2FeffNeg") : 0x0);
3067   if(h2Feff) {
3068     h2Feff->Reset();
3069     h2Feff->SetStats(kFALSE);
3070     h2Feff->Divide(h2FtrdN, h2FtpcN);
3071     h2Feff->SetMaximum(1.0);
3072     if(h2Feff->GetEntries()>0.1) { h2Feff->Draw("samecolz"); isGoodForSaving=kTRUE; }
3073   }
3074   //-----------------------------------------------------
3075   // <ntracklets> vs (phi,eta)
3076   pad = ((TVirtualPad*)l->At(2)); pad->cd();
3077   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3078   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3079   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3080   rangeEtaPhi->Draw();
3081   lat->DrawLatex(-0.9, 3.6, "TRD <N_{tracklets}>");
3082
3083   TProfile2D* hProf2D;
3084   if((hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvNtrkl+centralityClass)))) {
3085     if(hProf2D->GetEntries()>10) {
3086       hProf2D->SetStats(kFALSE);
3087       hProf2D->SetMinimum(0.);
3088       hProf2D->SetMaximum(6.);
3089       if(hProf2D->GetEntries()>1) { hProf2D->Draw("samecolz"); isGoodForSaving = kTRUE; }
3090     }
3091   }
3092   //---------------------------------------------------------
3093   // TPC-TRD matching efficiency vs pt
3094   pad = ((TVirtualPad*)l->At(5)); pad->cd();
3095   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
3096   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3097   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3098   TH1F* hFeffP = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3099               dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos+centralityClass)), kTRUE);
3100   TH1F* hFeffN = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3101               dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg+centralityClass)), kTRUE);
3102   TH1F* hFeffP4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3103         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos4+centralityClass)), kTRUE);
3104   TH1F* hFeffN4 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3105         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg4+centralityClass)), kTRUE);
3106   TH1F* hFeffP5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3107         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos5+centralityClass)), kTRUE);
3108   TH1F* hFeffN5 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3109         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg5+centralityClass)), kTRUE);
3110   TH1F* hFeffP6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksPos+centralityClass)),
3111         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksPos6+centralityClass)), kTRUE);
3112   TH1F* hFeffN6 = EfficiencyTRD(dynamic_cast<TH3F*>(fHistos->At(kTPCRefTracksNeg+centralityClass)),
3113         dynamic_cast<TH3F*>(fHistos->At(kTRDRefTracksNeg6+centralityClass)), kTRUE);
3114
3115   TF1* funcConst = new TF1("funcConst", "[0]", 1.0, 3.0);
3116
3117   if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
3118   TH2F* rangeEffPt2=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
3119   rangeEffPt2->SetStats(kFALSE);
3120   SetStyle(rangeEffPt2->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3121   SetStyle(rangeEffPt2->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
3122   rangeEffPt2->Draw();
3123   lat->DrawLatex(0.5, 1.42, "TRD-TPC matching efficiency");
3124   //++++++++++++++++++
3125   TLine line;
3126   line.SetLineStyle(2);
3127   line.SetLineWidth(2);
3128   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.7, rangeEffPt2->GetXaxis()->GetXmax(), 0.7);
3129   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 0.9, rangeEffPt2->GetXaxis()->GetXmax(), 0.9);
3130   line.SetLineStyle(1);
3131   line.SetLineWidth(1);
3132   line.DrawLine(rangeEffPt2->GetXaxis()->GetXmin(), 1.0, rangeEffPt2->GetXaxis()->GetXmax(), 1.0);
3133   TLegend* leg=new TLegend(0.2, 0.7, 0.6, 0.89);
3134   leg->SetNColumns(2);
3135   leg->SetFillColor(0);
3136   if(hFeffP){
3137     hFeffP->SetMarkerStyle(24);
3138     hFeffP->SetMarkerColor(2);
3139     hFeffP->SetLineColor(2);
3140     if(trendValues && hFeffP->GetEntries()>1) {
3141       hFeffP->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3142       trendValues[0] = funcConst->GetParameter(0);
3143       trendValues[1] = funcConst->GetParError(0);
3144     }
3145     if(hFeffP->Integral()>0.001) {
3146       hFeffP->Draw("same");
3147       leg->AddEntry(hFeffP, "positives (#geq 1 tracklet)", "p");
3148     }
3149   }
3150   if(hFeffN){
3151     hFeffN->SetMarkerStyle(24);
3152     hFeffN->SetMarkerColor(4);
3153     hFeffN->SetLineColor(4);
3154     if(trendValues && hFeffN->GetEntries()>1) {
3155       hFeffN->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3156       trendValues[2] = funcConst->GetParameter(0);
3157       trendValues[3] = funcConst->GetParError(0);
3158     }
3159     if(hFeffN->Integral()>0.001) {
3160       hFeffN->Draw("same");
3161       leg->AddEntry(hFeffN, "negatives (#geq 1 tracklet)", "p");
3162     }
3163   }
3164   if(hFeffP4){
3165     hFeffP4->SetMarkerStyle(25);
3166     hFeffP4->SetMarkerColor(2);
3167     hFeffP4->SetLineColor(2);
3168     if(hFeffP4->Integral()>0.001) {
3169       hFeffP4->Draw("same");
3170       leg->AddEntry(hFeffP4, "positives (4 tracklets)", "p");
3171     }
3172   }
3173   if(hFeffN4){
3174     hFeffN4->SetMarkerStyle(25);
3175     hFeffN4->SetMarkerColor(4);
3176     hFeffN4->SetLineColor(4);
3177     if(hFeffN4->Integral()>0.001) {
3178       hFeffN4->Draw("same");
3179       leg->AddEntry(hFeffN4, "negatives (4 tracklets)", "p");
3180     }
3181   }
3182   if(hFeffP5){
3183     hFeffP5->SetMarkerStyle(26);
3184     hFeffP5->SetMarkerColor(2);
3185     hFeffP5->SetLineColor(2);
3186     if(hFeffP5->Integral()>0.001) {
3187       hFeffP5->Draw("same");
3188       leg->AddEntry(hFeffP5, "positives (5 tracklets)", "p");
3189     }
3190   }
3191   if(hFeffN5){
3192     hFeffN5->SetMarkerStyle(26);
3193     hFeffN5->SetMarkerColor(4);
3194     hFeffN5->SetLineColor(4);
3195     if(hFeffN5->Integral()>0.001) {
3196       hFeffN5->Draw("same");
3197       leg->AddEntry(hFeffN5, "negatives (5 tracklets)", "p");
3198     }
3199   }
3200   if(hFeffP6){
3201     hFeffP6->SetMarkerStyle(27);
3202     hFeffP6->SetMarkerColor(2);
3203     hFeffP6->SetLineColor(2);
3204     if(hFeffP6->Integral()>0.001) {
3205       hFeffP6->Draw("same");
3206       leg->AddEntry(hFeffP6, "positives (6 tracklets)", "p");
3207     }
3208   }
3209   if(hFeffN6){
3210     hFeffN6->SetMarkerStyle(27);
3211     hFeffN6->SetMarkerColor(4);
3212     hFeffN6->SetLineColor(4);
3213     if(hFeffN6->Integral()>0.001) {
3214       hFeffN6->Draw("same");
3215       leg->AddEntry(hFeffN6, "negatives (6 tracklets)", "p");
3216     }
3217   }
3218   leg->Draw();
3219
3220   //--------------------------------------------------------------
3221   // Nclusters per TRD track
3222   pad = ((TVirtualPad*)l->At(8)); pad->cd();
3223   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
3224   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3225   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3226   pad->SetLogz();
3227   if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
3228   TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
3229   SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3230   SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
3231   rangeNclsP->SetStats(kFALSE);
3232   rangeNclsP->Draw();
3233   lat->DrawLatex(1.0, 205., "TRD Clusters / track");
3234
3235   TH2F* hNclsVsP=0x0;
3236   if((hNclsVsP = dynamic_cast<TH2F*>(fHistos->At(kNClsTrackTRD+centralityClass)))) {
3237     hNclsVsP->SetStats(kFALSE);
3238     if(hNclsVsP->GetEntries()>10) {
3239       hNclsVsP->Draw("samecolz"); isGoodForSaving=kTRUE;
3240       if(trendValues) {
3241         TProfile* h2FProf = hNclsVsP->ProfileX("nclsVsPprof");
3242         h2FProf->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
3243         trendValues[4] = funcConst->GetParameter(0);
3244         trendValues[5] = funcConst->GetParError(0);
3245       }
3246     }
3247   }
3248
3249   delete funcConst;
3250   return isGoodForSaving;
3251 }
3252
3253
3254 //_________________________________________________________________
3255 Bool_t AliTRDcheckESD::PlotPidSummary(Int_t centralityClass, Double_t* trendValues) {
3256
3257   Bool_t isGoodForSaving=kFALSE;
3258
3259   TLatex *lat=new TLatex();
3260   lat->SetTextSize(0.07);
3261   lat->SetTextColor(2);
3262   gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
3263   gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
3264   gPad->Divide(3,3,0.,0.);
3265   TList* l=gPad->GetListOfPrimitives();
3266   // eta-phi distr. for <Qtot> in layer 0
3267   TVirtualPad* pad;
3268   TProfile2D* hProf2D;
3269   if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
3270   TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.4, +3.4);
3271   SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
3272   SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
3273   rangeEtaPhi->SetStats(kFALSE);
3274
3275   for(Int_t iLayer=0; iLayer<6; ++iLayer) {
3276     pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
3277     pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3278     pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3279     pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3280     rangeEtaPhi->Draw();
3281     lat->DrawLatex(-0.9, 3.6, Form("TRD <Q_{tot}> Layer %d", iLayer));
3282
3283     if(!(hProf2D = dynamic_cast<TProfile2D*>(fHistos->At(kTRDEtaPhiAvQtot+6*centralityClass+iLayer)))) continue;
3284     if(hProf2D && hProf2D->GetEntries()>10) {
3285       hProf2D->SetStats(kFALSE);
3286       hProf2D->SetMinimum(0.);
3287       hProf2D->SetMaximum(4.);
3288       if(hProf2D->GetEntries()>10) { hProf2D->Draw("samecolz"); isGoodForSaving=kTRUE; }
3289     }
3290   }
3291
3292   // PH versus slice number
3293   pad = ((TVirtualPad*)l->At(2)); pad->cd();
3294   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3295   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3296   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3297   if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
3298   TH2F* rangePHslice = new TH2F("rangePHslice", "", 10, -0.5, 7.5, 10, 0.0, 2000.0);
3299   SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
3300   SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
3301   rangePHslice->SetStats(kFALSE);
3302   rangePHslice->Draw();
3303
3304   TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
3305
3306   TH2F* h2F;
3307   TH1D* hF;
3308   if((h2F = dynamic_cast<TH2F*>(fHistos->At(kPHSlice+centralityClass)))) {
3309     if(h2F && h2F->GetEntries()>10) {
3310       hF = Proj2D(h2F);
3311       h2F->SetStats(kFALSE);
3312       h2F->Draw("samecolz");
3313       isGoodForSaving=kTRUE;
3314       if(trendValues) {
3315         hF->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
3316         trendValues[6] = funcPol1->GetParameter(0);
3317         trendValues[7] = funcPol1->GetParError(0);
3318         trendValues[8] = funcPol1->GetParameter(1);
3319         trendValues[9] = funcPol1->GetParError(1);
3320       }
3321       hF->SetLineWidth(2);
3322       hF->Draw("same");
3323     }
3324   }
3325   delete funcPol1;
3326
3327   // Qtot vs P
3328   pad = ((TVirtualPad*)l->At(5)); pad->cd();
3329   pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
3330   pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
3331   pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
3332   pad->SetLogz();
3333   if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
3334   TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, 11.99);
3335   SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
3336   SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
3337   rangeQtotP->SetStats(kFALSE);
3338   rangeQtotP->Draw();
3339
3340   if((h2F = dynamic_cast<TH2F*>(fHistos->At(kQtotP+centralityClass)))) {
3341     if(h2F && h2F->GetEntries()>10) {
3342       h2F->SetStats(kFALSE);
3343       h2F->Draw("samecolz");
3344       isGoodForSaving=kTRUE;
3345       hF = Proj2D(h2F);
3346       hF->SetLineWidth(2);
3347       hF->Draw("same");
3348       if(trendValues) {
3349         trendValues[10] = hF->GetBinContent(hF->FindBin(1.0));
3350         trendValues[11] = hF->GetBinError(hF->FindBin(1.0));
3351       }
3352     }
3353   }
3354   return isGoodForSaving;
3355 }
3356
3357 //__________________________________________________________________________________________________
3358 void AliTRDcheckESD::DrawTRDGrid() {
3359   //
3360   //   Draw a grid of lines showing the TRD supermodule and stack structure in (eta,phi) coordinates.
3361   //   The canvas on which to draw must already exist.
3362   //
3363   TLine line;
3364   line.SetLineColor(2);
3365   line.SetLineWidth(1);
3366   line.SetLineStyle(2);
3367   for(Int_t i=0; i<=9; ++i) {
3368     line.DrawLine(-1.0, 2.0*TMath::Pi()/18.0*i, +1.0, 2.0*TMath::Pi()/18.0*i);
3369     line.DrawLine(-1.0, -2.0*TMath::Pi()/18.0*i, +1.0, -2.0*TMath::Pi()/18.0*i);
3370   }
3371   line.DrawLine(-0.85, -3.2, -0.85, +3.2);
3372   line.DrawLine(-0.54, -3.2, -0.54, +3.2);
3373   line.DrawLine(-0.16, -3.2, -0.16, +3.2);
3374   line.DrawLine(+0.16, -3.2, +0.16, +3.2);
3375   line.DrawLine(+0.54, -3.2, +0.54, +3.2);
3376   line.DrawLine(+0.85, -3.2, +0.85, +3.2);
3377 }
3378
3379 //_________________________________________________________________
3380 void AliTRDcheckESD::SetStyle(TH1* hist,
3381                               Int_t lineStyle, Int_t lineColor, Int_t lineWidth,
3382                               Int_t markerStyle, Int_t markerColor, Int_t markerSize) {
3383   //
3384   // Set style settings for histograms
3385   //
3386   if(!hist) return;
3387   hist->SetLineStyle(lineStyle);
3388   hist->SetLineColor(lineColor);
3389   hist->SetLineWidth(lineWidth);
3390   hist->SetMarkerStyle(markerStyle);
3391   hist->SetMarkerColor(markerColor);
3392   hist->SetMarkerSize(markerSize);
3393 }
3394
3395 //____________________________________________________________________
3396 void AliTRDcheckESD::SetStyle(TAxis* axis, const Char_t* title, Float_t titleSize, Float_t titleOffset, Bool_t centerTitle,
3397                               Float_t labelSize) {
3398   //
3399   // Set style settings for axes
3400   //
3401   if(!axis) return;
3402   axis->SetTitle(title);
3403   axis->SetTitleSize(titleSize);
3404   axis->SetTitleOffset(titleOffset);
3405   axis->CenterTitle(centerTitle);
3406   axis->SetLabelSize(labelSize);
3407 }
3408
3409 //____________________________________________________________________
3410 void AliTRDcheckESD::FindIsolatedBCs(TH1D* bcHist, Bool_t isIsolated[3500]) {
3411   //
3412   // Find the isolated bunch crossings
3413   //
3414   Int_t isolationSize = 5;      // number of free bunches in both directions
3415   for(Int_t bcBin=1; bcBin<=bcHist->GetXaxis()->GetNbins(); ++bcBin) {
3416     Int_t bc = TMath::Nint(bcHist->GetBinCenter(bcBin));
3417     if(bc<-0.001 || bc>3499.01) {
3418       isIsolated[bc] = kFALSE;
3419       continue;
3420     }
3421     Double_t entries = bcHist->GetBinContent(bcBin);
3422     if(entries<0.001) {
3423       isIsolated[bc] = kFALSE;
3424       continue;     // no entries
3425     }
3426
3427     // check isolation
3428     isIsolated[bc] = kTRUE;
3429     for(Int_t ibc = TMath::Max(1,bcBin-isolationSize); ibc<=TMath::Min(3499, bcBin+isolationSize); ++ibc) {
3430       if(ibc==bcBin) continue;
3431       if(bcHist->GetBinContent(ibc)>0.01) {
3432         isIsolated[bc] = kFALSE;
3433         break;
3434       }
3435     }
3436   }   // end loop over BC bins
3437
3438   cout << "Isolated bunches: " << endl;
3439   for(Int_t ibc=0; ibc<3500; ++ibc)
3440     if(isIsolated[ibc]) cout << "BC #" << ibc << endl;
3441 }
3442
3443
3444 //__________________________________________________________________________________________________
3445 Int_t AliTRDcheckESD::GetTriggerIndex(const Char_t* name, Bool_t createNew/*=kTRUE*/) {
3446   //
3447   //  Return the index of trigger "name" in the trigger histogram.
3448   //  If the index for this trigger does not exist yet, then assign one if createNew is set to TRUE
3449   //
3450   //cout << "GetTriggerIndex for " << name << endl;
3451   TH1F* triggerHist = (TH1F*)fHistos->At(kTriggerDefs);
3452   TString nameStr=name;
3453   for(Int_t i=1; i<=triggerHist->GetXaxis()->GetNbins(); ++i) {
3454     if(!nameStr.CompareTo(triggerHist->GetXaxis()->GetBinLabel(i))) {
3455       //cout << "       index found: " << i << endl;
3456       return i;
3457     }
3458   }
3459   if(createNew) {
3460     triggerHist->GetXaxis()->SetBinLabel(fNAssignedTriggers+1, name);
3461     if(fMatchingPhiEtaCF->GetVar("trigger")>=0) {
3462       fMatchingPhiEtaCF->GetAxis(fMatchingPhiEtaCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3463       fMatchingPhiEtaCF->GetAxis(fMatchingPhiEtaCF->GetVar("trigger"), 1)->SetBinLabel(fNAssignedTriggers+1, name);
3464       fMatchingPhiEtaCF->GetAxis(fMatchingPhiEtaCF->GetVar("trigger"), 2)->SetBinLabel(fNAssignedTriggers+1, name);
3465     }
3466     if(fMatchingPtCF->GetVar("trigger")>=0) {
3467       fMatchingPtCF->GetAxis(fMatchingPtCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3468       fMatchingPtCF->GetAxis(fMatchingPtCF->GetVar("trigger"), 1)->SetBinLabel(fNAssignedTriggers+1, name);
3469       fMatchingPtCF->GetAxis(fMatchingPtCF->GetVar("trigger"), 2)->SetBinLabel(fNAssignedTriggers+1, name);
3470     }
3471     if(fBunchCrossingsCF->GetVar("trigger")>=0) {
3472       fBunchCrossingsCF->GetAxis(fBunchCrossingsCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3473       fBunchCrossingsCF->GetAxis(fBunchCrossingsCF->GetVar("trigger"), 1)->SetBinLabel(fNAssignedTriggers+1, name);
3474       fBunchCrossingsCF->GetAxis(fBunchCrossingsCF->GetVar("trigger"), 2)->SetBinLabel(fNAssignedTriggers+1, name);
3475     }
3476     if(fCentralityCF->GetVar("trigger")>=0)
3477       fCentralityCF->GetAxis(fCentralityCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3478     if(fQtotCF->GetVar("trigger")>=0)
3479       fQtotCF->GetAxis(fQtotCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3480     if(fPulseHeightCF->GetVar("trigger")>=0)
3481       fPulseHeightCF->GetAxis(fPulseHeightCF->GetVar("trigger"), 0)->SetBinLabel(fNAssignedTriggers+1, name);
3482     if(fExpertCF) {
3483       if(fExpertCF->GetVar("trigger")>=0)
3484         for(Int_t istep=0; istep<fExpertCF->GetNStep(); ++istep)
3485           fExpertCF->GetAxis(fExpertCF->GetVar("trigger"), istep)->SetBinLabel(fNAssignedTriggers+1, name);
3486     }
3487
3488     ++fNAssignedTriggers;
3489     return fNAssignedTriggers+1;
3490   }
3491   else {
3492     return -1;
3493   }
3494 }
3495
3496 //__________________________________________________________________________________________________
3497 void AliTRDcheckESD::PrintTriggers() const {
3498   //
3499   //  Print the available triggers for this run
3500   //
3501   if(!fHistos) {
3502     cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
3503     return;
3504   }
3505   TH1F* hTriggers = (TH1F*)fHistos->At(kTriggerDefs);
3506   cout << "Triggers found in this run" << endl;
3507   cout << "==========================" << endl;
3508   cout << "Name   Index   Entries    " << endl;
3509   for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
3510     if(hTriggers->GetXaxis()->GetBinLabel(it)[0]!='\0') {
3511       cout << hTriggers->GetXaxis()->GetBinLabel(it) << "  " << hTriggers->GetXaxis()->GetBinCenter(it) << "  " << hTriggers->GetBinContent(it) << endl;
3512     }
3513   }
3514 }
3515
3516
3517 //__________________________________________________________________________________________________
3518 Int_t AliTRDcheckESD::GetTriggerCounter(const Char_t* triggerName) const {
3519   //
3520   // Get the number of events for a given trigger name
3521   //
3522   if(!fHistos) {
3523     cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
3524     return -1;
3525   }
3526   TH1F* hTriggers = (TH1F*)fHistos->At(kTriggerDefs);
3527   Int_t counter = -1;
3528   for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
3529     TString trgString = hTriggers->GetXaxis()->GetBinLabel(it);
3530     if(!trgString.CompareTo(triggerName))
3531       counter = (Int_t)hTriggers->GetBinContent(it);
3532   }
3533   if(counter<0) {cout << "AliTRDcheckESD::GetTriggerCounter()  Trigger not found !!";}
3534   return counter;
3535 }
3536
3537
3538 //__________________________________________________________________________________________________________
3539 Int_t AliTRDcheckESD::GetNAssignedTriggers() {
3540   //
3541   // Return the number of assigned triggers
3542   //
3543   return fNAssignedTriggers;
3544 }