24231c49e531ad46d8fd89ecb2d336f3e4afa33d
[u/mrichter/AliRoot.git] / PWG1 / TPC / AliPerformanceEff.cxx
1 //------------------------------------------------------------------------------\r
2 // Implementation of AliPerformanceEff class. It keeps information from \r
3 // comparison of reconstructed and MC particle tracks. In addtion, \r
4 // it keeps selection cuts used during comparison. The comparison \r
5 // information is stored in the ROOT histograms. Analysis of these \r
6 // histograms can be done by using Analyse() class function. The result of \r
7 // the analysis (histograms/graphs) are stored in the folder which is \r
8 // a data member of AliPerformanceEff.\r
9 // \r
10 // Author: J.Otwinowski 04/02/2008 \r
11 //------------------------------------------------------------------------------\r
12 \r
13 /*\r
14  \r
15   // after running comparison task, read the file, and get component\r
16   gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");\r
17   LoadMyLibs();\r
18   TFile f("Output.root");\r
19   AliPerformanceEff * compObj = (AliPerformanceEff*)coutput->FindObject("AliPerformanceEff");\r
20 \r
21   // Analyse comparison data\r
22   compObj->Analyse();\r
23 \r
24   // the output histograms/graphs will be stored in the folder "folderEff" \r
25   compObj->GetAnalysisFolder()->ls("*");\r
26 \r
27   // user can save whole comparison object (or only folder with anlysed histograms) \r
28   // in the seperate output file (e.g.)\r
29   TFile fout("Analysed_Eff.root","recreate");\r
30   compObj->Write(); // compObj->GetAnalysisFolder()->Write();\r
31   fout.Close();\r
32 \r
33 */\r
34 \r
35 #include <TAxis.h>\r
36 #include <TH1D.h>\r
37 #include "THnSparse.h"\r
38 \r
39 // \r
40 #include "AliESDtrack.h"\r
41 #include "AliRecInfoCuts.h" \r
42 #include "AliMCInfoCuts.h" \r
43 #include "AliLog.h" \r
44 #include "AliESDVertex.h" \r
45 #include "AliExternalTrackParam.h" \r
46 #include "AliTracker.h" \r
47 #include "AliESDEvent.h" \r
48 #include "AliMCEvent.h" \r
49 #include "AliMCParticle.h" \r
50 #include "AliHeader.h" \r
51 #include "AliGenEventHeader.h" \r
52 #include "AliStack.h" \r
53 #include "AliPerformanceEff.h" \r
54 \r
55 using namespace std;\r
56 \r
57 ClassImp(AliPerformanceEff)\r
58 \r
59 //_____________________________________________________________________________\r
60 AliPerformanceEff::AliPerformanceEff():\r
61   AliPerformanceObject("AliPerformanceEff"),\r
62 \r
63   // histograms\r
64   fEffHisto(0),\r
65   fEffSecHisto(0),\r
66 \r
67   // Cuts \r
68   fCutsRC(0), \r
69   fCutsMC(0),\r
70 \r
71   // histogram folder \r
72   fAnalysisFolder(0)\r
73 {\r
74   // default consttructor       \r
75   Init();\r
76 }\r
77 \r
78 //_____________________________________________________________________________\r
79 AliPerformanceEff::AliPerformanceEff(Char_t* name="AliPerformanceEff",Char_t*title="AliPerformanceEff",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE):\r
80   AliPerformanceObject(name,title),\r
81 \r
82   // histograms\r
83   fEffHisto(0),\r
84   fEffSecHisto(0),\r
85 \r
86   // Cuts \r
87   fCutsRC(0), \r
88   fCutsMC(0),\r
89 \r
90   // histogram folder \r
91   fAnalysisFolder(0)\r
92 {\r
93   // named constructor\r
94   //\r
95   SetAnalysisMode(analysisMode);\r
96   SetHptGenerator(hptGenerator);\r
97 \r
98   Init();\r
99 }\r
100 \r
101 \r
102 //_____________________________________________________________________________\r
103 AliPerformanceEff::~AliPerformanceEff()\r
104 {\r
105 // destructor\r
106 \r
107   if(fEffHisto)  delete  fEffHisto; fEffHisto=0;\r
108   if(fEffSecHisto)  delete  fEffSecHisto; fEffSecHisto=0;\r
109   if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;\r
110 }\r
111 \r
112 //_____________________________________________________________________________\r
113 void AliPerformanceEff::Init()\r
114 {\r
115   // Init histograms\r
116   //\r
117   // set pt bins\r
118   Int_t nPtBins = 50;\r
119   Double_t ptMin = 1.e-2, ptMax = 10.;\r
120 \r
121   Double_t *binsPt = 0;\r
122   if (IsHptGenerator())  { \r
123     nPtBins = 100; ptMax = 100.;\r
124     binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);\r
125   } else {\r
126     binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);\r
127   }\r
128 \r
129   /*\r
130   Int_t nPtBins = 31;\r
131   Double_t binsPt[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.};\r
132   Double_t ptMin = 0., ptMax = 10.;\r
133 \r
134   if(IsHptGenerator() == kTRUE) {\r
135     nPtBins = 100;\r
136     ptMin = 0.; ptMax = 100.;\r
137   }\r
138   */\r
139 \r
140   //mceta:mcphi:mcpt:pid:recStatus:findable\r
141   Int_t binsEffHisto[6]={30,144,nPtBins,5,2,2};\r
142   Double_t minEffHisto[6]={-1.5,0.,ptMin,0.,0.,0.};\r
143   Double_t maxEffHisto[6]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.};\r
144 \r
145   fEffHisto = new THnSparseF("fEffHisto","mceta:mcphi:mcpt:pid:recStatus:findable",6,binsEffHisto,minEffHisto,maxEffHisto);\r
146   fEffHisto->SetBinEdges(2,binsPt);\r
147 \r
148   fEffHisto->GetAxis(0)->SetTitle("#eta_{mc}");\r
149   fEffHisto->GetAxis(1)->SetTitle("#phi_{mc} (rad)");\r
150   fEffHisto->GetAxis(2)->SetTitle("p_{Tmc} (GeV/c)");\r
151   fEffHisto->GetAxis(3)->SetTitle("pid");\r
152   fEffHisto->GetAxis(4)->SetTitle("recStatus");\r
153   fEffHisto->GetAxis(5)->SetTitle("findable");\r
154   fEffHisto->Sumw2();\r
155 \r
156   //mceta:mcphi:mcpt:pid:recStatus:findable:mcR:mother_phi:mother_eta\r
157   Int_t binsEffSecHisto[9]={30,60,nPtBins,5,2,2,100,60,30};\r
158   Double_t minEffSecHisto[9]={-1.5,0.,ptMin,0.,0.,0.,0.,0.,-1.5};\r
159   Double_t maxEffSecHisto[9]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.,200,2.*TMath::Pi(),1.5};\r
160 \r
161   fEffSecHisto = new THnSparseF("fEffSecHisto","mceta:mcphi:mcpt:pid:recStatus:findable:mcR:mother_phi:mother_eta",9,binsEffSecHisto,minEffSecHisto,maxEffSecHisto);\r
162   fEffSecHisto->SetBinEdges(2,binsPt);\r
163 \r
164   fEffSecHisto->GetAxis(0)->SetTitle("#eta_{mc}");\r
165   fEffSecHisto->GetAxis(1)->SetTitle("#phi_{mc} (rad)");\r
166   fEffSecHisto->GetAxis(2)->SetTitle("p_{Tmc} (GeV/c)");\r
167   fEffSecHisto->GetAxis(3)->SetTitle("pid");\r
168   fEffSecHisto->GetAxis(4)->SetTitle("recStatus");\r
169   fEffSecHisto->GetAxis(5)->SetTitle("findable");\r
170   fEffSecHisto->GetAxis(6)->SetTitle("mcR (cm)");\r
171   fEffSecHisto->GetAxis(7)->SetTitle("mother_phi (rad)");\r
172   fEffSecHisto->GetAxis(8)->SetTitle("mother_eta");\r
173   fEffSecHisto->Sumw2();\r
174 \r
175   // init cuts\r
176   if(!fCutsMC) \r
177     AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object");\r
178   if(!fCutsRC) \r
179     AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object");\r
180 \r
181   // init folder\r
182   fAnalysisFolder = CreateFolder("folderEff","Analysis Efficiency Folder");\r
183 }\r
184 \r
185 //_____________________________________________________________________________\r
186 void AliPerformanceEff::ProcessTPC(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
187 {\r
188   // Fill TPC only efficiency comparison information \r
189   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
190   if(!labelsRec) \r
191      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
192 \r
193   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
194   if(!labelsAllRec) \r
195      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
196 \r
197   // loop over rec. tracks\r
198   AliESDtrack *track=0;\r
199   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
200   { \r
201     track = esdEvent->GetTrack(iTrack);\r
202     if(!track) continue;\r
203     if(track->Charge()==0) continue;\r
204     Int_t label = TMath::Abs(track->GetLabel()); \r
205     labelsAllRec[iTrack]=label;\r
206 \r
207     // TPC only\r
208     if(IsRecTPC(track) != 0) \r
209       labelsRec[iTrack]=label;\r
210   }\r
211 \r
212   // \r
213   // MC histograms for efficiency studies\r
214   //\r
215   if(!mcEvent) return;\r
216  \r
217   AliStack *stack = mcEvent->Stack();\r
218   if (!stack) {\r
219     AliDebug(AliLog::kError, "Stack not available");\r
220     return;\r
221   }\r
222 \r
223   //Int_t nPart  = stack->GetNtrack();\r
224   Int_t nPart  = stack->GetNprimary();\r
225   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
226   {\r
227     TParticle* particle = stack->Particle(iMc);\r
228     if (!particle) continue;\r
229     if (!particle->GetPDG()) continue; \r
230     if (particle->GetPDG()->Charge() == 0.0) continue;\r
231       \r
232     // physical primary\r
233     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
234     if(!prim) continue;\r
235 \r
236     Bool_t findable = kFALSE;\r
237     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
238     {\r
239       // check findable\r
240       if(iMc == labelsAllRec[iRec]) \r
241       {\r
242         findable = IsFindable(mcEvent,iMc);\r
243         break;\r
244       }\r
245     }  \r
246 \r
247     Bool_t recStatus = kFALSE;\r
248     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
249     {\r
250       // check reconstructed\r
251       if(iMc == labelsRec[iRec]) \r
252       {\r
253         recStatus = kTRUE;\r
254         break;\r
255       }\r
256     }\r
257 \r
258     // Only 5 charged particle species (e,mu,pi,K,p)\r
259     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
260 \r
261     // transform Pdg to Pid\r
262     Int_t pid = TransformToPID(particle);\r
263 \r
264     Float_t mceta =  particle->Eta();\r
265     Float_t mcphi =  particle->Phi();\r
266     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
267     Float_t mcpt = particle->Pt();\r
268 \r
269 \r
270     // Fill histograms\r
271     Double_t vEffHisto[6] = {mceta, mcphi, mcpt, pid, recStatus, findable}; \r
272     fEffHisto->Fill(vEffHisto);\r
273   }\r
274 \r
275   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
276   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
277 }\r
278 \r
279 //_____________________________________________________________________________\r
280 void AliPerformanceEff::ProcessTPCSec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
281 {\r
282   // Fill TPC only efficiency comparison information for secondaries\r
283   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
284   if(!labelsRec) \r
285      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
286 \r
287   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
288   if(!labelsAllRec) \r
289      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
290 \r
291   // loop over rec. tracks\r
292   AliESDtrack *track=0;\r
293   Int_t multAll=0, multRec=0;\r
294   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
295   { \r
296     track = esdEvent->GetTrack(iTrack);\r
297     if(!track) continue;\r
298     if(track->Charge()==0) continue;\r
299     Int_t label = TMath::Abs(track->GetLabel()); \r
300     labelsAllRec[multAll]=label;\r
301     multAll++;\r
302 \r
303     // TPC only\r
304     if(IsRecTPC(track) != 0) {\r
305       labelsRec[multRec]=label;\r
306       multRec++;\r
307     }\r
308   }\r
309 \r
310   // \r
311   // MC histograms for efficiency studies\r
312   //\r
313   if(!mcEvent) return;\r
314  \r
315   AliStack *stack = mcEvent->Stack();\r
316   if (!stack) {\r
317     AliDebug(AliLog::kError, "Stack not available");\r
318     return;\r
319   }\r
320 \r
321   Int_t nPart  = stack->GetNtrack();\r
322   //Int_t nPart  = stack->GetNprimary();\r
323   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
324   {\r
325     TParticle* particle = stack->Particle(iMc);\r
326     if (!particle) continue;\r
327     if (!particle->GetPDG()) continue; \r
328     if (particle->GetPDG()->Charge() == 0.0) continue;\r
329       \r
330     // physical primary\r
331     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
332 \r
333     // only secondaries which can be reconstructed at TPC\r
334     if(prim) continue;\r
335 \r
336     //Float_t radius = TMath::Sqrt(particle->Vx()*particle->Vx()+particle->Vy()*particle->Vy()+particle->Vz()*particle->Vz());\r
337     //if(radius > fCutsMC->GetMaxR()) continue;\r
338 \r
339     // only secondary electrons from gamma conversion\r
340     //if( TMath::Abs(particle->GetPdgCode())!=fCutsMC->GetEM() ||   particle->GetUniqueID() != 5) continue;\r
341 \r
342     Bool_t findable = kFALSE;\r
343     for(Int_t iRec=0; iRec<multAll; ++iRec) \r
344     {\r
345       // check findable\r
346       if(iMc == labelsAllRec[iRec]) \r
347       {\r
348         findable = IsFindable(mcEvent,iMc);\r
349         break;\r
350       }\r
351     }  \r
352 \r
353     Bool_t recStatus = kFALSE;\r
354     for(Int_t iRec=0; iRec<multRec; ++iRec) \r
355     {\r
356       // check reconstructed\r
357       if(iMc == labelsRec[iRec]) \r
358       {\r
359         recStatus = kTRUE;\r
360         break;\r
361       }\r
362     }\r
363 \r
364     // Only 5 charged particle species (e,mu,pi,K,p)\r
365     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
366 \r
367     // transform Pdg to Pid\r
368     Int_t pid = TransformToPID(particle);\r
369 \r
370     Float_t mceta =  particle->Eta();\r
371     Float_t mcphi =  particle->Phi();\r
372     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
373     Float_t mcpt = particle->Pt();\r
374     Float_t mcR = particle->R();\r
375 \r
376     // get info about mother\r
377     Int_t motherLabel = particle->GetMother(0);\r
378     if(motherLabel < 0) continue;\r
379     TParticle *mother = stack->Particle(motherLabel);\r
380     if(!mother) continue; \r
381 \r
382     Float_t mother_eta = mother->Eta();\r
383     Float_t mother_phi = mother->Phi();\r
384     if(mother_phi<0) mother_phi += 2.*TMath::Pi();\r
385 \r
386     // Fill histograms\r
387     Double_t vEffSecHisto[9] = { mceta, mcphi, mcpt, pid, recStatus, findable, mcR, mother_phi, mother_eta }; \r
388     fEffSecHisto->Fill(vEffSecHisto);\r
389   }\r
390 \r
391   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
392   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
393 }\r
394 \r
395 \r
396 \r
397 \r
398 //_____________________________________________________________________________\r
399 void AliPerformanceEff::ProcessTPCITS(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
400 {\r
401   // Fill efficiency comparison information\r
402   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
403   if(!labelsRec) \r
404      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
405 \r
406   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
407   if(!labelsAllRec) \r
408      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
409 \r
410   // loop over rec. tracks\r
411   AliESDtrack *track=0;\r
412   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
413   { \r
414     track = esdEvent->GetTrack(iTrack);\r
415     if(!track) continue;\r
416     if(track->Charge()==0) continue;\r
417     Int_t label = TMath::Abs(track->GetLabel()); \r
418     labelsAllRec[iTrack]=label;\r
419 \r
420     // iTPC+ITS\r
421     if(IsRecTPCITS(track) != 0) \r
422       labelsRec[iTrack]=label;\r
423   }\r
424 \r
425   // \r
426   // MC histograms for efficiency studies\r
427   //\r
428   if(!mcEvent) return;\r
429  \r
430   AliStack *stack = mcEvent->Stack();\r
431   if (!stack) {\r
432     AliDebug(AliLog::kError, "Stack not available");\r
433     return;\r
434   }\r
435 \r
436   //Int_t nPart  = stack->GetNtrack();\r
437   Int_t nPart  = stack->GetNprimary();\r
438   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
439   {\r
440     TParticle* particle = stack->Particle(iMc);\r
441     if (!particle) continue;\r
442     if (!particle->GetPDG()) continue; \r
443     if (particle->GetPDG()->Charge() == 0.0) continue;\r
444       \r
445     // physical primary\r
446     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
447     if(!prim) continue;\r
448 \r
449     Bool_t findable = kFALSE;\r
450     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
451     {\r
452       // check findable\r
453       if(iMc == labelsAllRec[iRec]) \r
454       {\r
455         findable = IsFindable(mcEvent,iMc);\r
456         break;\r
457       }\r
458     }  \r
459 \r
460     Bool_t recStatus = kFALSE;\r
461     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
462     {\r
463       // check reconstructed\r
464       if(iMc == labelsRec[iRec]) \r
465       {\r
466         recStatus = kTRUE;\r
467         break;\r
468       }\r
469     }\r
470 \r
471     // Only 5 charged particle species (e,mu,pi,K,p)\r
472     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
473 \r
474     // transform Pdg to Pid\r
475     Int_t pid = TransformToPID(particle);\r
476 \r
477     Float_t mceta =  particle->Eta();\r
478     Float_t mcphi =  particle->Phi();\r
479     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
480     Float_t mcpt = particle->Pt();\r
481 \r
482     // Fill histograms\r
483     Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable}; \r
484     fEffHisto->Fill(vEffHisto);\r
485   }\r
486 \r
487   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
488   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
489 }\r
490 \r
491 //_____________________________________________________________________________\r
492 void AliPerformanceEff::ProcessConstrained(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)\r
493 {\r
494   // Process comparison information \r
495   Int_t *labelsRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
496   if(!labelsRec) \r
497      AliDebug(AliLog::kError, "Cannot create labelsRec");\r
498 \r
499   Int_t *labelsAllRec =  new Int_t[esdEvent->GetNumberOfTracks()];\r
500   if(!labelsAllRec) \r
501      AliDebug(AliLog::kError, "Cannot create labelsAllRec");\r
502 \r
503   // loop over rec. tracks\r
504   AliESDtrack *track=0;\r
505   for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) \r
506   { \r
507     track = esdEvent->GetTrack(iTrack);\r
508     if(!track) continue;\r
509     if(track->Charge()==0) continue;\r
510     Int_t label = TMath::Abs(track->GetLabel()); \r
511     labelsAllRec[iTrack]=label;\r
512 \r
513     // Constrained\r
514     if(IsRecConstrained(track) != 0) \r
515       labelsRec[iTrack]=label;\r
516 \r
517   }\r
518 \r
519   // \r
520   // MC histograms for efficiency studies\r
521   //\r
522   if(!mcEvent) return;\r
523  \r
524   AliStack *stack = mcEvent->Stack();\r
525   if (!stack) {\r
526     AliDebug(AliLog::kError, "Stack not available");\r
527     return;\r
528   }\r
529 \r
530   //Int_t nPart  = stack->GetNtrack();\r
531   Int_t nPart  = stack->GetNprimary();\r
532   for (Int_t iMc = 0; iMc < nPart; ++iMc) \r
533   {\r
534     TParticle* particle = stack->Particle(iMc);\r
535     if (!particle) continue;\r
536     if (!particle->GetPDG()) continue; \r
537     if (particle->GetPDG()->Charge() == 0.0) continue;\r
538       \r
539     // physical primary\r
540     Bool_t prim = stack->IsPhysicalPrimary(iMc);\r
541     if(!prim) continue;\r
542 \r
543     Bool_t findable = kFALSE;\r
544     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
545     {\r
546       // check findable\r
547       if(iMc == labelsAllRec[iRec]) \r
548       {\r
549         findable = IsFindable(mcEvent,iMc);\r
550         break;\r
551       }\r
552     }  \r
553 \r
554     Bool_t recStatus = kFALSE;\r
555     for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec) \r
556     {\r
557       // check reconstructed\r
558       if(iMc == labelsRec[iRec]) \r
559       {\r
560         recStatus = kTRUE;\r
561         break;\r
562       }\r
563     }\r
564 \r
565     // Only 5 charged particle species (e,mu,pi,K,p)\r
566     if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; \r
567 \r
568     // transform Pdg to Pid\r
569     Int_t pid = TransformToPID(particle);\r
570 \r
571     Float_t mceta =  particle->Eta();\r
572     Float_t mcphi =  particle->Phi();\r
573     if(mcphi<0) mcphi += 2.*TMath::Pi();\r
574     Float_t mcpt = particle->Pt();\r
575 \r
576     // Fill histograms\r
577     Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable}; \r
578     fEffHisto->Fill(vEffHisto);\r
579   }\r
580 \r
581   if(labelsRec) delete [] labelsRec; labelsRec = 0;\r
582   if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;\r
583 }\r
584 \r
585 //_____________________________________________________________________________\r
586 void AliPerformanceEff::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend)\r
587 {\r
588   // Process comparison information \r
589   //\r
590   if(!esdEvent) \r
591   {\r
592     Error("Exec","esdEvent not available");\r
593     return;\r
594   }\r
595   AliHeader* header = 0;\r
596   AliGenEventHeader* genHeader = 0;\r
597   AliStack* stack = 0;\r
598   TArrayF vtxMC(3);\r
599   \r
600   if(bUseMC)\r
601   {\r
602     if(!mcEvent) {\r
603       Error("Exec","mcEvent not available");\r
604       return;\r
605     }\r
606     // get MC event header\r
607     header = mcEvent->Header();\r
608     if (!header) {\r
609       Error("Exec","Header not available");\r
610       return;\r
611     }\r
612     // MC particle stack\r
613     stack = mcEvent->Stack();\r
614     if (!stack) {\r
615       Error("Exec","Stack not available");\r
616       return;\r
617     }\r
618     // get MC vertex\r
619     genHeader = header->GenEventHeader();\r
620     if (!genHeader) {\r
621       Error("Exec","Could not retrieve genHeader from Header");\r
622       return;\r
623     }\r
624     genHeader->PrimaryVertex(vtxMC);\r
625   } \r
626   else {\r
627     Error("Exec","MC information required!");\r
628     return;\r
629   } \r
630 \r
631   // use ESD friends\r
632   if(bUseESDfriend) {\r
633     if(!esdFriend) {\r
634       Error("Exec","esdFriend not available");\r
635       return;\r
636     }\r
637   }\r
638 \r
639   //\r
640   //  Process events\r
641   //\r
642   if(GetAnalysisMode() == 0) ProcessTPC(mcEvent,esdEvent);\r
643   else if(GetAnalysisMode() == 1) ProcessTPCITS(mcEvent,esdEvent);\r
644   else if(GetAnalysisMode() == 2) ProcessConstrained(mcEvent,esdEvent);\r
645   else if(GetAnalysisMode() == 5) ProcessTPCSec(mcEvent,esdEvent);\r
646   else {\r
647     printf("ERROR: AnalysisMode %d \n",fAnalysisMode);\r
648     return;\r
649   }\r
650 }\r
651 \r
652 //_____________________________________________________________________________\r
653 Int_t AliPerformanceEff::TransformToPID(TParticle *particle) \r
654 {\r
655 // transform Pdg to Pid\r
656 // Pdg convension is different for hadrons and leptons \r
657 // (e.g. K+/K- = 321/-321; e+/e- = -11/11 ) \r
658 \r
659   Int_t pid = -1;\r
660   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetEM() ) pid = 0; \r
661   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetMuM() ) pid = 1; \r
662   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetPiP() ) pid = 2; \r
663   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetKP() ) pid = 3; \r
664   if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetProt() ) pid = 4; \r
665 \r
666 return pid;\r
667 }\r
668 \r
669 //_____________________________________________________________________________\r
670 Bool_t AliPerformanceEff::IsFindable(const AliMCEvent *mcEvent, Int_t label) \r
671 {\r
672 //\r
673 // Findfindable tracks\r
674 //\r
675 if(!mcEvent) return kFALSE;\r
676 \r
677   AliMCParticle *mcParticle = (AliMCParticle*) mcEvent->GetTrack(label);\r
678   if(!mcParticle) return kFALSE;\r
679 \r
680   Int_t counter; \r
681   Float_t tpcTrackLength = mcParticle->GetTPCTrackLength(AliTracker::GetBz(),0.05,counter,3.0); \r
682   //printf("tpcTrackLength %f \n", tpcTrackLength);\r
683 \r
684 return (tpcTrackLength>fCutsMC->GetMinTrackLength());    \r
685 }\r
686 \r
687 //_____________________________________________________________________________\r
688 Bool_t AliPerformanceEff::IsRecTPC(AliESDtrack *esdTrack) \r
689 {\r
690 //\r
691 // Check whether track is reconstructed in TPC\r
692 //\r
693 if(!esdTrack) return kFALSE;\r
694 \r
695   const AliExternalTrackParam *track = esdTrack->GetTPCInnerParam();\r
696   if(!track) return kFALSE;\r
697 \r
698   Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
699   esdTrack->GetImpactParametersTPC(dca,cov);\r
700 \r
701   Bool_t recStatus = kFALSE;\r
702   if(esdTrack->GetTPCNcls()>fCutsRC->GetMinNClustersTPC()) recStatus = kTRUE; \r
703 \r
704   /*\r
705   if( TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && \r
706       TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
707   {\r
708     recStatus = kTRUE;\r
709   }\r
710   */\r
711 \r
712 return recStatus;\r
713 }\r
714 \r
715 //_____________________________________________________________________________\r
716 Bool_t AliPerformanceEff::IsRecTPCITS(AliESDtrack *esdTrack) \r
717 {\r
718 //\r
719 // Check whether track is reconstructed in TPCITS\r
720 //\r
721 if(!esdTrack) return kFALSE;\r
722 \r
723   Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
724   esdTrack->GetImpactParameters(dca,cov);\r
725 \r
726   Bool_t recStatus = kFALSE;\r
727 \r
728   if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit\r
729   if (esdTrack->GetTPCNcls()<fCutsRC->GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters\r
730   //if ((esdTrack->GetStatus()&AliESDtrack::kITSrefit)==0) return kFALSE; // ITS refit\r
731   //Int_t clusterITS[200];\r
732   //if(esdTrack->GetITSclusters(clusterITS)<fCutsRC->GetMinNClustersITS()) return kFALSE;  // min. nb. ITS clusters\r
733 \r
734   recStatus = kTRUE;\r
735   /*\r
736   if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && \r
737      TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
738   {\r
739     recStatus = kTRUE;\r
740   }\r
741   */\r
742 \r
743 return recStatus;\r
744 }\r
745 \r
746 //_____________________________________________________________________________\r
747 Bool_t AliPerformanceEff::IsRecConstrained(AliESDtrack *esdTrack) \r
748 {\r
749 //\r
750 // Check whether track is reconstructed in IsRecConstrained\r
751 //\r
752   if(!esdTrack) return kFALSE;\r
753 \r
754   const AliExternalTrackParam * track = esdTrack->GetConstrainedParam();\r
755   if(!track) return kFALSE;\r
756 \r
757   Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z\r
758   esdTrack->GetImpactParameters(dca,cov);\r
759   //Int_t label = TMath::Abs(esdTrack->GetLabel()); \r
760 \r
761   Bool_t recStatus = kFALSE;\r
762 \r
763   if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit\r
764   if (esdTrack->GetTPCNcls()<fCutsRC->GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters\r
765   Int_t clusterITS[200];\r
766   if(esdTrack->GetITSclusters(clusterITS)<fCutsRC->GetMinNClustersITS()) return kFALSE;  // min. nb. ITS clusters\r
767 \r
768   recStatus = kTRUE;\r
769 \r
770   /*\r
771   if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() && \r
772      TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())\r
773   {\r
774     recStatus = kTRUE;\r
775   }\r
776   */\r
777 \r
778 return recStatus;\r
779 }\r
780 \r
781 //_____________________________________________________________________________\r
782 Long64_t AliPerformanceEff::Merge(TCollection* const list) \r
783 {\r
784   // Merge list of objects (needed by PROOF)\r
785 \r
786   if (!list)\r
787   return 0;\r
788 \r
789   if (list->IsEmpty())\r
790   return 1;\r
791 \r
792   TIterator* iter = list->MakeIterator();\r
793   TObject* obj = 0;\r
794 \r
795   // collection of generated histograms\r
796 \r
797   Int_t count=0;\r
798   while((obj = iter->Next()) != 0) \r
799   {\r
800     AliPerformanceEff* entry = dynamic_cast<AliPerformanceEff*>(obj);\r
801     if (entry == 0) continue; \r
802   \r
803      fEffHisto->Add(entry->fEffHisto);\r
804      fEffSecHisto->Add(entry->fEffSecHisto);\r
805   count++;\r
806   }\r
807 \r
808 return count;\r
809 }\r
810  \r
811 //_____________________________________________________________________________\r
812 void AliPerformanceEff::Analyse() \r
813 {\r
814   // Analyse comparison information and store output histograms\r
815   // in the folder "folderEff" \r
816   //\r
817   TH1::AddDirectory(kFALSE);\r
818   TObjArray *aFolderObj = new TObjArray;\r
819   char title[256];\r
820 \r
821   //\r
822   // efficiency vs pt\r
823   //\r
824 \r
825   if(GetAnalysisMode() != 5) {\r
826 \r
827   fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range\r
828   fEffHisto->GetAxis(2)->SetRangeUser(0.1,10.); // pt range\r
829 \r
830   // rec efficiency vs pt\r
831   TH1D *ptAll = fEffHisto->Projection(2);\r
832 \r
833   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
834   TH1D *ptRec = fEffHisto->Projection(2);\r
835   TH1D *ptRecc = (TH1D*)ptRec->Clone();\r
836   ptRecc->Divide(ptRec,ptAll,1,1,"B");\r
837   ptRecc->SetName("ptRecEff");\r
838 \r
839   ptRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
840   ptRecc->GetYaxis()->SetTitle("efficiency");\r
841   sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(2)->GetTitle());\r
842   ptRecc->SetTitle(title);\r
843 \r
844   ptRecc->SetBit(TH1::kLogX);\r
845   aFolderObj->Add(ptRecc);\r
846 \r
847   // rec efficiency vs pid vs pt\r
848 \r
849   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
850   fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
851 \r
852   TH1D *ptAllPi = fEffHisto->Projection(2);\r
853 \r
854   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
855   TH1D *ptRecPi = fEffHisto->Projection(2);\r
856   TH1D *ptRecPic = (TH1D*)ptRecPi->Clone();\r
857   ptRecPic->Divide(ptRecPi,ptAllPi,1,1,"B");\r
858   ptRecPic->SetName("ptRecEffPi");\r
859 \r
860   ptRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
861   ptRecPic->GetYaxis()->SetTitle("efficiency");\r
862   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(2)->GetTitle());\r
863   ptRecPic->SetTitle(title);\r
864 \r
865   ptRecPic->SetBit(TH1::kLogX);\r
866   aFolderObj->Add(ptRecPic);\r
867 \r
868   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
869   fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
870   TH1D *ptAllK = fEffHisto->Projection(2);\r
871 \r
872   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
873   TH1D *ptRecK = fEffHisto->Projection(2);\r
874 \r
875   TH1D *ptRecKc = (TH1D*)ptRecK->Clone();\r
876   ptRecKc->Divide(ptRecK,ptAllK,1,1,"B");\r
877   ptRecKc->SetName("ptRecEffK");\r
878 \r
879   ptRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
880   ptRecKc->GetYaxis()->SetTitle("efficiency");\r
881   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(2)->GetTitle());\r
882   ptRecKc->SetTitle(title);\r
883 \r
884 \r
885   ptRecKc->SetBit(TH1::kLogX);\r
886   aFolderObj->Add(ptRecKc);\r
887 \r
888   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
889   fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
890   TH1D *ptAllP = fEffHisto->Projection(2);\r
891 \r
892   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
893   TH1D *ptRecP = fEffHisto->Projection(2);\r
894   TH1D *ptRecPc = (TH1D*)ptRecP->Clone();\r
895   ptRecPc->Divide(ptRecP,ptAllP,1,1,"B");\r
896   ptRecPc->SetName("ptRecEffP");\r
897 \r
898   ptRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
899   ptRecPc->GetYaxis()->SetTitle("efficiency");\r
900   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(2)->GetTitle());\r
901   ptRecPc->SetTitle(title);\r
902 \r
903   ptRecPc->SetBit(TH1::kLogX);\r
904   aFolderObj->Add(ptRecPc);\r
905 \r
906   // findable efficiency vs pt\r
907 \r
908   fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
909   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
910   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
911   TH1D *ptAllF = fEffHisto->Projection(2);\r
912 \r
913   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
914   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
915 \r
916   TH1D *ptRecF = fEffHisto->Projection(2); // rec findable\r
917   TH1D *ptRecFc = (TH1D*)ptRecF->Clone();\r
918   ptRecFc->Divide(ptRecF,ptAllF,1,1,"B");\r
919   ptRecFc->SetName("ptRecEffF");\r
920 \r
921   ptRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());\r
922   ptRecFc->GetYaxis()->SetTitle("efficiency");\r
923   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(2)->GetTitle());\r
924   ptRecFc->SetTitle(title);\r
925 \r
926   ptRecFc->SetBit(TH1::kLogX);\r
927   aFolderObj->Add(ptRecFc);\r
928 \r
929   //\r
930   // efficiency vs eta\r
931   //\r
932 \r
933   fEffHisto->GetAxis(0)->SetRangeUser(-1.5,1.5); // eta range\r
934   fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range\r
935   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
936   fEffHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
937 \r
938   TH1D *etaAll = fEffHisto->Projection(0);\r
939 \r
940   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
941   TH1D *etaRec = fEffHisto->Projection(0);\r
942   TH1D *etaRecc = (TH1D*)etaRec->Clone();\r
943   etaRecc->Divide(etaRec,etaAll,1,1,"B");\r
944   etaRecc->SetName("etaRecEff");\r
945 \r
946   etaRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
947   etaRecc->GetYaxis()->SetTitle("efficiency");\r
948   sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(0)->GetTitle());\r
949   etaRecc->SetTitle(title);\r
950 \r
951   aFolderObj->Add(etaRecc);\r
952 \r
953   // rec efficiency vs pid vs eta\r
954   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
955   fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
956 \r
957   TH1D *etaAllPi = fEffHisto->Projection(0);\r
958 \r
959   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
960   TH1D *etaRecPi = fEffHisto->Projection(0);\r
961   TH1D *etaRecPic = (TH1D*)etaRecPi->Clone();\r
962   etaRecPic->Divide(etaRecPi,etaAllPi,1,1,"B");\r
963   etaRecPic->SetName("etaRecEffPi");\r
964 \r
965   etaRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
966   etaRecPic->GetYaxis()->SetTitle("efficiency");\r
967   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(0)->GetTitle());\r
968   etaRecPic->SetTitle(title);\r
969 \r
970   aFolderObj->Add(etaRecPic);\r
971 \r
972   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
973   fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
974   TH1D *etaAllK = fEffHisto->Projection(0);\r
975 \r
976   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
977   TH1D *etaRecK = fEffHisto->Projection(0);\r
978 \r
979   TH1D *etaRecKc = (TH1D*)etaRecK->Clone();\r
980   etaRecKc->Divide(etaRecK,etaAllK,1,1,"B");\r
981   etaRecKc->SetName("etaRecEffK");\r
982 \r
983   etaRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
984   etaRecKc->GetYaxis()->SetTitle("efficiency");\r
985   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(0)->GetTitle());\r
986   etaRecKc->SetTitle(title);\r
987 \r
988 \r
989   aFolderObj->Add(etaRecKc);\r
990 \r
991   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
992   fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
993   TH1D *etaAllP = fEffHisto->Projection(0);\r
994 \r
995   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
996   TH1D *etaRecP = fEffHisto->Projection(0);\r
997   TH1D *etaRecPc = (TH1D*)etaRecP->Clone();\r
998   etaRecPc->Divide(etaRecP,etaAllP,1,1,"B");\r
999   etaRecPc->SetName("etaRecEffP");\r
1000 \r
1001   etaRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
1002   etaRecPc->GetYaxis()->SetTitle("efficiency");\r
1003   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(0)->GetTitle());\r
1004   etaRecPc->SetTitle(title);\r
1005 \r
1006   aFolderObj->Add(etaRecPc);\r
1007 \r
1008   // findable efficiency vs eta\r
1009 \r
1010   fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1011   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1012   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1013   TH1D *etaAllF = fEffHisto->Projection(0);\r
1014 \r
1015   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1016   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1017 \r
1018   TH1D *etaRecF = fEffHisto->Projection(0); // rec findable\r
1019   TH1D *etaRecFc = (TH1D*)etaRecF->Clone();\r
1020   etaRecFc->Divide(etaRecF,etaAllF,1,1,"B");\r
1021   etaRecFc->SetName("etaRecEffF");\r
1022 \r
1023   etaRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());\r
1024   etaRecFc->GetYaxis()->SetTitle("efficiency");\r
1025   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(0)->GetTitle());\r
1026   etaRecFc->SetTitle(title);\r
1027 \r
1028   aFolderObj->Add(etaRecFc);\r
1029 \r
1030   //\r
1031   // efficiency vs phi\r
1032   //\r
1033 \r
1034   fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range\r
1035   fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range\r
1036   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
1037   fEffHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
1038 \r
1039   TH1D *phiAll = fEffHisto->Projection(1);\r
1040 \r
1041   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1042   TH1D *phiRec = fEffHisto->Projection(1);\r
1043   TH1D *phiRecc = (TH1D*)phiRec->Clone();\r
1044   phiRecc->Divide(phiRec,phiAll,1,1,"B");\r
1045   phiRecc->SetName("phiRecEff");\r
1046 \r
1047   phiRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1048   phiRecc->GetYaxis()->SetTitle("efficiency");\r
1049   sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(1)->GetTitle());\r
1050   phiRecc->SetTitle(title);\r
1051 \r
1052   aFolderObj->Add(phiRecc);\r
1053 \r
1054   // rec efficiency vs pid vs phi\r
1055   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1056   fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1057 \r
1058   TH1D *phiAllPi = fEffHisto->Projection(1);\r
1059 \r
1060   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1061   TH1D *phiRecPi = fEffHisto->Projection(1);\r
1062   TH1D *phiRecPic = (TH1D*)phiRecPi->Clone();\r
1063   phiRecPic->Divide(phiRecPi,phiAllPi,1,1,"B");\r
1064   phiRecPic->SetName("phiRecEffPi");\r
1065 \r
1066   phiRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1067   phiRecPic->GetYaxis()->SetTitle("efficiency");\r
1068   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(1)->GetTitle());\r
1069   phiRecPic->SetTitle(title);\r
1070 \r
1071   aFolderObj->Add(phiRecPic);\r
1072 \r
1073   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1074   fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1075   TH1D *phiAllK = fEffHisto->Projection(1);\r
1076 \r
1077   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1078   TH1D *phiRecK = fEffHisto->Projection(1);\r
1079 \r
1080   TH1D *phiRecKc = (TH1D*)phiRecK->Clone();\r
1081   phiRecKc->Divide(phiRecK,phiAllK,1,1,"B");\r
1082   phiRecKc->SetName("phiRecEffK");\r
1083 \r
1084   phiRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1085   phiRecKc->GetYaxis()->SetTitle("efficiency");\r
1086   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(1)->GetTitle());\r
1087   phiRecKc->SetTitle(title);\r
1088 \r
1089 \r
1090   aFolderObj->Add(phiRecKc);\r
1091 \r
1092   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1093   fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1094   TH1D *phiAllP = fEffHisto->Projection(1);\r
1095 \r
1096   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1097   TH1D *phiRecP = fEffHisto->Projection(1);\r
1098   TH1D *phiRecPc = (TH1D*)phiRecP->Clone();\r
1099   phiRecPc->Divide(phiRecP,phiAllP,1,1,"B");\r
1100   phiRecPc->SetName("phiRecEffP");\r
1101 \r
1102   phiRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1103   phiRecPc->GetYaxis()->SetTitle("efficiency");\r
1104   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(1)->GetTitle());\r
1105   phiRecPc->SetTitle(title);\r
1106 \r
1107   aFolderObj->Add(phiRecPc);\r
1108 \r
1109   // findable efficiency vs phi\r
1110 \r
1111   fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1112   fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1113   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1114   TH1D *phiAllF = fEffHisto->Projection(1);\r
1115 \r
1116   fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1117   fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1118 \r
1119   TH1D *phiRecF = fEffHisto->Projection(1); // rec findable\r
1120   TH1D *phiRecFc = (TH1D*)phiRecF->Clone();\r
1121   phiRecFc->Divide(phiRecF,phiAllF,1,1,"B");\r
1122   phiRecFc->SetName("phiRecEffF");\r
1123 \r
1124   phiRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());\r
1125   phiRecFc->GetYaxis()->SetTitle("efficiency");\r
1126   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(1)->GetTitle());\r
1127   phiRecFc->SetTitle(title);\r
1128 \r
1129   aFolderObj->Add(phiRecFc);\r
1130   }\r
1131   else {\r
1132   // \r
1133   Float_t minEta=-1.5, maxEta=1.5;\r
1134   Float_t minR=0.0, maxR=150.0;\r
1135   Float_t minPt=0.15, maxPt=100.0;\r
1136 \r
1137   // mother eta range\r
1138   fEffSecHisto->GetAxis(8)->SetRangeUser(minEta,maxEta);\r
1139 \r
1140   // particle creation radius range \r
1141   fEffSecHisto->GetAxis(6)->SetRangeUser(minR,maxR);\r
1142 \r
1143   //\r
1144   fEffSecHisto->GetAxis(0)->SetRangeUser(minEta,maxEta);\r
1145   fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt);\r
1146 \r
1147   // rec efficiency vs pt\r
1148   TH1D *ptAll = fEffSecHisto->Projection(2);\r
1149 \r
1150   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1151   TH1D *ptRec = fEffSecHisto->Projection(2);\r
1152   TH1D *ptRecc = (TH1D*)ptRec->Clone();\r
1153   ptRecc->Divide(ptRec,ptAll,1,1,"B");\r
1154   ptRecc->SetName("ptRecEff");\r
1155 \r
1156   ptRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1157   ptRecc->GetYaxis()->SetTitle("efficiency");\r
1158   sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(2)->GetTitle());\r
1159   ptRecc->SetTitle(title);\r
1160 \r
1161   ptRecc->SetBit(TH1::kLogX);\r
1162   aFolderObj->Add(ptRecc);\r
1163 \r
1164   // rec efficiency vs pid vs pt\r
1165   \r
1166   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1167   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,0.); // electrons\r
1168 \r
1169   TH1D *ptAllEle = fEffSecHisto->Projection(2);\r
1170 \r
1171   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1172   TH1D *ptRecEle = fEffSecHisto->Projection(2);\r
1173   TH1D *ptRecElec = (TH1D*)ptRecEle->Clone();\r
1174   ptRecElec->Divide(ptRecEle,ptAllEle,1,1,"B");\r
1175   ptRecElec->SetName("ptRecEffEle");\r
1176 \r
1177   ptRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1178   ptRecElec->GetYaxis()->SetTitle("efficiency");\r
1179   sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1180   ptRecElec->SetTitle(title);\r
1181 \r
1182   ptRecElec->SetBit(TH1::kLogX);\r
1183   aFolderObj->Add(ptRecElec);\r
1184 \r
1185   //\r
1186 \r
1187   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1188   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1189 \r
1190   TH1D *ptAllPi = fEffSecHisto->Projection(2);\r
1191 \r
1192   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1193   TH1D *ptRecPi = fEffSecHisto->Projection(2);\r
1194   TH1D *ptRecPic = (TH1D*)ptRecPi->Clone();\r
1195   ptRecPic->Divide(ptRecPi,ptAllPi,1,1,"B");\r
1196   ptRecPic->SetName("ptRecEffPi");\r
1197 \r
1198   ptRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1199   ptRecPic->GetYaxis()->SetTitle("efficiency");\r
1200   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1201   ptRecPic->SetTitle(title);\r
1202 \r
1203   ptRecPic->SetBit(TH1::kLogX);\r
1204   aFolderObj->Add(ptRecPic);\r
1205 \r
1206   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1207   fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1208   TH1D *ptAllK = fEffSecHisto->Projection(2);\r
1209 \r
1210   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1211   TH1D *ptRecK = fEffSecHisto->Projection(2);\r
1212 \r
1213   TH1D *ptRecKc = (TH1D*)ptRecK->Clone();\r
1214   ptRecKc->Divide(ptRecK,ptAllK,1,1,"B");\r
1215   ptRecKc->SetName("ptRecEffK");\r
1216 \r
1217   ptRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1218   ptRecKc->GetYaxis()->SetTitle("efficiency");\r
1219   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1220   ptRecKc->SetTitle(title);\r
1221 \r
1222 \r
1223   ptRecKc->SetBit(TH1::kLogX);\r
1224   aFolderObj->Add(ptRecKc);\r
1225 \r
1226   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1227   fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1228   TH1D *ptAllP = fEffSecHisto->Projection(2);\r
1229 \r
1230   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1231   TH1D *ptRecP = fEffSecHisto->Projection(2);\r
1232   TH1D *ptRecPc = (TH1D*)ptRecP->Clone();\r
1233   ptRecPc->Divide(ptRecP,ptAllP,1,1,"B");\r
1234   ptRecPc->SetName("ptRecEffP");\r
1235 \r
1236   ptRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1237   ptRecPc->GetYaxis()->SetTitle("efficiency");\r
1238   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1239   ptRecPc->SetTitle(title);\r
1240 \r
1241   ptRecPc->SetBit(TH1::kLogX);\r
1242   aFolderObj->Add(ptRecPc);\r
1243 \r
1244   // findable efficiency vs pt\r
1245 \r
1246   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1247   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1248   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1249   TH1D *ptAllF = fEffSecHisto->Projection(2);\r
1250 \r
1251   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1252   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1253 \r
1254   TH1D *ptRecF = fEffSecHisto->Projection(2); // rec findable\r
1255   TH1D *ptRecFc = (TH1D*)ptRecF->Clone();\r
1256   ptRecFc->Divide(ptRecF,ptAllF,1,1,"B");\r
1257   ptRecFc->SetName("ptRecEffF");\r
1258 \r
1259   ptRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle());\r
1260   ptRecFc->GetYaxis()->SetTitle("efficiency");\r
1261   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(2)->GetTitle());\r
1262   ptRecFc->SetTitle(title);\r
1263 \r
1264   ptRecFc->SetBit(TH1::kLogX);\r
1265   aFolderObj->Add(ptRecFc);\r
1266 \r
1267   //\r
1268   // efficiency vs eta\r
1269   //\r
1270   fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt);\r
1271   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
1272   fEffSecHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
1273 \r
1274   TH1D *etaAll = fEffSecHisto->Projection(0);\r
1275 \r
1276   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1277   TH1D *etaRec = fEffSecHisto->Projection(0);\r
1278   TH1D *etaRecc = (TH1D*)etaRec->Clone();\r
1279   etaRecc->Divide(etaRec,etaAll,1,1,"B");\r
1280   etaRecc->SetName("etaRecEff");\r
1281 \r
1282   etaRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1283   etaRecc->GetYaxis()->SetTitle("efficiency");\r
1284   sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(0)->GetTitle());\r
1285   etaRecc->SetTitle(title);\r
1286 \r
1287   aFolderObj->Add(etaRecc);\r
1288 \r
1289   // rec efficiency vs pid vs eta\r
1290   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1291   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,0.); // electrons\r
1292 \r
1293   TH1D *etaAllEle = fEffSecHisto->Projection(0);\r
1294 \r
1295   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1296   TH1D *etaRecEle = fEffSecHisto->Projection(0);\r
1297   TH1D *etaRecElec = (TH1D*)etaRecEle->Clone();\r
1298   etaRecElec->Divide(etaRecEle,etaAllEle,1,1,"B");\r
1299   etaRecElec->SetName("etaRecEffEle");\r
1300 \r
1301   etaRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1302   etaRecElec->GetYaxis()->SetTitle("efficiency");\r
1303   sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1304   etaRecElec->SetTitle(title);\r
1305 \r
1306   aFolderObj->Add(etaRecElec);\r
1307 \r
1308   //\r
1309   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1310   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1311 \r
1312   TH1D *etaAllPi = fEffSecHisto->Projection(0);\r
1313 \r
1314   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1315   TH1D *etaRecPi = fEffSecHisto->Projection(0);\r
1316   TH1D *etaRecPic = (TH1D*)etaRecPi->Clone();\r
1317   etaRecPic->Divide(etaRecPi,etaAllPi,1,1,"B");\r
1318   etaRecPic->SetName("etaRecEffPi");\r
1319 \r
1320   etaRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1321   etaRecPic->GetYaxis()->SetTitle("efficiency");\r
1322   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1323   etaRecPic->SetTitle(title);\r
1324 \r
1325   aFolderObj->Add(etaRecPic);\r
1326 \r
1327   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1328   fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1329   TH1D *etaAllK = fEffSecHisto->Projection(0);\r
1330 \r
1331   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1332   TH1D *etaRecK = fEffSecHisto->Projection(0);\r
1333 \r
1334   TH1D *etaRecKc = (TH1D*)etaRecK->Clone();\r
1335   etaRecKc->Divide(etaRecK,etaAllK,1,1,"B");\r
1336   etaRecKc->SetName("etaRecEffK");\r
1337 \r
1338   etaRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1339   etaRecKc->GetYaxis()->SetTitle("efficiency");\r
1340   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1341   etaRecKc->SetTitle(title);\r
1342 \r
1343 \r
1344   aFolderObj->Add(etaRecKc);\r
1345 \r
1346   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1347   fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1348   TH1D *etaAllP = fEffSecHisto->Projection(0);\r
1349 \r
1350   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1351   TH1D *etaRecP = fEffSecHisto->Projection(0);\r
1352   TH1D *etaRecPc = (TH1D*)etaRecP->Clone();\r
1353   etaRecPc->Divide(etaRecP,etaAllP,1,1,"B");\r
1354   etaRecPc->SetName("etaRecEffP");\r
1355 \r
1356   etaRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1357   etaRecPc->GetYaxis()->SetTitle("efficiency");\r
1358   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1359   etaRecPc->SetTitle(title);\r
1360 \r
1361   aFolderObj->Add(etaRecPc);\r
1362 \r
1363   // findable efficiency vs eta\r
1364 \r
1365   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1366   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1367   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1368   TH1D *etaAllF = fEffSecHisto->Projection(0);\r
1369 \r
1370   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1371   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1372 \r
1373   TH1D *etaRecF = fEffSecHisto->Projection(0); // rec findable\r
1374   TH1D *etaRecFc = (TH1D*)etaRecF->Clone();\r
1375   etaRecFc->Divide(etaRecF,etaAllF,1,1,"B");\r
1376   etaRecFc->SetName("etaRecEffF");\r
1377 \r
1378   etaRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle());\r
1379   etaRecFc->GetYaxis()->SetTitle("efficiency");\r
1380   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(0)->GetTitle());\r
1381   etaRecFc->SetTitle(title);\r
1382 \r
1383   aFolderObj->Add(etaRecFc);\r
1384 \r
1385   //\r
1386   // efficiency vs phi\r
1387   //\r
1388 \r
1389   fEffSecHisto->GetAxis(0)->SetRangeUser(minEta,maxEta);\r
1390   fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt);\r
1391 \r
1392   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.);   // all\r
1393   fEffSecHisto->GetAxis(5)->SetRangeUser(0.,1.);   // all\r
1394 \r
1395   TH1D *phiAll = fEffSecHisto->Projection(1);\r
1396 \r
1397   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);  // reconstructed \r
1398   TH1D *phiRec = fEffSecHisto->Projection(1);\r
1399   TH1D *phiRecc = (TH1D*)phiRec->Clone();\r
1400   phiRecc->Divide(phiRec,phiAll,1,1,"B");\r
1401   phiRecc->SetName("phiRecEff");\r
1402 \r
1403   phiRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1404   phiRecc->GetYaxis()->SetTitle("efficiency");\r
1405   sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(1)->GetTitle());\r
1406   phiRecc->SetTitle(title);\r
1407 \r
1408   aFolderObj->Add(phiRecc);\r
1409 \r
1410   // rec efficiency vs pid vs phi\r
1411   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1412   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1413 \r
1414   TH1D *phiAllEle = fEffSecHisto->Projection(1);\r
1415 \r
1416   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1417   TH1D *phiRecEle = fEffSecHisto->Projection(1);\r
1418   TH1D *phiRecElec = (TH1D*)phiRecEle->Clone();\r
1419   phiRecElec->Divide(phiRecEle,phiAllEle,1,1,"B");\r
1420   phiRecElec->SetName("phiRecEffEle");\r
1421 \r
1422   phiRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1423   phiRecElec->GetYaxis()->SetTitle("efficiency");\r
1424   sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1425   phiRecElec->SetTitle(title);\r
1426 \r
1427   aFolderObj->Add(phiRecElec);\r
1428 \r
1429   //\r
1430   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1431   fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions\r
1432 \r
1433   TH1D *phiAllPi = fEffSecHisto->Projection(1);\r
1434 \r
1435   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1436   TH1D *phiRecPi = fEffSecHisto->Projection(1);\r
1437   TH1D *phiRecPic = (TH1D*)phiRecPi->Clone();\r
1438   phiRecPic->Divide(phiRecPi,phiAllPi,1,1,"B");\r
1439   phiRecPic->SetName("phiRecEffPi");\r
1440 \r
1441   phiRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1442   phiRecPic->GetYaxis()->SetTitle("efficiency");\r
1443   sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1444   phiRecPic->SetTitle(title);\r
1445 \r
1446   aFolderObj->Add(phiRecPic);\r
1447 \r
1448   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1449   fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons\r
1450   TH1D *phiAllK = fEffSecHisto->Projection(1);\r
1451 \r
1452   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1453   TH1D *phiRecK = fEffSecHisto->Projection(1);\r
1454 \r
1455   TH1D *phiRecKc = (TH1D*)phiRecK->Clone();\r
1456   phiRecKc->Divide(phiRecK,phiAllK,1,1,"B");\r
1457   phiRecKc->SetName("phiRecEffK");\r
1458 \r
1459   phiRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1460   phiRecKc->GetYaxis()->SetTitle("efficiency");\r
1461   sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1462   phiRecKc->SetTitle(title);\r
1463 \r
1464 \r
1465   aFolderObj->Add(phiRecKc);\r
1466 \r
1467   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1468   fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons\r
1469   TH1D *phiAllP = fEffSecHisto->Projection(1);\r
1470 \r
1471   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed\r
1472   TH1D *phiRecP = fEffSecHisto->Projection(1);\r
1473   TH1D *phiRecPc = (TH1D*)phiRecP->Clone();\r
1474   phiRecPc->Divide(phiRecP,phiAllP,1,1,"B");\r
1475   phiRecPc->SetName("phiRecEffP");\r
1476 \r
1477   phiRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1478   phiRecPc->GetYaxis()->SetTitle("efficiency");\r
1479   sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1480   phiRecPc->SetTitle(title);\r
1481 \r
1482   aFolderObj->Add(phiRecPc);\r
1483 \r
1484   // findable efficiency vs phi\r
1485 \r
1486   fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); \r
1487   fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); \r
1488   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable\r
1489   TH1D *phiAllF = fEffSecHisto->Projection(1);\r
1490 \r
1491   fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.);\r
1492   fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.);\r
1493 \r
1494   TH1D *phiRecF = fEffSecHisto->Projection(1); // rec findable\r
1495   TH1D *phiRecFc = (TH1D*)phiRecF->Clone();\r
1496   phiRecFc->Divide(phiRecF,phiAllF,1,1,"B");\r
1497   phiRecFc->SetName("phiRecEffF");\r
1498 \r
1499   phiRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle());\r
1500   phiRecFc->GetYaxis()->SetTitle("efficiency");\r
1501   sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(1)->GetTitle());\r
1502   phiRecFc->SetTitle(title);\r
1503 \r
1504   aFolderObj->Add(phiRecFc);\r
1505   }\r
1506 \r
1507   // export objects to analysis folder\r
1508   fAnalysisFolder = ExportToFolder(aFolderObj);\r
1509 \r
1510   // delete only TObjArray\r
1511   if(aFolderObj) delete aFolderObj;\r
1512 }\r
1513 \r
1514 //_____________________________________________________________________________\r
1515 TFolder* AliPerformanceEff::ExportToFolder(TObjArray * array) \r
1516 {\r
1517   // recreate folder avery time and export objects to new one\r
1518   //\r
1519   AliPerformanceEff * comp=this;\r
1520   TFolder *folder = comp->GetAnalysisFolder();\r
1521 \r
1522   TString name, title;\r
1523   TFolder *newFolder = 0;\r
1524   Int_t i = 0;\r
1525   Int_t size = array->GetSize();\r
1526 \r
1527   if(folder) { \r
1528      // get name and title from old folder\r
1529      name = folder->GetName();  \r
1530      title = folder->GetTitle();  \r
1531 \r
1532          // delete old one\r
1533      delete folder;\r
1534 \r
1535          // create new one\r
1536      newFolder = CreateFolder(name.Data(),title.Data());\r
1537      newFolder->SetOwner();\r
1538 \r
1539          // add objects to folder\r
1540      while(i < size) {\r
1541            newFolder->Add(array->At(i));\r
1542            i++;\r
1543          }\r
1544   }\r
1545 \r
1546 return newFolder;\r
1547 }\r
1548 \r
1549 \r
1550 //_____________________________________________________________________________\r
1551 TFolder* AliPerformanceEff::CreateFolder(TString name,TString title) { \r
1552 // create folder for analysed histograms\r
1553 //\r
1554 TFolder *folder = 0;\r
1555   folder = new TFolder(name.Data(),title.Data());\r
1556 \r
1557   return folder;\r
1558 }\r