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