]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG1/TPC/AliPerformanceMatch.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Updating the functionality of AliAnalysisHadEtCorrections to accomodate centrality...
[u/mrichter/AliRoot.git] / PWG1 / TPC / AliPerformanceMatch.cxx
CommitLineData
7cc34f08 1//------------------------------------------------------------------------------
2// Implementation of AliPerformanceMatch class. It checks the track matching
3// quality (residuals, pulls) bewteen tracking detectors TPC-ITS and TPC-TRD
4// with TPC as the reference detector. In addition, the ITS and TRD track
5// reconstruction efficiency with respect to TPC is calculated.
6//
7// The matchinig quality parameters are stored in the THnSparse histograms.
8// The analysis of these histograms to extract reference information is done in
9// the Analyse() function (post-processing).
10//
11// The histograms with reference information can be exported to the ROOT folder.
12//
13// Author: J.Otwinowski 17/10/2009
f69eb048 14// Changes by M.Knichel 22/10/2010
7cc34f08 15//------------------------------------------------------------------------------
16
17/*
18
19 // after running comparison task, read the file, and get component
20 gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
21 LoadMyLibs();
22
23 TFile f("Output.root");
24 AliPerformanceMatch * compObj = (AliPerformanceMatch*)coutput->FindObject("AliPerformanceMatchTPCTRD");
25
26 // analyse comparison data
27 compObj->Analyse();
28
29 // the output histograms/graphs will be stored in the folder "folderMatch"
30 compObj->GetAnalysisFolder()->ls("*");
31
32 // user can save whole comparison object (or only folder with anlysed histograms)
33 // in the seperate output file (e.g.)
34 TFile fout("Analysed_Match.root","recreate");
35 compObj->Write(); // compObj->GetAnalysisFolder()->Write();
36 fout.Close();
37
38*/
39
40#include "TCanvas.h"
41#include "TH1.h"
42#include "TH2.h"
43#include "TAxis.h"
44#include "TF1.h"
45
46#include "AliPerformanceMatch.h"
47#include "AliESDEvent.h"
48#include "AliESDVertex.h"
49#include "AliESDtrack.h"
50#include "AliESDfriendTrack.h"
51#include "AliESDfriend.h"
52#include "AliLog.h"
53#include "AliMCEvent.h"
54#include "AliMCParticle.h"
55#include "AliHeader.h"
56#include "AliGenEventHeader.h"
57#include "AliStack.h"
58#include "AliMCInfoCuts.h"
59#include "AliRecInfoCuts.h"
60#include "AliTracker.h"
61#include "AliTRDtrackV1.h"
62#include "AliTreeDraw.h"
63
64using namespace std;
65
66ClassImp(AliPerformanceMatch)
67
f69eb048 68Bool_t AliPerformanceMatch::fgMergeTHnSparse = kFALSE;
69
7cc34f08 70//_____________________________________________________________________________
71AliPerformanceMatch::AliPerformanceMatch():
72 AliPerformanceObject("AliPerformanceMatch"),
73 fResolHisto(0),
74 fPullHisto(0),
6b053687 75 fTrackingEffHisto(0),
f69eb048 76 fFolderObj(0),
7cc34f08 77 // Cuts
78 fCutsRC(0),
79 fCutsMC(0),
80
81 // histogram folder
f69eb048 82 fAnalysisFolder(0),
83
84 fUseHLT(0)
7cc34f08 85{
86 Init();
87}
88
89//_____________________________________________________________________________
90AliPerformanceMatch::AliPerformanceMatch(Char_t* name="AliPerformanceMatch", Char_t* title="AliPerformanceMatch",Int_t analysisMode=0,Bool_t hptGenerator=kFALSE):
91 AliPerformanceObject(name,title),
92 fResolHisto(0),
93 fPullHisto(0),
6b053687 94 fTrackingEffHisto(0),
f69eb048 95 fFolderObj(0),
7cc34f08 96 // Cuts
97 fCutsRC(0),
98 fCutsMC(0),
99
100 // histogram folder
f69eb048 101 fAnalysisFolder(0),
102 fUseHLT(0)
7cc34f08 103{
104 // named constructor
105 //
106 SetAnalysisMode(analysisMode);
107 SetHptGenerator(hptGenerator);
108
109 Init();
110}
111
112//_____________________________________________________________________________
113AliPerformanceMatch::~AliPerformanceMatch()
114{
115 // destructor
116
117 if(fResolHisto) delete fResolHisto; fResolHisto=0;
6b053687 118 if(fPullHisto) delete fPullHisto; fPullHisto=0;
119 if(fTrackingEffHisto) delete fTrackingEffHisto; fTrackingEffHisto = 0x0;
7cc34f08 120
121 if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;
f69eb048 122 if(fFolderObj) delete fFolderObj; fFolderObj=0;
7cc34f08 123}
124
125//_____________________________________________________________________________
126void AliPerformanceMatch::Init(){
127
128 //
129 // Make performance histogrms
130 //
131
132 // set pt bins
133 Int_t nPtBins = 50;
134 Double_t ptMin = 1.e-2, ptMax = 10.;
135
136 Double_t *binsPt = 0;
137 if (IsHptGenerator()) {
138 nPtBins = 100; ptMax = 100.;
139 binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);
140 } else {
141 binsPt = CreateLogAxis(nPtBins,ptMin,ptMax);
142 }
143
144 Double_t yMin = -0.02, yMax = 0.02;
145 Double_t zMin = -12.0, zMax = 12.0;
146 if(GetAnalysisMode() == 0 || GetAnalysisMode() == 1) {
147 yMin = -100.; yMax = 100.;
148 zMin = -100.; zMax = 100.;
149 }
150
151 // res_y:res_z:res_phi,res_lambda:res_pt:y:z:eta:phi:pt:isRec
152 Int_t binsResolHisto[11]={100,100,100,100,100,25,50,90,30,nPtBins,2};
153 Double_t minResolHisto[11]={-1.,-1.,-0.03,-0.03,-0.2, yMin, zMin, 0., -1.5, ptMin,0};
154 Double_t maxResolHisto[11]={ 1., 1., 0.03, 0.03, 0.2, yMax, zMax, 2.*TMath::Pi(), 1.5, ptMax,2};
155
156 fResolHisto = new THnSparseF("fResolHisto","res_y:res_z:res_phi:res_lambda:res_pt:y:z:phi:eta:pt:isRec",11,binsResolHisto,minResolHisto,maxResolHisto);
157 fResolHisto->SetBinEdges(9,binsPt);
158
159 fResolHisto->GetAxis(0)->SetTitle("y-y_{ref} (cm)");
160 fResolHisto->GetAxis(1)->SetTitle("z-z_{ref} (cm)");
161 fResolHisto->GetAxis(2)->SetTitle("#phi-#phi_{ref} (rad)");
162 fResolHisto->GetAxis(3)->SetTitle("#lambda-#lambda_{ref} (rad)");
163 fResolHisto->GetAxis(4)->SetTitle("(p_{T}/p_{Tref}-1)");
164 fResolHisto->GetAxis(5)->SetTitle("y_{ref} (cm)");
165 fResolHisto->GetAxis(6)->SetTitle("z_{ref} (cm)");
166 fResolHisto->GetAxis(7)->SetTitle("#phi_{ref} (rad)");
167 fResolHisto->GetAxis(8)->SetTitle("#eta_{ref}");
168 fResolHisto->GetAxis(9)->SetTitle("p_{Tref} (GeV/c)");
169 fResolHisto->GetAxis(10)->SetTitle("isReconstructed");
170 fResolHisto->Sumw2();
171
172 //pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt:isRec
173 Int_t binsPullHisto[11]={100,100,100,100,100,50,50,50,50,nPtBins,2};
174 Double_t minPullHisto[11]={-5.,-5.,-5.,-5.,-5., yMin, zMin,-1.,-2.0, ptMin,0};
175 Double_t maxPullHisto[11]={ 5., 5., 5., 5., 5., yMax, zMax, 1., 2.0, ptMax,2};
176 fPullHisto = new THnSparseF("fPullHisto","pull_y:pull_z:pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt:isRec",11,binsPullHisto,minPullHisto,maxPullHisto);
177
178 fPullHisto->GetAxis(0)->SetTitle("(y-y_{ref})/#sigma");
179 fPullHisto->GetAxis(1)->SetTitle("(z-z_{ref})/#sigma");
180 fPullHisto->GetAxis(2)->SetTitle("(sin#phi-sin#phi_{ref})/#sigma");
181 fPullHisto->GetAxis(3)->SetTitle("(tan#lambda-tan#lambda_{ref})/#sigma");
182 fPullHisto->GetAxis(4)->SetTitle("(p_{Tref}/p_{T}-1)/#sigma");
183 fPullHisto->GetAxis(5)->SetTitle("y_{ref} (cm)");
184 fPullHisto->GetAxis(6)->SetTitle("z_{ref} (cm)");
185 fPullHisto->GetAxis(7)->SetTitle("sin#phi_{ref}");
186 fPullHisto->GetAxis(8)->SetTitle("tan#lambda_{ref}");
187 fPullHisto->GetAxis(9)->SetTitle("1/p_{Tref} (GeV/c)^{-1}");
188 fPullHisto->GetAxis(10)->SetTitle("isReconstructed");
189 fPullHisto->Sumw2();
190
a13f4653 191 // -> has match:y:z:snp:tgl:phi:pt:ITSclusters
192 Int_t binsTrackingEffHisto[8] = { 2, 50, 100, 50, 50, 90, 100, 7 };
193 Double_t minTrackingEffHisto[8] = {-0.5, -25, -50, -1, -2, 0., 0, -0.5 };
194 Double_t maxTrackingEffHisto[8] = { 1.5, 25, 50, 1, 2, 2*TMath::Pi(), 20, 6.5 };
6b053687 195
a13f4653 196 fTrackingEffHisto = new THnSparseF("fTrackingEffHisto","has match:y:z:snp:tgl:phi:pt:ITSclusters",8,binsTrackingEffHisto,minTrackingEffHisto,maxTrackingEffHisto);
6b053687 197 fTrackingEffHisto->GetAxis(0)->SetTitle("IsMatching");
198 fTrackingEffHisto->GetAxis(1)->SetTitle("local y (cm)");
199 fTrackingEffHisto->GetAxis(2)->SetTitle("z (cm)");
200 fTrackingEffHisto->GetAxis(3)->SetTitle("sin(#phi)");
201 fTrackingEffHisto->GetAxis(4)->SetTitle("tan(#lambda)");
a13f4653 202 fTrackingEffHisto->GetAxis(5)->SetTitle("phi (rad)");
203 fTrackingEffHisto->GetAxis(6)->SetTitle("p_{T}");
204 fTrackingEffHisto->GetAxis(7)->SetTitle("number of ITS clusters");
205 fTrackingEffHisto->Sumw2();
6b053687 206
7cc34f08 207 // Init cuts
208 if(!fCutsMC)
209 AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object");
210 if(!fCutsRC)
211 AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object");
212
213 // init folder
a13f4653 214 fAnalysisFolder = CreateFolder("folderMatch","Analysis Matching Folder");
7cc34f08 215}
216
6b053687 217//_____________________________________________________________________________
218void AliPerformanceMatch::ProcessITSTPC(Int_t iTrack, AliESDEvent *const esdEvent, AliStack* /*const stack*/, AliESDtrack *const esdTrack, AliESDfriendTrack *const esdFriendTrack)
219{
220 //
221 // addition to standard analysis - check if ITS stand-alone tracks have a match in the TPC
a13f4653 222 // Origin: A. Kalwait
223 // Modified: J. Otwinowski
65c87d0e 224 if(!esdEvent) return;
6b053687 225 if(!esdTrack) return;
226 if(!esdFriendTrack) return;
227
65c87d0e 228 // ITS stand alone tracks with SPD layers
229 if(!(esdTrack->GetStatus() & AliESDtrack::kITSpureSA)) return;
230 if(!(esdTrack->GetStatus() & AliESDtrack::kITSrefit)) return;
231 if(esdTrack->GetNcls(0)<fCutsRC->GetMinNClustersITS()) return;
232 if(!esdTrack->HasPointOnITSLayer(0) && !esdTrack->HasPointOnITSLayer(1)) return;
233
6b053687 234 Bool_t hasMatch = kFALSE;
235 for (Int_t jTrack = 0; jTrack < esdEvent->GetNumberOfTracks(); jTrack++) {
236 // loop for all those tracks and check if the corresponding TPC track is found
237 if (jTrack==iTrack) continue;
238 AliESDtrack *trackTPC = esdEvent->GetTrack(jTrack);
239 if (!trackTPC) continue;
a13f4653 240 if (!trackTPC->GetTPCInnerParam()) continue;
6b053687 241
65c87d0e 242 // TPC nClust/track after first tracking pass
243 if(trackTPC->GetTPCNclsIter1()<fCutsRC->GetMinNClustersTPC()) continue;
244
6b053687 245 AliExternalTrackParam *innerTPC = new AliExternalTrackParam(*(trackTPC->GetTPCInnerParam()));
a13f4653 246 if(!innerTPC) continue;
247
6b053687 248 Double_t x[3]; trackTPC->GetXYZ(x);
249 Double_t b[3]; AliTracker::GetBxByBz(x,b);
65c87d0e 250 Double_t dca[2],cov[3];
251 Bool_t isTPCOK = innerTPC->PropagateToDCABxByBz(esdEvent->GetPrimaryVertexSPD(),b,kVeryBig,dca,cov);
252 if(!isTPCOK) {
253 if(innerTPC) delete innerTPC;
254 continue;
255 }
256
257 //
258 // select primaries
259 //
260 Double_t dcaToVertex = -1;
261 if( fCutsRC->GetDCAToVertex2D() )
262 {
263 dcaToVertex = TMath::Sqrt(dca[0]*dca[0]/fCutsRC->GetMaxDCAToVertexXY()/fCutsRC->GetMaxDCAToVertexXY()+dca[1]*dca[1]/fCutsRC->GetMaxDCAToVertexZ()/fCutsRC->GetMaxDCAToVertexZ());
264 }
265 if(fCutsRC->GetDCAToVertex2D() && dcaToVertex > 1) {
266 delete innerTPC; continue; }
267 if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[0]) > fCutsRC->GetMaxDCAToVertexXY()) {
268 delete innerTPC; continue; }
269 if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[1]) > fCutsRC->GetMaxDCAToVertexZ()) {
270 delete innerTPC; continue; }
6b053687 271
272 // rough checking if they match
273 /*
274 printf("+++++++++++++++++++++++++++++++++++++++++++++++ ");
65c87d0e 275 printf("esdTrack->GetY() %e, esdTrack->GetSnp() %e, esdTrack->GetTgl() %e \n",
6b053687 276 esdTrack->GetY(), esdTrack->GetSnp(), esdTrack->GetTgl());
65c87d0e 277 printf("innerTPC->GetY() %e, innerTPC->GetSnp() %e, innerTPC->GetTgl() %e \n",
6b053687 278 innerTPC->GetY() , innerTPC->GetSnp() , innerTPC->GetTgl());
279 */
65c87d0e 280 if (TMath::Abs(esdTrack->GetY() - innerTPC->GetY()) > 3) {
281 delete innerTPC; continue;
282 }
283 if (TMath::Abs(esdTrack->GetSnp() - innerTPC->GetSnp()) > 0.2) {
284 delete innerTPC; continue;
285 }
286 if (TMath::Abs(esdTrack->GetTgl() - innerTPC->GetTgl()) > 0.2) {
287 delete innerTPC; continue;
288 }
6b053687 289
290 hasMatch = kTRUE;
291 if(innerTPC) delete innerTPC;
292 }
a13f4653 293 //has match:y:z:snp:tgl:phi:pt:ITSclusters
294 Double_t vecTrackingEff[8] = { hasMatch,esdTrack->GetY(),esdTrack->GetZ(),esdTrack->GetSnp(),esdTrack->GetTgl(),esdTrack->Phi(), esdTrack->Pt(),esdTrack->GetITSclusters(0) };
6b053687 295 fTrackingEffHisto->Fill(vecTrackingEff);
296
297}
298
7cc34f08 299//_____________________________________________________________________________
300void AliPerformanceMatch::ProcessTPCITS(AliStack* /*const stack*/, AliESDtrack *const esdTrack, AliESDfriendTrack *const esdFriendTrack)
301{
302 //
303 // Match TPC and ITS min-bias tracks
304 // at radius between detectors
305 //
306 if(!esdTrack) return;
307 if(!esdFriendTrack) return;
308
309 //
310 // Propagate tracks to the radius between TPC-ITS
311 // using B-field and material budget
312 //
313 Double_t radius = fCutsRC->GetTPCITSMatchingRadius();
314 Double_t mass = esdTrack->GetMass();
315 Double_t step=1.0; // cm
316
7cc34f08 317 //
318 // Propagate TPCinner (reference detector)
319 //
320 Bool_t isTPCOK=kFALSE;
321 AliExternalTrackParam *innerTPC=NULL;
322
323 Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
324 esdTrack->GetImpactParametersTPC(dca,cov);
325
a13f4653 326 //
327 // select primaries
328 //
329 Double_t dcaToVertex = -1;
330 if( fCutsRC->GetDCAToVertex2D() )
331 {
65c87d0e 332 dcaToVertex = TMath::Sqrt(dca[0]*dca[0]/fCutsRC->GetMaxDCAToVertexXY()/fCutsRC->GetMaxDCAToVertexXY() + dca[1]*dca[1]/fCutsRC->GetMaxDCAToVertexZ()/fCutsRC->GetMaxDCAToVertexZ());
a13f4653 333 }
334 if(fCutsRC->GetDCAToVertex2D() && dcaToVertex > 1) return;
335 if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[0]) > fCutsRC->GetMaxDCAToVertexXY()) return;
336 if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[1]) > fCutsRC->GetMaxDCAToVertexZ()) return;
337
65c87d0e 338 if( (esdTrack->GetTPCNclsIter1()>fCutsRC->GetMinNClustersTPC()) &&
7cc34f08 339 (esdTrack->GetTPCInnerParam()) &&
340 (innerTPC=new AliExternalTrackParam(*(esdTrack->GetTPCInnerParam()))))
341 {
342 isTPCOK = AliTracker::PropagateTrackToBxByBz(innerTPC,radius,mass,step,kTRUE);
343 }
6b053687 344 if(!isTPCOK) {
345 if(innerTPC) delete innerTPC;
346 return;
347 }
7cc34f08 348
349 //
350 // Propagate ITSouter
351 //
352 Bool_t isITSOK=kFALSE;
353 AliExternalTrackParam *outerITS=NULL;
354
355 if( (esdTrack->GetNcls(0)>fCutsRC->GetMinNClustersITS()) &&
356 (esdFriendTrack->GetITSOut()) &&
357 (outerITS=new AliExternalTrackParam(*(esdFriendTrack->GetITSOut()))))
358 {
359 isITSOK = AliTracker::PropagateTrackToBxByBz(outerITS,radius,mass,step,kTRUE);
360 }
361
362 //
363 // Fill histograms (TPC reference detector)
364 //
365 if(isTPCOK)
366 FillHistograms(innerTPC,outerITS,isITSOK);
367
368 if(outerITS) delete outerITS;
369 if(innerTPC) delete innerTPC;
370}
371
372//_____________________________________________________________________________
373void AliPerformanceMatch::ProcessTPCTRD(AliStack* /*const stack*/, AliESDtrack *const esdTrack, AliESDfriendTrack *const esdFriendTrack)
374{
375 //
376 // Match TPC and TRD min-bias tracks
377 // at radius between detectors. TPC is the reference detector.
378 //
379 if(!esdTrack) return;
380 if(!esdFriendTrack) return;
381
382 //
383 // Propagate tracks to the radius between TPC-TRD
384 // using B-field and material budget
385 //
386 Double_t radius = fCutsRC->GetTPCTRDMatchingRadius();
387 Double_t mass = esdTrack->GetMass();
388 Double_t step=1.0; // cm
389
390 //
391 // Propagate TPCouter (reference detector)
392 //
393 Bool_t isTPCOK=kFALSE;
394 AliExternalTrackParam *outerTPC=NULL;
395
396 Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
397 esdTrack->GetImpactParametersTPC(dca,cov);
398
a13f4653 399 //
400 // select primaries
401 //
402 Double_t dcaToVertex = -1;
403 if( fCutsRC->GetDCAToVertex2D() )
404 {
405 dcaToVertex = TMath::Sqrt(dca[0]*dca[0]/fCutsRC->GetMaxDCAToVertexXY()/fCutsRC->GetMaxDCAToVertexXY() + dca[1]*dca[1]/fCutsRC->GetMaxDCAToVertexZ()/fCutsRC->GetMaxDCAToVertexZ());
406 }
407 if(fCutsRC->GetDCAToVertex2D() && dcaToVertex > 1) return;
408 if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[0]) > fCutsRC->GetMaxDCAToVertexXY()) return;
409 if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[1]) > fCutsRC->GetMaxDCAToVertexZ()) return;
410
65c87d0e 411 if( (esdTrack->GetTPCNclsIter1()>fCutsRC->GetMinNClustersTPC()) &&
7cc34f08 412 (esdFriendTrack->GetTPCOut()) &&
413 (outerTPC=new AliExternalTrackParam(*(esdFriendTrack->GetTPCOut()))))
414 {
415 isTPCOK = AliTracker::PropagateTrackToBxByBz(outerTPC,radius,mass,step,kTRUE);
416 }
6b053687 417 if(!isTPCOK) {
418 if(outerTPC) delete outerTPC;
419 return;
420 }
7cc34f08 421
422 //
423 // Propagate TRDinner
424 //
425 Bool_t isTRDOK = kFALSE;
426 AliExternalTrackParam *innerTRD=NULL;
427
428 // get TRD track
429 AliTRDtrackV1 *trdTrack=NULL; //esdFriendTrack = fESDfriend->GetTrack(itrk);
430 TObject *calObject=NULL;
431 Int_t icalib = 0;
432 while((calObject = esdFriendTrack->GetCalibObject(icalib++))) {
433 if(strcmp(calObject->IsA()->GetName(),"AliTRDtrackV1") != 0) continue; // Look for the TRDtrack
434 if(!(trdTrack = dynamic_cast<AliTRDtrackV1*>(calObject))) break;
435 }
436
7cc34f08 437 if( (trdTrack) &&
438 (trdTrack->GetNumberOfTracklets()>fCutsRC->GetMinNTrackletsTRD()) &&
439 (trdTrack->GetTracklet(0)) &&
440 (esdFriendTrack->GetTRDIn()) &&
441 (innerTRD = new AliExternalTrackParam(*(esdFriendTrack->GetTRDIn()))))
442 {
443 isTRDOK = AliTracker::PropagateTrackToBxByBz(innerTRD,radius,mass,step,kTRUE);
444 }
445
446 //
447 // Fill histograms (TPC reference detector)
448 //
449 if(isTPCOK)
450 FillHistograms(outerTPC,innerTRD,isTRDOK);
451
452 if(outerTPC) delete outerTPC;
453 if(innerTRD) delete innerTRD;
454}
455
456//_____________________________________________________________________________
457void AliPerformanceMatch::FillHistograms(AliExternalTrackParam *const refParam, AliExternalTrackParam *const param, Bool_t isRec)
458{
459 //
460 // fill performance histograms
461 // (TPC always as reference)
462 //
463 if(!refParam) return;
464
465 //
466 // Deltas (dy,dz,dphi,dtheta,dpt)
467 //
468 Float_t delta[5] = {0};
469 if(param && isRec) {
470 delta[0] = param->GetY()-refParam->GetY();
471 delta[1] = param->GetZ()-refParam->GetZ();
472 delta[2] = TMath::ATan2(param->Py(),param->Px())-TMath::ATan2(refParam->Py(),refParam->Px());
473 delta[3] = TMath::ATan2(param->Pz(),param->Pt())-TMath::ATan2(refParam->Pz(),refParam->Pt());
474 if(refParam->Pt()) delta[4] = (param->Pt()-refParam->Pt())/refParam->Pt();
475 }
476 //
477 // Pulls (y,z,snp,tanl,1/pt)
478 //
479 Float_t sigma[5] = {0};
480 Float_t pull[5] = {0};
481 if(param && isRec) {
482 sigma[0] = TMath::Sqrt(param->GetSigmaY2()+refParam->GetSigmaY2());
483 sigma[1] = TMath::Sqrt(param->GetSigmaZ2()+refParam->GetSigmaZ2());
484 sigma[2] = TMath::Sqrt(param->GetSigmaSnp2()+refParam->GetSigmaSnp2());
485 sigma[3] = TMath::Sqrt(param->GetSigmaTgl2()+refParam->GetSigmaTgl2());
486 sigma[4] = TMath::Sqrt(param->GetSigma1Pt2()+refParam->GetSigma1Pt2());
487 if(sigma[0]) pull[0] = delta[0] / sigma[0];
488 if(sigma[1]) pull[1] = delta[1] / sigma[1];
489 if(sigma[2]) pull[2] = (param->GetSnp()-refParam->GetSnp()) / sigma[2];
490 if(sigma[3]) pull[3] = (param->GetTgl()-refParam->GetTgl()) / sigma[3];
491 if(sigma[4]) pull[4] = (param->OneOverPt()-refParam->OneOverPt()) / sigma[4];
492 }
493
494 // Fill histograms
495 Double_t vResolHisto[11] = {delta[0],delta[1],delta[2],delta[3],delta[4],refParam->GetY(),refParam->GetZ(),refParam->Phi(),refParam->Eta(),refParam->Pt(),isRec};
496 fResolHisto->Fill(vResolHisto);
497
498 Double_t vPullHisto[11] = {pull[0],pull[1],pull[2],pull[3],pull[4],refParam->GetY(),refParam->GetZ(),refParam->GetSnp(),refParam->GetTgl(),refParam->OneOverPt(),isRec};
499 fPullHisto->Fill(vPullHisto);
500}
501
502//_____________________________________________________________________________
503void AliPerformanceMatch::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend)
504{
505 // Process comparison information
506 //
507 if(!esdEvent)
508 {
509 Error("Exec","esdEvent not available");
510 return;
511 }
512 AliHeader* header = 0;
513 AliGenEventHeader* genHeader = 0;
514 AliStack* stack = 0;
515 TArrayF vtxMC(3);
516
517 if(bUseMC)
518 {
519 if(!mcEvent) {
520 Error("Exec","mcEvent not available");
521 return;
522 }
523 // get MC event header
524 header = mcEvent->Header();
525 if (!header) {
526 Error("Exec","Header not available");
527 return;
528 }
529 // MC particle stack
530 stack = mcEvent->Stack();
531 if (!stack) {
532 Error("Exec","Stack not available");
533 return;
534 }
535 // get MC vertex
536 genHeader = header->GenEventHeader();
537 if (!genHeader) {
538 Error("Exec","Could not retrieve genHeader from Header");
539 return;
540 }
541 genHeader->PrimaryVertex(vtxMC);
542 }
543
544 // use ESD friends
545 if(bUseESDfriend) {
546 if(!esdFriend) {
547 Error("Exec","esdFriend not available");
548 return;
549 }
550 }
551
e6a60a90 552 // trigger
046b4280 553 if(!bUseMC && GetTriggerClass()) {
4bb5f8a9 554 Bool_t isEventTriggered = esdEvent->IsTriggerClassFired(GetTriggerClass());
555 if(!isEventTriggered) return;
556 }
e6a60a90 557
558 // get TPC event vertex
559 const AliESDVertex *vtxESD = esdEvent->GetPrimaryVertexTPC();
560 if(vtxESD && (vtxESD->GetStatus()<=0)) return;
561
7cc34f08 562 // Process events
563 for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
564 {
565 AliESDtrack *track = esdEvent->GetTrack(iTrack);
566 if(!track) continue;
567
568 AliESDfriendTrack *friendTrack=0;
569 if(bUseESDfriend) {
570 friendTrack=esdFriend->GetTrack(iTrack);
571 if(!friendTrack) continue;
572 }
573
574 if(GetAnalysisMode() == 0) ProcessTPCITS(stack,track,friendTrack);
575 else if(GetAnalysisMode() == 1) ProcessTPCTRD(stack,track,friendTrack);
6b053687 576 else if(GetAnalysisMode() == 2) ProcessITSTPC(iTrack,esdEvent,stack,track,friendTrack);
7cc34f08 577 else {
578 printf("ERROR: AnalysisMode %d \n",fAnalysisMode);
579 return;
580 }
581 }
582}
583
584//_____________________________________________________________________________
585TH1F* AliPerformanceMatch::MakeResol(TH2F * his, Int_t integ, Bool_t type, Int_t cut){
586 // Create resolution histograms
587
588 TH1F *hisr, *hism;
589 if (!gPad) new TCanvas;
590 hisr = AliTreeDraw::CreateResHistoII(his,&hism,integ,kTRUE,cut);
591 if (type) return hism;
592 else
593 return hisr;
594}
595
596//_____________________________________________________________________________
597void AliPerformanceMatch::Analyse() {
598 // Analyse comparison information and store output histograms
599 // in the folder "folderMatch"
600 //
f69eb048 601 TString selString;
602 /*
7cc34f08 603 TH1::AddDirectory(kFALSE);
604 TH1F *h=0;
605 TH1F *h2=0;
606 TH2F *h2D=0;
f69eb048 607 */
7cc34f08 608 TObjArray *aFolderObj = new TObjArray;
609
610 // write results in the folder
f69eb048 611 // TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan");
612 // c->cd();
7cc34f08 613
f69eb048 614 // char name[256];
615 // char title[256];
7cc34f08 616
a13f4653 617 if(GetAnalysisMode()==0 || GetAnalysisMode()==1) {
618
7cc34f08 619 fResolHisto->GetAxis(10)->SetRangeUser(1.0,2.0); // only reconstructed
620 fPullHisto->GetAxis(10)->SetRangeUser(1.0,2.0); // only reconstructed
621 for(Int_t i=0; i<5; i++)
622 {
623 for(Int_t j=5; j<10; j++)
624 {
625 //if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window
626 if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(0.0,0.89); // eta window
627 else fResolHisto->GetAxis(8)->SetRangeUser(-1.5,1.49);
a13f4653 628 fResolHisto->GetAxis(9)->SetRangeUser(0.1,100.); // pt threshold
f69eb048 629
630 selString = "resol";
631 AddProjection(aFolderObj, "match", fResolHisto, i, j, &selString);
7cc34f08 632
f69eb048 633 /*
7cc34f08 634 h2D = (TH2F*)fResolHisto->Projection(i,j);
7cc34f08 635 h = AliPerformanceMatch::MakeResol(h2D,1,0,100);
18e588e9 636 snprintf(name,256,"h_res_%d_vs_%d",i,j);
7cc34f08 637 h->SetName(name);
638
639 h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle());
18e588e9 640 snprintf(title,256,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(resolution)");
7cc34f08 641 h->GetYaxis()->SetTitle(title);
18e588e9 642 snprintf(title,256,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle());
7cc34f08 643 h->SetTitle(title);
644
a13f4653 645 //if(j==9) h->SetBit(TH1::kLogX);
7cc34f08 646 aFolderObj->Add(h);
f69eb048 647 */
648 /*
7cc34f08 649 h = AliPerformanceMatch::MakeResol(h2D,1,1,100);
650 //h = (TH1F*)arr->At(1);
18e588e9 651 snprintf(name,256,"h_mean_res_%d_vs_%d",i,j);
7cc34f08 652 h->SetName(name);
653
654 h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle());
18e588e9 655 snprintf(title,256,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(mean)");
7cc34f08 656 h->GetYaxis()->SetTitle(title);
657
18e588e9 658 snprintf(title,256,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle());
7cc34f08 659 h->SetTitle(title);
660
661 if(j==9) h->SetBit(TH1::kLogX);
662 aFolderObj->Add(h);
f69eb048 663 */
7cc34f08 664 //
7cc34f08 665 if(j!=8) fPullHisto->GetAxis(8)->SetRangeUser(0.0,0.89); // eta window
666 else fPullHisto->GetAxis(8)->SetRangeUser(-1.5,1.49); // eta window
a13f4653 667 fPullHisto->GetAxis(9)->SetRangeUser(0.1,100.); // pt threshold
f69eb048 668 selString = "pull";
669 AddProjection(aFolderObj, "match", fPullHisto, i, j, &selString);
7cc34f08 670
f69eb048 671 /*
7cc34f08 672 h2D = (TH2F*)fPullHisto->Projection(i,j);
f69eb048 673
7cc34f08 674 h = AliPerformanceMatch::MakeResol(h2D,1,0,100);
18e588e9 675 snprintf(name,256,"h_pull_%d_vs_%d",i,j);
7cc34f08 676 h->SetName(name);
677
678 h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle());
18e588e9 679 snprintf(title,256,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(resolution)");
7cc34f08 680 h->GetYaxis()->SetTitle(title);
18e588e9 681 snprintf(title,256,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle());
7cc34f08 682 h->SetTitle(title);
683
a13f4653 684 if(j==9) h->SetBit(TH1::kLogX);
7cc34f08 685 aFolderObj->Add(h);
686
687 h = AliPerformanceMatch::MakeResol(h2D,1,1,100);
18e588e9 688 snprintf(name,256,"h_mean_pull_%d_vs_%d",i,j);
7cc34f08 689 h->SetName(name);
690
691 h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle());
18e588e9 692 snprintf(title,256,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(mean)");
7cc34f08 693 h->GetYaxis()->SetTitle(title);
18e588e9 694 snprintf(title,256,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle());
7cc34f08 695 h->SetTitle(title);
696
697 //if(j==9) h->SetBit(TH1::kLogX);
698 aFolderObj->Add(h);
f69eb048 699 */
7cc34f08 700 }
701 }
702
703 //
704 // Efficiency plots
705 //
706 for(Int_t i=5; i<10; i++)
707 {
708 if(i!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window
709 else fResolHisto->GetAxis(8)->SetRangeUser(-1.5,1.49);
a13f4653 710 fResolHisto->GetAxis(9)->SetRangeUser(0.1,100.); // pt threshold
7cc34f08 711
712 fResolHisto->GetAxis(10)->SetRange(1,fResolHisto->GetAxis(10)->GetNbins()); // all
f69eb048 713 selString = "eff_all";
714 AddProjection(aFolderObj, "match", fResolHisto, i, &selString);
715 // h = (TH1F*)fResolHisto->Projection(i);
7cc34f08 716
a13f4653 717 fResolHisto->GetAxis(10)->SetRange(2,2); // only reconstructed
f69eb048 718 selString = "eff_rec";
719 AddProjection(aFolderObj, "match", fResolHisto, i, &selString);
720 //h2 = (TH1F*)fResolHisto->Projection(i);
7cc34f08 721
f69eb048 722 /*
7cc34f08 723 TH1F* h2c = (TH1F*)h2->Clone();
a13f4653 724 h2c->Divide(h2,h,1,1,"B");
7cc34f08 725
18e588e9 726 snprintf(name,256,"h_eff_%d",i);
7cc34f08 727 h2c->SetName(name);
728
729 h2c->GetXaxis()->SetTitle(h2c->GetXaxis()->GetTitle());
730 h2c->GetYaxis()->SetTitle("efficiency");
731 h2c->SetTitle("matching effciency");
732
733 aFolderObj->Add(h2c);
f69eb048 734 */
7cc34f08 735 }
a13f4653 736
737 }
738
739 //
740 // TPC efficiency wrt ITS
741 //
742 if(GetAnalysisMode()==2) {
f69eb048 743 selString = "trackingeff";
744 AddProjection(aFolderObj, "match", fTrackingEffHisto, 0, &selString);
a13f4653 745
f69eb048 746 // h = (TH1F*)fTrackingEffHisto->Projection(0);
747 // aFolderObj->Add(h);
a13f4653 748
749 for(Int_t i=1; i<7; i++)
750 {
751 //
752 //
753 // calculate efficiency
754 //
755
756 // all ITS standalone tracks
757 fTrackingEffHisto->GetAxis(0)->SetRange(1,fTrackingEffHisto->GetAxis(0)->GetNbins());
f69eb048 758 //h = (TH1F*)fTrackingEffHisto->Projection(i);
759 selString = "trackingeff_all";
760 AddProjection(aFolderObj, "match", fTrackingEffHisto, i, &selString);
a13f4653 761
762 // TPC tracks which has matching with TPC
763 fTrackingEffHisto->GetAxis(0)->SetRange(2,2);
f69eb048 764 //h2 = (TH1F*)fTrackingEffHisto->Projection(i);
765 selString = "trackingeff_tpc";
766 AddProjection(aFolderObj, "match", fTrackingEffHisto, i, &selString);
a13f4653 767
f69eb048 768 /*
a13f4653 769 TH1F* h2c = (TH1F*)h2->Clone();
770 h2c->Divide(h2,h,1,1,"B");
771
18e588e9 772 snprintf(name,256,"h_TPC_eff_%d",i);
a13f4653 773 h2c->SetName(name);
774
775 h2c->GetXaxis()->SetTitle(h2c->GetXaxis()->GetTitle());
776 h2c->GetYaxis()->SetTitle("efficiency");
777 h2c->SetTitle("TPC effciency wrt ITS");
f69eb048 778
a13f4653 779 aFolderObj->Add(h2c);
f69eb048 780 */
a13f4653 781 }
782
783 }
f69eb048 784 printf("exportToFolder\n");
785 // export objects to analysis folder
786 fAnalysisFolder = ExportToFolder(aFolderObj);
787
788 // delete only TObjArray
789 if(fFolderObj) delete fFolderObj;
790 fFolderObj = aFolderObj;
791 aFolderObj=0;
792
793}
794
795//_____________________________________________________________________________
796void AliPerformanceMatch::AnalyseFinal() {
797 if (!fFolderObj) {
798 printf("AliPerformanceMatch: no projections available to analyse\n");
799 return;
800 }
801 TH1::AddDirectory(kFALSE);
802 TH1F *h=0;
803 TH1F *h2=0;
804 TH2F *h2D=0;
805 TObjArray *aFolderObj = fFolderObj;
806
807 // write results in the folder
808 TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan");
809 c->cd();
810
811 char name[256];
812 char title[256];
813
814 if(GetAnalysisMode()==0 || GetAnalysisMode()==1) {
815
816 for(Int_t i=0; i<5; i++)
817 {
818 for(Int_t j=5; j<10; j++)
819 {
18e588e9 820 snprintf(name,256,"h_tpc_match_resol_%d_%d",i,j);
f69eb048 821 h2D = dynamic_cast<TH2F*>(aFolderObj->FindObject(name));
822 if (h2D) {
823 h = AliPerformanceMatch::MakeResol(h2D,1,0,100);
18e588e9 824 snprintf(name,256,"h_res_%d_vs_%d",i,j);
f69eb048 825 h->SetName(name);
826 h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle());
18e588e9 827 snprintf(title,256,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(resolution)");
f69eb048 828 h->GetYaxis()->SetTitle(title);
18e588e9 829 snprintf(title,256,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle());
f69eb048 830 h->SetTitle(title);
831
832 //if(j==9) h->SetBit(TH1::kLogX);
833 aFolderObj->Add(h);
834
835 h = AliPerformanceMatch::MakeResol(h2D,1,1,100);
836 //h = (TH1F*)arr->At(1);
18e588e9 837 snprintf(name,256,"h_mean_res_%d_vs_%d",i,j);
f69eb048 838 h->SetName(name);
839
840 h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle());
18e588e9 841 snprintf(title,256,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(mean)");
f69eb048 842 h->GetYaxis()->SetTitle(title);
843
18e588e9 844 snprintf(title,256,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle());
f69eb048 845 h->SetTitle(title);
846
847 if(j==9) h->SetBit(TH1::kLogX);
848 aFolderObj->Add(h);
849 h=0;
850 }
851 //
18e588e9 852 snprintf(name,256,"h_tpc_match_pull_%d_%d",i,j);
f69eb048 853 h2D = dynamic_cast<TH2F*>(aFolderObj->FindObject(name));
854 if (h2D) {
855 h = AliPerformanceMatch::MakeResol(h2D,1,0,100);
18e588e9 856 snprintf(name,256,"h_pull_%d_vs_%d",i,j);
f69eb048 857 h->SetName(name);
858
859 h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle());
18e588e9 860 snprintf(title,256,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(resolution)");
f69eb048 861 h->GetYaxis()->SetTitle(title);
18e588e9 862 snprintf(title,256,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle());
f69eb048 863 h->SetTitle(title);
864
865 if(j==9) h->SetBit(TH1::kLogX);
866 aFolderObj->Add(h);
867
868 h = AliPerformanceMatch::MakeResol(h2D,1,1,100);
18e588e9 869 snprintf(name,256,"h_mean_pull_%d_vs_%d",i,j);
f69eb048 870 h->SetName(name);
871
872 h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle());
18e588e9 873 snprintf(title,256,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(mean)");
f69eb048 874 h->GetYaxis()->SetTitle(title);
18e588e9 875 snprintf(title,256,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle());
f69eb048 876 h->SetTitle(title);
877
878 //if(j==9) h->SetBit(TH1::kLogX);
879 aFolderObj->Add(h);
880 h2D=0;
881 }
882 }
883 }
884
885 //
886 // Efficiency plots
887 //
888 for(Int_t i=5; i<10; i++)
889 {
18e588e9 890 snprintf(name,256,"h_tpc_match_eff_all_%d",i);
f69eb048 891 h = dynamic_cast<TH1F*>(aFolderObj->FindObject(name));
a13f4653 892
f69eb048 893
18e588e9 894 snprintf(name,256,"h_tpc_match_eff_rec_%d",i);
f69eb048 895 h2 = dynamic_cast<TH1F*>(aFolderObj->FindObject(name));
896
897 if (h && h2) {
898 TH1F* h2c = (TH1F*)h2->Clone();
899 h2c->Divide(h2,h,1,1,"B");
900
18e588e9 901 snprintf(name,256,"h_eff_%d",i);
f69eb048 902 h2c->SetName(name);
903
904 h2c->GetXaxis()->SetTitle(h2c->GetXaxis()->GetTitle());
905 h2c->GetYaxis()->SetTitle("efficiency");
906 h2c->SetTitle("matching effciency");
907
908 aFolderObj->Add(h2c);
909 h=0;
910 h2=0;
911 }
912 }
913
914 }
915
916 //
917 // TPC efficiency wrt ITS
918 //
919 if(GetAnalysisMode()==2) {
920
921 for(Int_t i=1; i<7; i++)
922 {
923 //
924 //
925 // calculate efficiency
926 //
927
928 // all ITS standalone tracks
18e588e9 929 snprintf(name,256,"h_tpc_match_trackingeff_all_%d",i);
f69eb048 930 h = dynamic_cast<TH1F*>(aFolderObj->FindObject(name));
931
932
933 // TPC tracks which has matching with TPC
18e588e9 934 snprintf(name,256,"h_tpc_match_trackingeff_tpc_%d",i);
f69eb048 935 h2 = dynamic_cast<TH1F*>(aFolderObj->FindObject(name));
936
937 if (h && h2) {
938 TH1F* h2c = (TH1F*)h2->Clone();
939 h2c->Divide(h2,h,1,1,"B");
940
18e588e9 941 snprintf(name,256,"h_TPC_eff_%d",i);
f69eb048 942 h2c->SetName(name);
943
944 h2c->GetXaxis()->SetTitle(h2c->GetXaxis()->GetTitle());
945 h2c->GetYaxis()->SetTitle("efficiency");
946 h2c->SetTitle("TPC effciency wrt ITS");
947
948 aFolderObj->Add(h2c);
949 h=0;
950 h2=0;
951 h2c=0;
952 }
953
954 }
955 printf("exportToFolder\n");
7cc34f08 956 // export objects to analysis folder
957 fAnalysisFolder = ExportToFolder(aFolderObj);
958
959 // delete only TObjArray
f69eb048 960 if(fFolderObj) delete fFolderObj;
961 fFolderObj = aFolderObj;
962 aFolderObj=0;
963 }
964
7cc34f08 965}
966
f69eb048 967
7cc34f08 968//_____________________________________________________________________________
969TFolder* AliPerformanceMatch::ExportToFolder(TObjArray * array)
970{
971 // recreate folder avery time and export objects to new one
972 //
973 AliPerformanceMatch * comp=this;
974 TFolder *folder = comp->GetAnalysisFolder();
975
976 TString name, title;
977 TFolder *newFolder = 0;
978 Int_t i = 0;
979 Int_t size = array->GetSize();
980
981 if(folder) {
982 // get name and title from old folder
983 name = folder->GetName();
984 title = folder->GetTitle();
985
986 // delete old one
987 delete folder;
988
989 // create new one
990 newFolder = CreateFolder(name.Data(),title.Data());
991 newFolder->SetOwner();
992
993 // add objects to folder
994 while(i < size) {
995 newFolder->Add(array->At(i));
996 i++;
997 }
998 }
999
1000return newFolder;
1001}
1002
f69eb048 1003//_____________________________________________________________________________
1004TFolder* AliPerformanceMatch::CreateFolder(TString name,TString title) {
1005// create folder for analysed histograms
1006//
1007TFolder *folder = 0;
1008 folder = new TFolder(name.Data(),title.Data());
1009
1010 return folder;
1011}
1012
7cc34f08 1013//_____________________________________________________________________________
1014Long64_t AliPerformanceMatch::Merge(TCollection* const list)
1015{
1016 // Merge list of objects (needed by PROOF)
1017
1018 if (!list)
1019 return 0;
1020
1021 if (list->IsEmpty())
1022 return 1;
1023
1024 TIterator* iter = list->MakeIterator();
1025 TObject* obj = 0;
f69eb048 1026 TObjArray* objArrayList = 0;
1027 objArrayList = new TObjArray();
7cc34f08 1028
1029 // collection of generated histograms
1030 Int_t count=0;
1031 while((obj = iter->Next()) != 0)
1032 {
f69eb048 1033 AliPerformanceMatch* entry = dynamic_cast<AliPerformanceMatch*>(obj);
1034 if (entry == 0) continue;
1035 if (fgMergeTHnSparse) {
1036 if ((fResolHisto) && (entry->fResolHisto)) { fResolHisto->Add(entry->fResolHisto); }
1037 if ((fPullHisto) && (entry->fPullHisto)) { fPullHisto->Add(entry->fPullHisto); }
1038 if ((fTrackingEffHisto) && (entry->fTrackingEffHisto)) { fTrackingEffHisto->Add(entry->fTrackingEffHisto); }
1039 }
1040 // the analysisfolder is only merged if present
1041 if (entry->fFolderObj) { objArrayList->Add(entry->fFolderObj); }
7cc34f08 1042
f69eb048 1043 count++;
7cc34f08 1044 }
f69eb048 1045 if (fFolderObj) { fFolderObj->Merge(objArrayList); }
1046 // to signal that track histos were not merged: reset
1047 if (!fgMergeTHnSparse) { fResolHisto->Reset(); fPullHisto->Reset(); fTrackingEffHisto->Reset(); }
1048 // delete
1049 if (objArrayList) delete objArrayList; objArrayList=0;
7cc34f08 1050return count;
1051}