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