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
10 // Author: J.Otwinowski 04/02/2008
\r
11 //------------------------------------------------------------------------------
\r
15 // after running comparison task, read the file, and get component
\r
16 gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
\r
18 TFile f("Output.root");
\r
19 //AliPerformanceEff * compObj = (AliPerformanceEff*)f.Get("AliPerformanceEff");
\r
20 AliPerformanceEff * compObj = (AliPerformanceEff*)cOutput->FindObject("AliPerformanceEff");
\r
22 // Analyse comparison data
\r
25 // the output histograms/graphs will be stored in the folder "folderEff"
\r
26 compObj->GetAnalysisFolder()->ls("*");
\r
28 // user can save whole comparison object (or only folder with anlysed histograms)
\r
29 // in the seperate output file (e.g.)
\r
30 TFile fout("Analysed_Eff.root","recreate");
\r
31 compObj->Write(); // compObj->GetAnalysisFolder()->Write();
\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
55 using namespace std;
\r
57 ClassImp(AliPerformanceEff)
\r
59 //_____________________________________________________________________________
\r
60 AliPerformanceEff::AliPerformanceEff():
\r
61 AliPerformanceObject("AliPerformanceEff"),
\r
71 // histogram folder
\r
74 // default consttructor
\r
78 //_____________________________________________________________________________
\r
79 AliPerformanceEff::AliPerformanceEff(Char_t* name="AliPerformanceEff",Char_t*title="AliPerformanceEff",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE):
\r
80 AliPerformanceObject(name,title),
\r
89 // histogram folder
\r
92 // named constructor
\r
94 SetAnalysisMode(analysisMode);
\r
95 SetHptGenerator(hptGenerator);
\r
101 //_____________________________________________________________________________
\r
102 AliPerformanceEff::~AliPerformanceEff()
\r
106 if(fEffHisto) delete fEffHisto; fEffHisto=0;
\r
107 if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;
\r
110 //_____________________________________________________________________________
\r
111 void AliPerformanceEff::Init()
\r
116 Int_t nPtBins = 50;
\r
117 Double_t ptMin = 1.e-2, ptMax = 10.;
\r
119 Double_t *binsPt = 0;
\r
120 if (IsHptGenerator()) {
\r
121 nPtBins = 100; ptMax = 100.;
\r
122 binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);
\r
124 binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);
\r
128 Int_t nPtBins = 31;
\r
129 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
130 Double_t ptMin = 0., ptMax = 10.;
\r
132 if(IsHptGenerator() == kTRUE) {
\r
134 ptMin = 0.; ptMax = 100.;
\r
138 //mceta:mcphi:mcpt:pid:recStatus:findable
\r
139 Int_t binsEffHisto[6]={30,144,nPtBins,5,2,2};
\r
140 Double_t minEffHisto[6]={-1.5,0.,ptMin,0.,0.,0.};
\r
141 Double_t maxEffHisto[6]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.};
\r
143 fEffHisto = new THnSparseF("fEffHisto","mceta:mcphi:mcpt:pid:recStatus:findable",6,binsEffHisto,minEffHisto,maxEffHisto);
\r
144 fEffHisto->SetBinEdges(2,binsPt);
\r
146 fEffHisto->GetAxis(0)->SetTitle("#eta_{mc}");
\r
147 fEffHisto->GetAxis(1)->SetTitle("#phi_{mc} (rad)");
\r
148 fEffHisto->GetAxis(2)->SetTitle("p_{Tmc} (GeV/c)");
\r
149 fEffHisto->GetAxis(3)->SetTitle("pid");
\r
150 fEffHisto->GetAxis(4)->SetTitle("recStatus");
\r
151 fEffHisto->GetAxis(5)->SetTitle("findable");
\r
152 fEffHisto->Sumw2();
\r
156 AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object");
\r
158 AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object");
\r
161 fAnalysisFolder = CreateFolder("folderEff","Analysis Efficiency Folder");
\r
164 //_____________________________________________________________________________
\r
165 void AliPerformanceEff::ProcessTPC(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)
\r
167 // Fill TPC only efficiency comparison information
\r
168 Int_t *labelsRec = new Int_t[esdEvent->GetNumberOfTracks()];
\r
170 AliDebug(AliLog::kError, "Cannot create labelsRec");
\r
172 Int_t *labelsAllRec = new Int_t[esdEvent->GetNumberOfTracks()];
\r
174 AliDebug(AliLog::kError, "Cannot create labelsAllRec");
\r
176 // loop over rec. tracks
\r
177 AliESDtrack *track=0;
\r
178 for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
\r
180 track = esdEvent->GetTrack(iTrack);
\r
181 if(!track) continue;
\r
182 if(track->Charge()==0) continue;
\r
183 Int_t label = TMath::Abs(track->GetLabel());
\r
184 if(label == 0) continue;
\r
186 labelsAllRec[iTrack]=label;
\r
189 if(IsRecTPC(track) != 0)
\r
190 labelsRec[iTrack]=label;
\r
194 // MC histograms for efficiency studies
\r
197 AliStack *stack = mcEvent->Stack();
\r
199 AliDebug(AliLog::kError, "Stack not available");
\r
203 //Int_t nPart = stack->GetNtrack();
\r
204 Int_t nPart = stack->GetNprimary();
\r
205 for (Int_t iMc = 0; iMc < nPart; ++iMc)
\r
207 TParticle* particle = stack->Particle(iMc);
\r
208 if (!particle) continue;
\r
209 if (particle->GetPDG()->Charge() == 0.0) continue;
\r
211 // physical primary
\r
212 //Bool_t prim = stack->IsPhysicalPrimary(iMc);
\r
214 Bool_t findable = kFALSE;
\r
215 for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec)
\r
218 if(iMc > 0 && iMc == labelsAllRec[iRec])
\r
220 findable = IsFindable(mcEvent,iMc);
\r
225 Bool_t recStatus = kFALSE;
\r
226 for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec)
\r
228 // check reconstructed
\r
229 if(iMc > 0 && iMc == labelsRec[iRec])
\r
236 // Only 5 charged particle species (e,mu,pi,K,p)
\r
237 if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue;
\r
239 // transform Pdg to Pid
\r
240 Int_t pid = TransformToPID(particle);
\r
242 Float_t mceta = particle->Eta();
\r
243 Float_t mcphi = particle->Phi();
\r
244 if(mcphi<0) mcphi += 2.*TMath::Pi();
\r
245 Float_t mcpt = particle->Pt();
\r
248 Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable};
\r
249 fEffHisto->Fill(vEffHisto);
\r
252 if(labelsRec) delete [] labelsRec; labelsRec = 0;
\r
253 if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;
\r
256 //_____________________________________________________________________________
\r
257 void AliPerformanceEff::ProcessTPCITS(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)
\r
259 // Fill efficiency comparison information
\r
260 Int_t *labelsRec = new Int_t[esdEvent->GetNumberOfTracks()];
\r
262 AliDebug(AliLog::kError, "Cannot create labelsRec");
\r
264 Int_t *labelsAllRec = new Int_t[esdEvent->GetNumberOfTracks()];
\r
266 AliDebug(AliLog::kError, "Cannot create labelsAllRec");
\r
268 // loop over rec. tracks
\r
269 AliESDtrack *track=0;
\r
270 for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
\r
272 track = esdEvent->GetTrack(iTrack);
\r
273 if(!track) continue;
\r
274 if(track->Charge()==0) continue;
\r
275 Int_t label = TMath::Abs(track->GetLabel());
\r
276 if(label == 0) continue;
\r
278 labelsAllRec[iTrack]=label;
\r
281 if(IsRecTPCITS(track) != 0)
\r
282 labelsRec[iTrack]=label;
\r
286 // MC histograms for efficiency studies
\r
289 AliStack *stack = mcEvent->Stack();
\r
291 AliDebug(AliLog::kError, "Stack not available");
\r
295 //Int_t nPart = stack->GetNtrack();
\r
296 Int_t nPart = stack->GetNprimary();
\r
297 for (Int_t iMc = 0; iMc < nPart; ++iMc)
\r
299 TParticle* particle = stack->Particle(iMc);
\r
300 if (!particle) continue;
\r
301 if (particle->GetPDG()->Charge() == 0.0) continue;
\r
303 // physical primary
\r
304 //Bool_t prim = stack->IsPhysicalPrimary(iMc);
\r
306 Bool_t findable = kFALSE;
\r
307 for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec)
\r
310 if(iMc > 0 && iMc == labelsAllRec[iRec])
\r
312 findable = IsFindable(mcEvent,iMc);
\r
317 Bool_t recStatus = kFALSE;
\r
318 for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec)
\r
320 // check reconstructed
\r
321 if(iMc > 0 && iMc == labelsRec[iRec])
\r
328 // Only 5 charged particle species (e,mu,pi,K,p)
\r
329 if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue;
\r
331 // transform Pdg to Pid
\r
332 Int_t pid = TransformToPID(particle);
\r
334 Float_t mceta = particle->Eta();
\r
335 Float_t mcphi = particle->Phi();
\r
336 if(mcphi<0) mcphi += 2.*TMath::Pi();
\r
337 Float_t mcpt = particle->Pt();
\r
340 Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable};
\r
341 fEffHisto->Fill(vEffHisto);
\r
344 if(labelsRec) delete [] labelsRec; labelsRec = 0;
\r
345 if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;
\r
348 //_____________________________________________________________________________
\r
349 void AliPerformanceEff::ProcessConstrained(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent)
\r
351 // Process comparison information
\r
352 Int_t *labelsRec = new Int_t[esdEvent->GetNumberOfTracks()];
\r
354 AliDebug(AliLog::kError, "Cannot create labelsRec");
\r
356 Int_t *labelsAllRec = new Int_t[esdEvent->GetNumberOfTracks()];
\r
358 AliDebug(AliLog::kError, "Cannot create labelsAllRec");
\r
360 // loop over rec. tracks
\r
361 AliESDtrack *track=0;
\r
362 for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
\r
364 track = esdEvent->GetTrack(iTrack);
\r
365 if(!track) continue;
\r
366 if(track->Charge()==0) continue;
\r
367 Int_t label = TMath::Abs(track->GetLabel());
\r
368 if(label == 0) continue;
\r
370 labelsAllRec[iTrack]=label;
\r
373 if(IsRecConstrained(track) != 0)
\r
374 labelsRec[iTrack]=label;
\r
379 // MC histograms for efficiency studies
\r
382 AliStack *stack = mcEvent->Stack();
\r
384 AliDebug(AliLog::kError, "Stack not available");
\r
388 //Int_t nPart = stack->GetNtrack();
\r
389 Int_t nPart = stack->GetNprimary();
\r
390 for (Int_t iMc = 0; iMc < nPart; ++iMc)
\r
392 TParticle* particle = stack->Particle(iMc);
\r
393 if (!particle) continue;
\r
394 if (particle->GetPDG()->Charge() == 0.0) continue;
\r
396 // physical primary
\r
397 //Bool_t prim = stack->IsPhysicalPrimary(iMc);
\r
399 Bool_t findable = kFALSE;
\r
400 for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec)
\r
403 if(iMc > 0 && iMc == labelsAllRec[iRec])
\r
405 findable = IsFindable(mcEvent,iMc);
\r
410 Bool_t recStatus = kFALSE;
\r
411 for(Int_t iRec=0; iRec<esdEvent->GetNumberOfTracks(); ++iRec)
\r
413 // check reconstructed
\r
414 if(iMc > 0 && iMc == labelsRec[iRec])
\r
421 // Only 5 charged particle species (e,mu,pi,K,p)
\r
422 if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue;
\r
424 // transform Pdg to Pid
\r
425 Int_t pid = TransformToPID(particle);
\r
427 Float_t mceta = particle->Eta();
\r
428 Float_t mcphi = particle->Phi();
\r
429 if(mcphi<0) mcphi += 2.*TMath::Pi();
\r
430 Float_t mcpt = particle->Pt();
\r
433 Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable};
\r
434 fEffHisto->Fill(vEffHisto);
\r
437 if(labelsRec) delete [] labelsRec; labelsRec = 0;
\r
438 if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0;
\r
441 //_____________________________________________________________________________
\r
442 void AliPerformanceEff::Exec(AliMCEvent* const mcEvent, AliESDEvent* const esdEvent, const Bool_t bUseMC)
\r
444 // Process comparison information
\r
448 AliDebug(AliLog::kError, "esdEvent not available");
\r
451 AliHeader* header = 0;
\r
452 AliGenEventHeader* genHeader = 0;
\r
453 AliStack* stack = 0;
\r
459 AliDebug(AliLog::kError, "mcEvent not available");
\r
462 // get MC event header
\r
463 header = mcEvent->Header();
\r
465 AliDebug(AliLog::kError, "Header not available");
\r
468 // MC particle stack
\r
469 stack = mcEvent->Stack();
\r
471 AliDebug(AliLog::kError, "Stack not available");
\r
475 genHeader = header->GenEventHeader();
\r
477 AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
\r
480 genHeader->PrimaryVertex(vtxMC);
\r
488 if(GetAnalysisMode() == 0) ProcessTPC(mcEvent,esdEvent);
\r
489 else if(GetAnalysisMode() == 1) ProcessTPCITS(mcEvent,esdEvent);
\r
490 else if(GetAnalysisMode() == 2) ProcessConstrained(mcEvent,esdEvent);
\r
492 printf("ERROR: AnalysisMode %d \n",fAnalysisMode);
\r
497 //_____________________________________________________________________________
\r
498 Int_t AliPerformanceEff::TransformToPID(TParticle *particle)
\r
500 // transform Pdg to Pid
\r
501 // Pdg convension is different for hadrons and leptons
\r
502 // (e.g. K+/K- = 321/-321; e+/e- = -11/11 )
\r
505 if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetEM() ) pid = 0;
\r
506 if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetMuM() ) pid = 1;
\r
507 if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetPiP() ) pid = 2;
\r
508 if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetKP() ) pid = 3;
\r
509 if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetProt() ) pid = 4;
\r
514 //_____________________________________________________________________________
\r
515 Bool_t AliPerformanceEff::IsFindable(AliMCEvent *mcEvent, Int_t label)
\r
517 if(!mcEvent) return kFALSE;
\r
518 if(label==0) return kFALSE;
\r
520 AliMCParticle *mcParticle = mcEvent->GetTrack(label);
\r
521 if(!mcParticle) return kFALSE;
\r
524 Float_t tpcTrackLength = mcParticle->GetTPCTrackLength(AliTracker::GetBz(),0.1,counter,3.0);
\r
525 //printf("tpcTrackLength %f \n", tpcTrackLength);
\r
527 return (tpcTrackLength>fCutsMC->GetMinTrackLength());
\r
530 //_____________________________________________________________________________
\r
531 Bool_t AliPerformanceEff::IsRecTPC(AliESDtrack *esdTrack)
\r
533 if(!esdTrack) return kFALSE;
\r
535 const AliExternalTrackParam *track = esdTrack->GetTPCInnerParam();
\r
536 if(!track) return kFALSE;
\r
538 Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
\r
539 esdTrack->GetImpactParametersTPC(dca,cov);
\r
541 Int_t label = TMath::Abs(esdTrack->GetLabel());
\r
542 if(label == 0) return kFALSE;
\r
544 Bool_t recStatus = kFALSE;
\r
545 if(esdTrack->GetTPCNcls()>fCutsRC->GetMinNClustersTPC() &&
\r
546 TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() &&
\r
547 TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())
\r
555 //_____________________________________________________________________________
\r
556 Bool_t AliPerformanceEff::IsRecTPCITS(AliESDtrack *esdTrack)
\r
558 if(!esdTrack) return kFALSE;
\r
560 Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
\r
561 esdTrack->GetImpactParameters(dca,cov);
\r
563 Int_t label = TMath::Abs(esdTrack->GetLabel());
\r
564 if(label == 0) return kFALSE;
\r
566 Bool_t recStatus = kFALSE;
\r
568 if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit
\r
569 if (esdTrack->GetTPCNcls()<fCutsRC->GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters
\r
570 Int_t clusterITS[200];
\r
571 if(esdTrack->GetITSclusters(clusterITS)<fCutsRC->GetMinNClustersITS()) return kFALSE; // min. nb. ITS clusters
\r
573 if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() &&
\r
574 TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())
\r
582 //_____________________________________________________________________________
\r
583 Bool_t AliPerformanceEff::IsRecConstrained(AliESDtrack *esdTrack)
\r
585 if(!esdTrack) return kFALSE;
\r
587 const AliExternalTrackParam * track = esdTrack->GetConstrainedParam();
\r
588 if(!track) return kFALSE;
\r
590 Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
\r
591 esdTrack->GetImpactParameters(dca,cov);
\r
593 Int_t label = TMath::Abs(esdTrack->GetLabel());
\r
594 if(label == 0) return kFALSE;
\r
596 Bool_t recStatus = kFALSE;
\r
598 if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit
\r
599 if (esdTrack->GetTPCNcls()<fCutsRC->GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters
\r
600 Int_t clusterITS[200];
\r
601 if(esdTrack->GetITSclusters(clusterITS)<fCutsRC->GetMinNClustersITS()) return kFALSE; // min. nb. ITS clusters
\r
603 if(TMath::Abs(dca[0])<fCutsRC->GetMaxDCAToVertexXY() &&
\r
604 TMath::Abs(dca[1])<fCutsRC->GetMaxDCAToVertexZ())
\r
612 //_____________________________________________________________________________
\r
613 Long64_t AliPerformanceEff::Merge(TCollection* const list)
\r
615 // Merge list of objects (needed by PROOF)
\r
620 if (list->IsEmpty())
\r
623 TIterator* iter = list->MakeIterator();
\r
626 // collection of generated histograms
\r
629 while((obj = iter->Next()) != 0)
\r
631 AliPerformanceEff* entry = dynamic_cast<AliPerformanceEff*>(obj);
\r
632 if (entry == 0) continue;
\r
634 fEffHisto->Add(entry->fEffHisto);
\r
641 //_____________________________________________________________________________
\r
642 void AliPerformanceEff::Analyse()
\r
644 // Analyse comparison information and store output histograms
\r
645 // in the folder "folderEff"
\r
647 TH1::AddDirectory(kFALSE);
\r
648 TObjArray *aFolderObj = new TObjArray;
\r
652 // efficiency vs pt
\r
654 fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range
\r
655 fEffHisto->GetAxis(2)->SetRangeUser(0.1,10.); // pt range
\r
657 // rec efficiency vs pt
\r
658 TH1D *ptAll = fEffHisto->Projection(2);
\r
660 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
661 TH1D *ptRec = fEffHisto->Projection(2);
\r
662 TH1D *ptRec_c = (TH1D*)ptRec->Clone();
\r
663 ptRec_c->Divide(ptRec,ptAll,1,1,"B");
\r
664 ptRec_c->SetName("ptRecEff");
\r
666 ptRec_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());
\r
667 ptRec_c->GetYaxis()->SetTitle("efficiency");
\r
668 sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(2)->GetTitle());
\r
669 ptRec_c->SetTitle(title);
\r
671 ptRec_c->SetBit(TH1::kLogX);
\r
672 aFolderObj->Add(ptRec_c);
\r
674 // rec efficiency vs pid vs pt
\r
676 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
677 fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions
\r
679 TH1D *ptAllPi = fEffHisto->Projection(2);
\r
681 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
682 TH1D *ptRecPi = fEffHisto->Projection(2);
\r
683 TH1D *ptRecPi_c = (TH1D*)ptRecPi->Clone();
\r
684 ptRecPi_c->Divide(ptRecPi,ptAllPi,1,1,"B");
\r
685 ptRecPi_c->SetName("ptRecEffPi");
\r
687 ptRecPi_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());
\r
688 ptRecPi_c->GetYaxis()->SetTitle("efficiency");
\r
689 sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(2)->GetTitle());
\r
690 ptRecPi_c->SetTitle(title);
\r
692 ptRecPi_c->SetBit(TH1::kLogX);
\r
693 aFolderObj->Add(ptRecPi_c);
\r
695 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
696 fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons
\r
697 TH1D *ptAllK = fEffHisto->Projection(2);
\r
699 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
700 TH1D *ptRecK = fEffHisto->Projection(2);
\r
702 TH1D *ptRecK_c = (TH1D*)ptRecK->Clone();
\r
703 ptRecK_c->Divide(ptRecK,ptAllK,1,1,"B");
\r
704 ptRecK_c->SetName("ptRecEffK");
\r
706 ptRecK_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());
\r
707 ptRecK_c->GetYaxis()->SetTitle("efficiency");
\r
708 sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(2)->GetTitle());
\r
709 ptRecK_c->SetTitle(title);
\r
712 ptRecK_c->SetBit(TH1::kLogX);
\r
713 aFolderObj->Add(ptRecK_c);
\r
715 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
716 fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons
\r
717 TH1D *ptAllP = fEffHisto->Projection(2);
\r
719 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
720 TH1D *ptRecP = fEffHisto->Projection(2);
\r
721 TH1D *ptRecP_c = (TH1D*)ptRecP->Clone();
\r
722 ptRecP_c->Divide(ptRecP,ptAllP,1,1,"B");
\r
723 ptRecP_c->SetName("ptRecEffP");
\r
725 ptRecP_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());
\r
726 ptRecP_c->GetYaxis()->SetTitle("efficiency");
\r
727 sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(2)->GetTitle());
\r
728 ptRecP_c->SetTitle(title);
\r
730 ptRecP_c->SetBit(TH1::kLogX);
\r
731 aFolderObj->Add(ptRecP_c);
\r
733 // findable efficiency vs pt
\r
735 fEffHisto->GetAxis(3)->SetRangeUser(0.,4.);
\r
736 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
737 fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable
\r
738 TH1D *ptAllF = fEffHisto->Projection(2);
\r
740 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);
\r
741 fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);
\r
743 TH1D *ptRecF = fEffHisto->Projection(2); // rec findable
\r
744 TH1D *ptRecF_c = (TH1D*)ptRecF->Clone();
\r
745 ptRecF_c->Divide(ptRecF,ptAllF,1,1,"B");
\r
746 ptRecF_c->SetName("ptRecEffF");
\r
748 ptRecF_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle());
\r
749 ptRecF_c->GetYaxis()->SetTitle("efficiency");
\r
750 sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(2)->GetTitle());
\r
751 ptRecF_c->SetTitle(title);
\r
753 ptRecF_c->SetBit(TH1::kLogX);
\r
754 aFolderObj->Add(ptRecF_c);
\r
757 // efficiency vs eta
\r
760 fEffHisto->GetAxis(0)->SetRangeUser(-1.5,1.5); // eta range
\r
761 fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range
\r
762 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); // all
\r
763 fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); // all
\r
765 TH1D *etaAll = fEffHisto->Projection(0);
\r
767 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
768 TH1D *etaRec = fEffHisto->Projection(0);
\r
769 TH1D *etaRec_c = (TH1D*)etaRec->Clone();
\r
770 etaRec_c->Divide(etaRec,etaAll,1,1,"B");
\r
771 etaRec_c->SetName("etaRecEff");
\r
773 etaRec_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());
\r
774 etaRec_c->GetYaxis()->SetTitle("efficiency");
\r
775 sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(0)->GetTitle());
\r
776 etaRec_c->SetTitle(title);
\r
778 aFolderObj->Add(etaRec_c);
\r
780 // rec efficiency vs pid vs eta
\r
781 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
782 fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions
\r
784 TH1D *etaAllPi = fEffHisto->Projection(0);
\r
786 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
787 TH1D *etaRecPi = fEffHisto->Projection(0);
\r
788 TH1D *etaRecPi_c = (TH1D*)etaRecPi->Clone();
\r
789 etaRecPi_c->Divide(etaRecPi,etaAllPi,1,1,"B");
\r
790 etaRecPi_c->SetName("etaRecEffPi");
\r
792 etaRecPi_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());
\r
793 etaRecPi_c->GetYaxis()->SetTitle("efficiency");
\r
794 sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(0)->GetTitle());
\r
795 etaRecPi_c->SetTitle(title);
\r
797 aFolderObj->Add(etaRecPi_c);
\r
799 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
800 fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons
\r
801 TH1D *etaAllK = fEffHisto->Projection(0);
\r
803 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
804 TH1D *etaRecK = fEffHisto->Projection(0);
\r
806 TH1D *etaRecK_c = (TH1D*)etaRecK->Clone();
\r
807 etaRecK_c->Divide(etaRecK,etaAllK,1,1,"B");
\r
808 etaRecK_c->SetName("etaRecEffK");
\r
810 etaRecK_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());
\r
811 etaRecK_c->GetYaxis()->SetTitle("efficiency");
\r
812 sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(0)->GetTitle());
\r
813 etaRecK_c->SetTitle(title);
\r
816 aFolderObj->Add(etaRecK_c);
\r
818 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
819 fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons
\r
820 TH1D *etaAllP = fEffHisto->Projection(0);
\r
822 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
823 TH1D *etaRecP = fEffHisto->Projection(0);
\r
824 TH1D *etaRecP_c = (TH1D*)etaRecP->Clone();
\r
825 etaRecP_c->Divide(etaRecP,etaAllP,1,1,"B");
\r
826 etaRecP_c->SetName("etaRecEffP");
\r
828 etaRecP_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());
\r
829 etaRecP_c->GetYaxis()->SetTitle("efficiency");
\r
830 sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(0)->GetTitle());
\r
831 etaRecP_c->SetTitle(title);
\r
833 aFolderObj->Add(etaRecP_c);
\r
835 // findable efficiency vs eta
\r
837 fEffHisto->GetAxis(3)->SetRangeUser(0.,4.);
\r
838 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
839 fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable
\r
840 TH1D *etaAllF = fEffHisto->Projection(0);
\r
842 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);
\r
843 fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);
\r
845 TH1D *etaRecF = fEffHisto->Projection(0); // rec findable
\r
846 TH1D *etaRecF_c = (TH1D*)etaRecF->Clone();
\r
847 etaRecF_c->Divide(etaRecF,etaAllF,1,1,"B");
\r
848 etaRecF_c->SetName("etaRecEffF");
\r
850 etaRecF_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle());
\r
851 etaRecF_c->GetYaxis()->SetTitle("efficiency");
\r
852 sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(0)->GetTitle());
\r
853 etaRecF_c->SetTitle(title);
\r
855 aFolderObj->Add(etaRecF_c);
\r
858 // efficiency vs phi
\r
861 fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range
\r
862 fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range
\r
863 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); // all
\r
864 fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); // all
\r
866 TH1D *phiAll = fEffHisto->Projection(1);
\r
868 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
869 TH1D *phiRec = fEffHisto->Projection(1);
\r
870 TH1D *phiRec_c = (TH1D*)phiRec->Clone();
\r
871 phiRec_c->Divide(phiRec,phiAll,1,1,"B");
\r
872 phiRec_c->SetName("phiRecEff");
\r
874 phiRec_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());
\r
875 phiRec_c->GetYaxis()->SetTitle("efficiency");
\r
876 sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(1)->GetTitle());
\r
877 phiRec_c->SetTitle(title);
\r
879 aFolderObj->Add(phiRec_c);
\r
881 // rec efficiency vs pid vs phi
\r
882 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
883 fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions
\r
885 TH1D *phiAllPi = fEffHisto->Projection(1);
\r
887 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
888 TH1D *phiRecPi = fEffHisto->Projection(1);
\r
889 TH1D *phiRecPi_c = (TH1D*)phiRecPi->Clone();
\r
890 phiRecPi_c->Divide(phiRecPi,phiAllPi,1,1,"B");
\r
891 phiRecPi_c->SetName("phiRecEffPi");
\r
893 phiRecPi_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());
\r
894 phiRecPi_c->GetYaxis()->SetTitle("efficiency");
\r
895 sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(1)->GetTitle());
\r
896 phiRecPi_c->SetTitle(title);
\r
898 aFolderObj->Add(phiRecPi_c);
\r
900 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
901 fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons
\r
902 TH1D *phiAllK = fEffHisto->Projection(1);
\r
904 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
905 TH1D *phiRecK = fEffHisto->Projection(1);
\r
907 TH1D *phiRecK_c = (TH1D*)phiRecK->Clone();
\r
908 phiRecK_c->Divide(phiRecK,phiAllK,1,1,"B");
\r
909 phiRecK_c->SetName("phiRecEffK");
\r
911 phiRecK_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());
\r
912 phiRecK_c->GetYaxis()->SetTitle("efficiency");
\r
913 sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(1)->GetTitle());
\r
914 phiRecK_c->SetTitle(title);
\r
917 aFolderObj->Add(phiRecK_c);
\r
919 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
920 fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons
\r
921 TH1D *phiAllP = fEffHisto->Projection(1);
\r
923 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed
\r
924 TH1D *phiRecP = fEffHisto->Projection(1);
\r
925 TH1D *phiRecP_c = (TH1D*)phiRecP->Clone();
\r
926 phiRecP_c->Divide(phiRecP,phiAllP,1,1,"B");
\r
927 phiRecP_c->SetName("phiRecEffP");
\r
929 phiRecP_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());
\r
930 phiRecP_c->GetYaxis()->SetTitle("efficiency");
\r
931 sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(1)->GetTitle());
\r
932 phiRecP_c->SetTitle(title);
\r
934 aFolderObj->Add(phiRecP_c);
\r
936 // findable efficiency vs phi
\r
938 fEffHisto->GetAxis(3)->SetRangeUser(0.,4.);
\r
939 fEffHisto->GetAxis(4)->SetRangeUser(0.,1.);
\r
940 fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable
\r
941 TH1D *phiAllF = fEffHisto->Projection(1);
\r
943 fEffHisto->GetAxis(4)->SetRangeUser(1.,1.);
\r
944 fEffHisto->GetAxis(5)->SetRangeUser(1.,1.);
\r
946 TH1D *phiRecF = fEffHisto->Projection(1); // rec findable
\r
947 TH1D *phiRecF_c = (TH1D*)phiRecF->Clone();
\r
948 phiRecF_c->Divide(phiRecF,phiAllF,1,1,"B");
\r
949 phiRecF_c->SetName("phiRecEffF");
\r
951 phiRecF_c->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle());
\r
952 phiRecF_c->GetYaxis()->SetTitle("efficiency");
\r
953 sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(1)->GetTitle());
\r
954 phiRecF_c->SetTitle(title);
\r
956 aFolderObj->Add(phiRecF_c);
\r
958 // export objects to analysis folder
\r
959 fAnalysisFolder = ExportToFolder(aFolderObj);
\r
961 // delete only TObjArray
\r
962 if(aFolderObj) delete aFolderObj;
\r
965 //_____________________________________________________________________________
\r
966 TFolder* AliPerformanceEff::ExportToFolder(TObjArray * array)
\r
968 // recreate folder avery time and export objects to new one
\r
970 AliPerformanceEff * comp=this;
\r
971 TFolder *folder = comp->GetAnalysisFolder();
\r
973 TString name, title;
\r
974 TFolder *newFolder = 0;
\r
976 Int_t size = array->GetSize();
\r
979 // get name and title from old folder
\r
980 name = folder->GetName();
\r
981 title = folder->GetTitle();
\r
987 newFolder = CreateFolder(name.Data(),title.Data());
\r
988 newFolder->SetOwner();
\r
990 // add objects to folder
\r
992 newFolder->Add(array->At(i));
\r
1001 //_____________________________________________________________________________
\r
1002 TFolder* AliPerformanceEff::CreateFolder(TString name,TString title) {
\r
1003 // create folder for analysed histograms
\r
1005 TFolder *folder = 0;
\r
1006 folder = new TFolder(name.Data(),title.Data());
\r