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