]> git.uio.no Git - u/mrichter/AliRoot.git/blame - JETAN/AliJetESDFillUnitArrayTracks.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Printout only for debug flag set (Ken Read)
[u/mrichter/AliRoot.git] / JETAN / AliJetESDFillUnitArrayTracks.cxx
CommitLineData
be6e5811 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16
17//======================================================================
18// ***July 2006
19// Fill Unit Array class
20// Class used by AliJetESDReader to fill a UnitArray from the information extracted
21// from the particle tracks
22// Author: magali.estienne@ires.in2p3.fr
23//======================================================================
24
25
26// --- ROOT system ---
27#include <TVector3.h>
28#include <TProcessID.h>
29
30// --- AliRoot header files ---
31#include "AliJetUnitArray.h"
32#include "AliJetESDFillUnitArrayTracks.h"
33
34// --- ROOT system ---
35class TSystem;
36class TLorentzVector;
37class TGeoManager;
38
39// --- AliRoot header files ---
40class AliJetFinder;
41class AliJetReader;
42class AliJetESDReader;
43
44ClassImp(AliJetESDFillUnitArrayTracks)
45
46//_____________________________________________________________________________
47AliJetESDFillUnitArrayTracks::AliJetESDFillUnitArrayTracks()
48 : AliJetFillUnitArray(),
49 fNumUnits(0),
50 fHadCorr(0),
51 fApplyMIPCorrection(kTRUE),
52 fESD(0x0),
53 fGrid0(0x0),
54 fGrid1(0x0),
55 fGrid2(0x0),
56 fGrid3(0x0),
57 fGrid4(0x0)
58{
59 // constructor
60}
61
62//_____________________________________________________________________________
63AliJetESDFillUnitArrayTracks::AliJetESDFillUnitArrayTracks(AliESDEvent* esd)
64 : AliJetFillUnitArray(),
65 fNumUnits(0),
66 fHadCorr(0),
67 fApplyMIPCorrection(kTRUE),
68 fESD(esd),
69 fGrid0(0x0),
70 fGrid1(0x0),
71 fGrid2(0x0),
72 fGrid3(0x0),
73 fGrid4(0x0)
74{
75 // constructor
76}
77
78//_____________________________________________________________________________
79AliJetESDFillUnitArrayTracks::AliJetESDFillUnitArrayTracks(const AliJetESDFillUnitArrayTracks &det)
80 : AliJetFillUnitArray(det),
81 fNumUnits(det.fNumUnits),
82 fHadCorr(det.fHadCorr),
83 fApplyMIPCorrection(det.fApplyMIPCorrection),
84 fESD(det.fESD),
85 fGrid0(det.fGrid0),
86 fGrid1(det.fGrid1),
87 fGrid2(det.fGrid2),
88 fGrid3(det.fGrid3),
89 fGrid4(det.fGrid4)
90{
91 // Copy constructor
92}
93
94//------------------------------------------------------------------
95AliJetESDFillUnitArrayTracks& AliJetESDFillUnitArrayTracks::operator=(const AliJetESDFillUnitArrayTracks& other)
96{
97 // Assignment
98
99 fNumUnits = other.fNumUnits;
100 fHadCorr = other.fHadCorr;
101 fApplyMIPCorrection = other.fApplyMIPCorrection;
102 fESD = other.fESD;
103 fGrid0 = other.fGrid0;
104 fGrid1 = other.fGrid1;
105 fGrid2 = other.fGrid2;
106 fGrid3 = other.fGrid3;
107 fGrid4 = other.fGrid4;
108
109 return (*this);
110}
111
112//____________________________________________________________________________
113void AliJetESDFillUnitArrayTracks::InitParameters()
114{
115 fHadCorr = 0; // For hadron correction
116 fNumUnits = fGeom->GetNCells(); // Number of towers in EMCAL
117 cout << "In AliJetESDFillUnitArrayTracks:InitParameters(), Ncells : " << fNumUnits << endl;
118
119 fTPCGrid->GetAccParam(fNphi,fNeta,fPhiMin,
120 fPhiMax,fEtaMin,fEtaMax);
121 fTPCGrid->GetBinParam(fPhiBinInTPCAcc,fEtaBinInTPCAcc,
122 fPhiBinInEMCalAcc,fEtaBinInEMCalAcc,fNbinPhi);
123
124 fIndex = fTPCGrid->GetIndexObject();
125
126 if(fDebug>20){
127 for(Int_t i=0; i<fNphi+1; i++)
128 for(Int_t j=0; j<fNeta+1; j++) {cout << "fIndex[" << i << "," << j << "] : " <<
129 (*fIndex)(i,j) << endl; }
130 }
131 if(fDebug>1) printf("\n Parameters initiated ! \n");
132}
133
134//_____________________________________________________________________________
135AliJetESDFillUnitArrayTracks::~AliJetESDFillUnitArrayTracks()
136{
137 // destructor
138}
139
140//_____________________________________________________________________________
141void AliJetESDFillUnitArrayTracks::Exec(Option_t* const /*option*/)
142{
143 //
144 // Main method.
145 // Fill the unit array with the charged particle information in ESD
146 //
147
148 fDebug = fReaderHeader->GetDebug();
149
150 // Set parameters
151 InitParameters();
152
153 // get number of tracks in event (for the loop)
154 Int_t goodTrack = 0;
155 Int_t nt = 0;
156//(not used ?) Int_t nt2 = 0;
157 Int_t nmax = 0;
158 Float_t pt,eta,phi;
159 // Int_t sflag = 0;
160 TVector3 p3;
161
162 if(fDebug>1) cout << "fESD in Fill array : " << fESD << endl;
163
164 nt = fESD->GetNumberOfTracks();
165 if(fDebug>1) cout << "Number of Tracks in ESD : " << nt << endl;
166
167 // temporary storage of signal and pt cut flag
168 Int_t* sflag = new Int_t[nt];
169 Int_t* cflag = new Int_t[nt];
170
171 // get cuts set by user
172 Float_t ptMin = fReaderHeader->GetPtCut();
173 Float_t etaMin = fReaderHeader->GetFiducialEtaMin();
174 Float_t etaMax = fReaderHeader->GetFiducialEtaMax();
175 fOpt = fReaderHeader->GetDetector();
176 fDZ = fReaderHeader->GetDZ();
177
178 Int_t nTracksEmcal = 0;
179 Int_t nTracksEmcalDZ = 0;
180 Int_t nTracksTpc = 0;
181 Int_t nTracksTpcOnly = 0;
182 Int_t nTracksEmcalCut = 0;
183 Int_t nTracksEmcalDZCut = 0;
184 Int_t nTracksTpcCut = 0;
185 Int_t nTracksTpcOnlyCut = 0;
186
187//(not used ?) Int_t nElements = fTPCGrid->GetNEntries();
188//(not used ?) Int_t nElements2 = fEMCalGrid->GetNEntries();
189 fGrid = fTPCGrid->GetGridType();
190
191//(not used ?) Int_t nEntries = fUnitArray->GetEntries();
192
193//(not used ?) Int_t nRefEnt = fRefArray->GetEntries();
194
195 //loop over tracks
196 nmax = nt;
197 for (Int_t it = 0; it < nmax; it++) {
198 AliESDtrack *track;
199 track = fESD->GetTrack(it);
200 UInt_t status = track->GetStatus();
201
202 Double_t mom[3];
203 track->GetPxPyPz(mom);
204
205 p3.SetXYZ(mom[0],mom[1],mom[2]);
206 pt = p3.Pt();
207
208 Float_t mass = 0.;
209 mass = track->GetMass();
210
211 if ((status & AliESDtrack::kTPCrefit) == 0) continue; // quality check
212 if ((status & AliESDtrack::kITSrefit) == 0) continue; // quality check
213 if (((AliJetESDReaderHeader*) fReaderHeader)->ReadSignalOnly()
214 && TMath::Abs(track->GetLabel()) > 10000) continue; // quality check
215 if (((AliJetESDReaderHeader*) fReaderHeader)->ReadBkgdOnly()
216 && TMath::Abs(track->GetLabel()) < 10000) continue; // quality check
217 eta = p3.Eta();
218 phi = ( (p3.Phi()) < 0) ? (p3.Phi()) + 2. * TMath::Pi() : (p3.Phi());
219
220 if ( (eta > etaMax) || (eta < etaMin)) continue; // checking eta cut
221
222 sflag[goodTrack]=0;
223 if (TMath::Abs(track->GetLabel()) < 10000) sflag[goodTrack]=1;
224 cflag[goodTrack]=0;
225 if (pt > ptMin) cflag[goodTrack]=1; // pt cut
226
227 if(fGrid==0)
228 {
229 // Only TPC filled from its grid in its total acceptance
230
231 Int_t idTPC = fTPCGrid->GetIndex(phi,eta);
232 Bool_t ok = kFALSE;
233 Bool_t ref = kFALSE;
234
235 AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(idTPC-1);
236 TRefArray *reference = uArray->GetUnitTrackRef();
a9c14d46 237 if (reference->GetEntries() == 0) {
238 new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
239 }
240
be6e5811 241 reference->Add(track);
242
243 Float_t unitEnergy = 0.;
244 unitEnergy = uArray->GetUnitEnergy();
245 // nTracksTpcOnly is necessary to count the number of candidate cells
246 // but it doesn't give the real multiplicity -> it will be extracted
247 // in the jet finder through the reference to tracks
248 if(unitEnergy==0.){
249 nTracksTpcOnly++;
250 ok = kTRUE;
251 ref = kTRUE;
252 }
253
254 // Fill energy in TPC acceptance
255 uArray->SetUnitEnergy(unitEnergy + pt);
256 uArray->SetUnitMass(mass);
257
258 // Pt cut flag
259 if(uArray->GetUnitEnergy()<ptMin){
260 uArray->SetUnitCutFlag(kPtSmaller);
261 }
262 else {
263 uArray->SetUnitCutFlag(kPtHigher);
264 if(ok) nTracksTpcOnlyCut++;
265 }
266
267 // Signal flag
268 if(sflag[goodTrack] == 1) {
269 uArray->SetUnitSignalFlag(kGood);
270 uArray->SetUnitSignalFlagC(kFALSE,kGood);
271 } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
272
273 if(uArray->GetUnitEnergy()>0 && ref){
274 if(!fProcId) {
275 fProcId = kTRUE;
276 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
277 }
278 fRefArray->Add(uArray);
279 }
280 }
281
282 if(fGrid==1)
283 {
284 Int_t nElements = fTPCGrid->GetNEntries();
285 // Fill track information in EMCAL acceptance
286 if((eta >= fEtaMin && eta <= fEtaMax) &&
287 (phi >= fPhiMin && phi <= fPhiMax))// &&
288 {
289
290 // Include dead-zones
291 if(fDZ)
292 {
293 Double_t phimin0 = 0., phimin1 = 0., phimin2 = 0., phimin3 = 0., phimin4 = 0.;
294 Double_t phimax0 = 0., phimax1 = 0., phimax2 = 0., phimax3 = 0., phimax4 = 0.;
295 fGeom->GetPhiBoundariesOfSMGap(0,phimin0,phimax0);
296 fGeom->GetPhiBoundariesOfSMGap(1,phimin1,phimax1);
297 fGeom->GetPhiBoundariesOfSMGap(2,phimin2,phimax2);
298 fGeom->GetPhiBoundariesOfSMGap(3,phimin3,phimax3);
299 fGeom->GetPhiBoundariesOfSMGap(4,phimin4,phimax4);
300 Int_t n0 = fGrid0->GetNEntries();
301 Int_t n1 = fGrid1->GetNEntries();
302 Int_t n2 = fGrid2->GetNEntries();
303 Int_t n3 = fGrid3->GetNEntries();
304//(not used ?) Int_t n4 = fGrid4->GetNEntries();
305
306 if(phi >= phimin0 && phi <= phimax0){
307 Int_t id0 = fGrid0->GetIndex(phi,eta)-1;
308 AliJetUnitArray *uArray0 = (AliJetUnitArray*)fUnitArray->At(id0+fNumUnits+nElements);
309 TRefArray *reference0 = uArray0->GetUnitTrackRef();
a9c14d46 310 if (reference0->GetEntries() == 0) {
311 new(reference0) TRefArray(TProcessID::GetProcessWithUID(track));
312 }
313
be6e5811 314 reference0->Add(track);
315
316 Float_t uEnergy0 = uArray0->GetUnitEnergy();
317 Bool_t ok0 = kFALSE;
318 Bool_t ref0 = kFALSE;
319 if(uEnergy0==0.){
320 nTracksEmcalDZ++;
321 ok0 = kTRUE;
322 ref0 = kTRUE;
323 }
324 uArray0->SetUnitEnergy(uEnergy0+pt);
325
326 if(uArray0->GetUnitEnergy()<ptMin)
327 uArray0->SetUnitCutFlag(kPtSmaller);
328 else {
329 uArray0->SetUnitCutFlag(kPtHigher);
330 if(ok0) nTracksEmcalDZCut++;
331 }
332 if(sflag[goodTrack] == 1) {
333 uArray0->SetUnitSignalFlag(kGood);
334 uArray0->SetUnitSignalFlagC(kFALSE,kGood);
335 } else uArray0->SetUnitSignalFlagC(kFALSE,kBad);
336
337 if(uArray0->GetUnitEnergy()>0 && ref0){
338 if(!fProcId){
339 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray0));
340 fProcId = kTRUE;
341 }
342 fRefArray->Add(uArray0);
343 }
344 }
345
346 if(phi >= phimin1 && phi <= phimax1){
347 Int_t id1 = fGrid1->GetIndex(phi,eta)-1+n0;
348 AliJetUnitArray *uArray1 = (AliJetUnitArray*)fUnitArray->At(id1+fNumUnits+nElements);
349 TRefArray *reference1 = uArray1->GetUnitTrackRef();
a9c14d46 350 if (reference1->GetEntries() == 0) {
351 new(reference1) TRefArray(TProcessID::GetProcessWithUID(track));
352 }
353
be6e5811 354 reference1->Add(track);
355
356 Float_t uEnergy1 = uArray1->GetUnitEnergy();
357 Bool_t ok1 = kFALSE;
358 Bool_t ref1 = kFALSE;
359 if(uEnergy1==0.){
360 nTracksEmcalDZ++;
361 ok1 = kTRUE;
362 ref1 = kTRUE;
363 }
364 uArray1->SetUnitEnergy(uEnergy1+pt);
365
366 if(uArray1->GetUnitEnergy()<ptMin)
367 uArray1->SetUnitCutFlag(kPtSmaller);
368 else {
369 uArray1->SetUnitCutFlag(kPtHigher);
370 if(ok1) nTracksEmcalDZCut++;
371 }
372 if(sflag[goodTrack] == 1) {
373 uArray1->SetUnitSignalFlag(kGood);
374 uArray1->SetUnitSignalFlagC(kFALSE,kGood);
375 } else uArray1->SetUnitSignalFlagC(kFALSE,kBad);
376
377 if(uArray1->GetUnitEnergy()>0 && ref1){
378 if(!fProcId){
379 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray1));
380 fProcId = kTRUE;
381 }
382 fRefArray->Add(uArray1);
383 }
384 }
385
386 if(phi >= phimin2 && phi <= phimax2){
387 Int_t id2 = fGrid2->GetIndex(phi,eta)-1+n0+n1;
388 AliJetUnitArray *uArray2 = (AliJetUnitArray*)fUnitArray->At(id2+fNumUnits+nElements);
389 TRefArray *reference2 = uArray2->GetUnitTrackRef();
a9c14d46 390 if (reference2->GetEntries() == 0) {
391 new(reference2) TRefArray(TProcessID::GetProcessWithUID(track));
392 }
393
be6e5811 394 reference2->Add(track);
395
396 Float_t uEnergy2 = uArray2->GetUnitEnergy();
397 Bool_t ok2 = kFALSE;
398 Bool_t ref2 = kFALSE;
399 if(uEnergy2==0.){
400 nTracksEmcalDZ++;
401 ok2 = kTRUE;
402 ref2 = kTRUE;
403 }
404 uArray2->SetUnitEnergy(uEnergy2+pt);
405
406 if(uArray2->GetUnitEnergy()<ptMin)
407 uArray2->SetUnitCutFlag(kPtSmaller);
408 else {
409 uArray2->SetUnitCutFlag(kPtHigher);
410 if(ok2) nTracksEmcalDZCut++;
411 }
412 if(sflag[goodTrack] == 1) {
413 uArray2->SetUnitSignalFlag(kGood);
414 uArray2->SetUnitSignalFlagC(kFALSE,kGood);
415 } else uArray2->SetUnitSignalFlagC(kFALSE,kBad);
416
417 if(uArray2->GetUnitEnergy()>0 && ref2){
418 if(!fProcId){
419 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray2));
420 fProcId = kTRUE;
421 }
422 fRefArray->Add(uArray2);
423 }
424 }
425
426 if(phi >= phimin3 && phi <= phimax3){
427 Int_t id3 = fGrid3->GetIndex(phi,eta)-1+n0+n1+n2;
428 AliJetUnitArray *uArray3 = (AliJetUnitArray*)fUnitArray->At(id3+fNumUnits+nElements);
429 TRefArray *reference3 = uArray3->GetUnitTrackRef();
a9c14d46 430 if (reference3->GetEntries() == 0) {
431 new(reference3) TRefArray(TProcessID::GetProcessWithUID(track));
432 }
433
be6e5811 434 reference3->Add(track);
435
436 Float_t uEnergy3 = uArray3->GetUnitEnergy();
437 Bool_t ok3 = kFALSE;
438 Bool_t ref3 = kFALSE;
439 if(uEnergy3==0.){
440 nTracksEmcalDZ++;
441 ok3 = kTRUE;
442 ref3 = kTRUE;
443 }
444 uArray3->SetUnitEnergy(uEnergy3+pt);
445
446 if(uArray3->GetUnitEnergy()<ptMin)
447 uArray3->SetUnitCutFlag(kPtSmaller);
448 else {
449 uArray3->SetUnitCutFlag(kPtHigher);
450 if(ok3) nTracksEmcalDZCut++;
451 }
452 if(sflag[goodTrack] == 1) {
453 uArray3->SetUnitSignalFlag(kGood);
454 uArray3->SetUnitSignalFlagC(kFALSE,kGood);
455 } else uArray3->SetUnitSignalFlagC(kFALSE,kBad);
456
457 if(uArray3->GetUnitEnergy()>0 && ref3){
458 if(!fProcId){
459 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray3));
460 fProcId = kTRUE;
461 }
462 fRefArray->Add(uArray3);
463 }
464 }
465
466 if(phi >= phimin4 && phi <= phimax4){
467 Int_t id4 = fGrid4->GetIndex(phi,eta)-1+n0+n1+n2+n3;
468 AliJetUnitArray *uArray4 = (AliJetUnitArray*)fUnitArray->At(id4+fNumUnits+nElements);
469 TRefArray *reference4 = uArray4->GetUnitTrackRef();
a9c14d46 470 if (reference4->GetEntries() == 0) {
471 new(reference4) TRefArray(TProcessID::GetProcessWithUID(track));
472 }
473
be6e5811 474 reference4->Add(track);
475
476 Float_t uEnergy4 = uArray4->GetUnitEnergy();
477 Bool_t ok4 = kFALSE;
478 Bool_t ref4 = kFALSE;
479 if(uEnergy4==0.){
480 nTracksEmcalDZ++;
481 ok4 = kTRUE;
482 ref4 = kTRUE;
483 }
484 uArray4->SetUnitEnergy(uEnergy4+pt);
485
486 if(uArray4->GetUnitEnergy()<ptMin)
487 uArray4->SetUnitCutFlag(kPtSmaller);
488 else {
489 uArray4->SetUnitCutFlag(kPtHigher);
490 if(ok4) nTracksEmcalDZCut++;
491 }
492 if(sflag[goodTrack] == 1) {
493 uArray4->SetUnitSignalFlag(kGood);
494 uArray4->SetUnitSignalFlagC(kFALSE,kGood);
495 } else uArray4->SetUnitSignalFlagC(kFALSE,kBad);
496
497 if(uArray4->GetUnitEnergy()>0 && ref4){
498 if(!fProcId){
499 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray4));
500 fProcId = kTRUE;
501 }
502 fRefArray->Add(uArray4);
503 }
504 }
505 } // end fDZ
506
507 Int_t towerID = 0;
508 fGeom->GetAbsCellIdFromEtaPhi(eta,phi,towerID);
509 if(towerID==-1) continue;
510
511 AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(towerID);
512 TRefArray *reference = uArray->GetUnitTrackRef();
a9c14d46 513 if (reference->GetEntries() == 0) {
514 new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
515 }
516
be6e5811 517 reference->Add(track);
518
519 Float_t unitEnergy = uArray->GetUnitEnergy();
520 Bool_t ok = kFALSE;
521 Bool_t ref = kFALSE;
522 if(unitEnergy==0.){
523 nTracksEmcal++;
524 ok=kTRUE;
525 ref=kTRUE;
526 }
527
528 // Do Hadron Correction
529 // This is under construction !!!!!!!!!!!!!!!!!!!!!!!
530 // Parametrization to be added
531 if (fApplyMIPCorrection != 0)
532 {
533// Float_t hCEnergy = fHadCorr->GetEnergy(p3.Mag(), (Double_t)eta,0);
534// unitEnergy -= hCEnergy*TMath::Sin(2.0*TMath::ATan(TMath::Exp(-eta)));
535 } //end Hadron Correction loop
536
537 uArray->SetUnitEnergy(unitEnergy + pt);
538
539 // Put a pt cut flag
540 if(uArray->GetUnitEnergy()<ptMin){
541 uArray->SetUnitCutFlag(kPtSmaller);
542 }
543 else {
544 uArray->SetUnitCutFlag(kPtHigher);
545 if(ok) nTracksEmcalCut++;
546 }
547
548 // Signal flag
549 if(sflag[goodTrack] == 1) {
550 uArray->SetUnitSignalFlag(kGood);
551 uArray->SetUnitSignalFlagC(kFALSE,kGood);
552 } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
553
554
555 if(uArray->GetUnitEnergy()>0 && ref){
556 if(!fProcId){
557 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
558 fProcId = kTRUE;
559 }
560 fRefArray->Add(uArray);
561 }
562 } // end loop on EMCal acceptance cut + tracks quality
563 else{
564 // Outside EMCal acceptance
565
566 Int_t idTPC = fTPCGrid->GetIndex(phi,eta);
567
568 AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(fNumUnits-1+idTPC);
569 TRefArray *reference = uArray->GetUnitTrackRef();
a9c14d46 570 if (reference->GetEntries() == 0) {
571 new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
572 }
573
be6e5811 574 reference->Add(track);
575
576 Float_t unitEnergy2 = uArray->GetUnitEnergy();
577 Bool_t okout = kFALSE;
578 Bool_t refout = kFALSE;
579 if(unitEnergy2==0.){
580 nTracksTpc++;
581 okout=kTRUE;
582 refout=kTRUE;
583 }
584 // Fill energy outside emcal acceptance
585 uArray->SetUnitEnergy(unitEnergy2 + pt);
586
587 // Pt cut flag
588 if(uArray->GetUnitEnergy()<ptMin){
589 uArray->SetUnitCutFlag(kPtSmaller);
590 }
591 else {
592 uArray->SetUnitCutFlag(kPtHigher);
593 if(okout) nTracksTpcCut++;
594 }
595 // Signal flag
596 if(sflag[goodTrack] == 1) {
597 uArray->SetUnitSignalFlag(kGood);
598 uArray->SetUnitSignalFlagC(kFALSE,kGood);
599 } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
600
601
602 if(uArray->GetUnitEnergy()>0 && refout){
603 if(!fProcId){
604 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
605 fProcId = kTRUE;
606 }
607 fRefArray->Add(uArray);
608 }
609 }
610 } // end fGrid==1
611
612 goodTrack++;
613
614 } // end loop on entries (tpc tracks)
615
616 if(fDebug>0)
617 {
618 cout << "End of Tracks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%" << endl;
619 cout << "goodTracks: " << goodTrack << endl;
620 }
621
622 delete[] sflag;
623 delete[] cflag;
624
625 if(fGrid==0) {
626 fNTracks = nTracksTpcOnly;
627 fNTracksCut = nTracksTpcOnlyCut;
628 if(fDebug>10){
629 cout << "fNTracks : " << fNTracks << endl;
630 cout << "fNTracksCut : " << fNTracksCut << endl;
631 }
632 }
633 if(fGrid==1) {
634 fNTracks = nTracksEmcal+nTracksEmcalDZ+nTracksTpc;
635 fNTracksCut = nTracksEmcalCut+nTracksEmcalDZCut+nTracksTpcCut;
636 if(fDebug>10){
637 cout << "fNTracks : " << fNTracks << endl;
638 cout << "fNTracksCut : " << fNTracksCut << endl;
639 }
640 }
641
642}
643
644
645
646
647
648
649
650
651
652
653
654
655
656