]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG1/TPC/AliPerformanceEff.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bug fix and small changed in the macros
[u/mrichter/AliRoot.git] / PWG1 / TPC / AliPerformanceEff.cxx
CommitLineData
7cc34f08 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
55using namespace std;\r
56\r
57ClassImp(AliPerformanceEff)\r
58\r
59//_____________________________________________________________________________\r
60AliPerformanceEff::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
79AliPerformanceEff::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
103AliPerformanceEff::~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
113void 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
e6a60a90 141 Int_t binsEffHisto[6]={30,144,nPtBins,5,2,2};\r
7cc34f08 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
186void 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
ff7b6e14 229 if (!particle->GetPDG()) continue; \r
7cc34f08 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
280void 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
ff7b6e14 327 if (!particle->GetPDG()) continue; \r
7cc34f08 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
399void 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
ff7b6e14 442 if (!particle->GetPDG()) continue; \r
7cc34f08 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
492void 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
ff7b6e14 536 if (!particle->GetPDG()) continue; \r
7cc34f08 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
586void 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
653Int_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
666return pid;\r
667}\r
668\r
669//_____________________________________________________________________________\r
670Bool_t AliPerformanceEff::IsFindable(const AliMCEvent *mcEvent, Int_t label) \r
671{\r
672//\r
673// Findfindable tracks\r
674//\r
675if(!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
684return (tpcTrackLength>fCutsMC->GetMinTrackLength()); \r
685}\r
686\r
687//_____________________________________________________________________________\r
688Bool_t AliPerformanceEff::IsRecTPC(AliESDtrack *esdTrack) \r
689{\r
690//\r
691// Check whether track is reconstructed in TPC\r
692//\r
693if(!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
712return recStatus;\r
713}\r
714\r
715//_____________________________________________________________________________\r
716Bool_t AliPerformanceEff::IsRecTPCITS(AliESDtrack *esdTrack) \r
717{\r
718//\r
719// Check whether track is reconstructed in TPCITS\r
720//\r
721if(!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
743return recStatus;\r
744}\r
745\r
746//_____________________________________________________________________________\r
747Bool_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
778return recStatus;\r
779}\r
780\r
781//_____________________________________________________________________________\r
782Long64_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
808return count;\r
809}\r
810 \r
811//_____________________________________________________________________________\r
812void 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
1515TFolder* 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
1546return newFolder;\r
1547}\r
1548\r
1549\r
1550//_____________________________________________________________________________\r
1551TFolder* AliPerformanceEff::CreateFolder(TString name,TString title) { \r
1552// create folder for analysed histograms\r
1553//\r
1554TFolder *folder = 0;\r
1555 folder = new TFolder(name.Data(),title.Data());\r
1556\r
1557 return folder;\r
1558}\r