PWGPP/TRD/AliTRDcheckESD.cxx

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