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