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