]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGCF/Correlations/Base/AliAnalyseLeadingTrackUE.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Added Event Plane dependence in PhiCorrelations code and some random typos.
[u/mrichter/AliRoot.git] / PWGCF / Correlations / Base / AliAnalyseLeadingTrackUE.cxx
CommitLineData
a75aacd6 1/*************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: A.Abrahantes, E.Lopez, S.Vallero *
5 * Version 1.0 *
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 **************************************************************************/
7d756130 15
a75aacd6 16#include <TList.h>
a75aacd6 17#include <TMath.h>
18#include <TObjArray.h>
19#include <TObject.h>
a75aacd6 20#include <TVector3.h>
21
22#include "AliAnalyseLeadingTrackUE.h"
a75aacd6 23
a75aacd6 24#include "AliAODEvent.h"
a75aacd6 25#include "AliAODMCParticle.h"
26#include "AliAODTrack.h"
27#include "AliESDEvent.h"
28#include "AliESDtrack.h"
29#include "AliESDtrackCuts.h"
a75aacd6 30#include "AliInputEventHandler.h"
a75aacd6 31#include "AliMCEvent.h"
a75aacd6 32#include "AliVParticle.h"
7dd4dec4 33#include "AliAODMCHeader.h"
092db0d7 34#include "AliEventplane.h"
97270ee2 35#include "TFormula.h"
a75aacd6 36
ea1919ac 37#include "AliAnalysisManager.h"
38#include "AliMCEventHandler.h"
39#include "AliStack.h"
39c2cb38 40#include "AliPIDResponse.h"
32e49607 41#include "AliHelperPID.h"
ea1919ac 42
43
a75aacd6 44////////////////////////////////////////////////
45//---------------------------------------------
46// Class for transverse regions analysis
47//---------------------------------------------
48////////////////////////////////////////////////
49
50
51using namespace std;
52
53ClassImp(AliAnalyseLeadingTrackUE)
54
092db0d7 55//____________________________________________________________________
a75aacd6 56AliAnalyseLeadingTrackUE::AliAnalyseLeadingTrackUE() :
57 TObject(),
58 fDebug(0),
59 fFilterBit(16),
418b56c5 60 fTrackStatus(0),
a75aacd6 61 fOnlyHadrons(kFALSE),
9e35c487 62 fCheckMotherPDG(kTRUE),
3712ba26 63 fTrackEtaCut(0.8),
97dc2b4e 64 fTrackEtaCutMin(-1.),
092db0d7 65 fTrackPhiCutEvPlMin(0),
66 fTrackPhiCutEvPlMax(0),
e0331fd9 67 fTrackPtMin(0),
5cabd2cd 68 fEventSelection(AliVEvent::kMB|AliVEvent::kUserDefined),
97270ee2 69 fDCAXYCut(0),
7d756130 70 fSharedClusterCut(-1),
132b6963 71 fCrossedRowsCut(-1),
72 fFoundFractionCut(-1),
3712ba26 73 fEsdTrackCuts(0x0),
8b43ff78 74 fEsdTrackCutsExtra1(0x0),
32e49607 75 fEsdTrackCutsExtra2(0x0),
416af868 76 fHelperPID(0x0),
77 fEventCounter(0)
a75aacd6 78{
79 // constructor
80}
81
092db0d7 82//____________________________________________________________________
a75aacd6 83AliAnalyseLeadingTrackUE & AliAnalyseLeadingTrackUE::operator = (const AliAnalyseLeadingTrackUE & /*source*/)
84{
85 // assignment operator
86 return *this;
87}
88
092db0d7 89//____________________________________________________________________
a75aacd6 90AliAnalyseLeadingTrackUE::~AliAnalyseLeadingTrackUE()
91{
92
93 //clear memory
94
95}
96
a75aacd6 97//____________________________________________________________________
3712ba26 98Bool_t AliAnalyseLeadingTrackUE::ApplyCuts(TObject* track)
a75aacd6 99{
a75aacd6 100
101 // select track according to set of cuts
85bfac17 102 if (!fEsdTrackCuts->IsSelected(track) )return kFALSE;
8b43ff78 103 if (fEsdTrackCutsExtra1 && fEsdTrackCutsExtra2 && !fEsdTrackCutsExtra1->IsSelected(track) && !fEsdTrackCutsExtra2->IsSelected(track)) return kFALSE;
3712ba26 104
a75aacd6 105 return kTRUE;
106}
107
3712ba26 108//____________________________________________________________________
092db0d7 109void AliAnalyseLeadingTrackUE::DefineESDCuts(Int_t filterbit)
110{
3712ba26 111
85bfac17 112 // Reproduces the cuts of the corresponding bit in the ESD->AOD filtering
113 // (see $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C)
1be4eb33 114
115 if (filterbit == -1)
116 filterbit = fFilterBit;
a75aacd6 117
1be4eb33 118 if (filterbit == 128)
85bfac17 119 {
120 fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
121 fEsdTrackCuts->SetMinNClustersTPC(70);
122 }
1be4eb33 123 else if (filterbit == 256)
124 {
125 // syst study
126 fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
127 fEsdTrackCuts->SetMinNClustersTPC(80);
128 fEsdTrackCuts->SetMaxChi2PerClusterTPC(3);
129 fEsdTrackCuts->SetMaxDCAToVertexZ(2.7);
130 fEsdTrackCuts->SetMaxDCAToVertexXY(1.9);
131 }
132 else if (filterbit == 512)
133 {
134 // syst study
135 fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
136 fEsdTrackCuts->SetMinNClustersTPC(60);
137 fEsdTrackCuts->SetMaxChi2PerClusterTPC(5);
138 fEsdTrackCuts->SetMaxDCAToVertexZ(3.7);
139 fEsdTrackCuts->SetMaxDCAToVertexXY(2.9);
140 }
4bbcfff9 141 else if (filterbit == 1024)
142 {
143 fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
144 fEsdTrackCuts->SetMinNClustersTPC(-1);
145 fEsdTrackCuts->SetMinNCrossedRowsTPC(70);
146 fEsdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
147 }
8b43ff78 148 else if (filterbit == 2048) // mimic hybrid tracks
149 {
150 // correspond to esdTrackCutsHTG, but WITHOUT spd constraint. this is checked with the next object
151 fEsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE);
152 fEsdTrackCuts->SetName("Global Hybrid tracks, loose DCA");
153 fEsdTrackCuts->SetMaxDCAToVertexXY(2.4);
154 fEsdTrackCuts->SetMaxDCAToVertexZ(3.2);
155 fEsdTrackCuts->SetDCAToVertex2D(kTRUE);
156 fEsdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
157 fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);
e93687b1 158 fEsdTrackCuts->SetMaxFractionSharedTPCClusters(0.4);
8b43ff78 159
160 // Add SPD requirement
161 fEsdTrackCutsExtra1 = new AliESDtrackCuts("SPD", "Require 1 cluster in SPD");
162 fEsdTrackCutsExtra1->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
163 // A track passing fEsdTrackCuts and fEsdTrackCutsExtra1 corresponds to esdTrackCutsHTG
164
8b43ff78 165 fEsdTrackCutsExtra2 = new AliESDtrackCuts("No_SPD", "Reject tracks with cluster in SPD");
166 fEsdTrackCutsExtra2->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kNone);
167 // A track passing fEsdTrackCuts and fEsdTrackCutsExtra2 corresponds to esdTrackCutsHTGC and needs to be constrained
168 }
39c2cb38 169 else if (filterbit == 4096) // require TOF matching
170 {
171 fEsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kTRUE);
172 // FIXME: TOF REQUIREMENTS ARE IN GetParticleSpecies FOR THE MOMENT
173 }
85bfac17 174 else
175 {
cfc375d5 176 fEsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011();
8b43ff78 177 fEsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);
85bfac17 178
179 // Add SPD requirement
8b43ff78 180 fEsdTrackCutsExtra1 = new AliESDtrackCuts("SPD", "Require 1 cluster in SPD");
181 fEsdTrackCutsExtra1->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
85bfac17 182
183 // Add SDD requirement
8b43ff78 184 fEsdTrackCutsExtra2 = new AliESDtrackCuts("SDD", "Require 1 cluster in first layer SDD");
185 fEsdTrackCutsExtra2->SetClusterRequirementITS(AliESDtrackCuts::kSDD,AliESDtrackCuts::kFirst);
85bfac17 186 }
3712ba26 187}
a75aacd6 188
a75aacd6 189//____________________________________________________________________
190TObjArray* AliAnalyseLeadingTrackUE::FindLeadingObjects(TObject *obj)
191{
192
193 // Returns an array of charged particles (or jets) ordered according to their pT.
194
195 Int_t nTracks = NParticles(obj);
196
197
198 if( !nTracks ) return 0;
199
200 // Define array of AliVParticle objects
201 TObjArray* tracks = new TObjArray(nTracks);
202
203 // Loop over tracks or jets
204 for (Int_t ipart=0; ipart<nTracks; ++ipart) {
205 AliVParticle* part = ParticleWithCuts( obj, ipart );
206 if (!part) continue;
207 // Accept leading-tracks in a limited pseudo-rapidity range
97dc2b4e 208 if( TMath::Abs(part->Eta()) > fTrackEtaCut || TMath::Abs(part->Eta()) < fTrackEtaCutMin ) continue;
a75aacd6 209 tracks->AddLast( part );
210 }
211 // Order tracks by pT
212 QSortTracks( *tracks, 0, tracks->GetEntriesFast() );
213
214 nTracks = tracks->GetEntriesFast();
215 if( !nTracks ) return 0;
216
217 return tracks;
218 }
219
092db0d7 220//____________________________________________________________________
1ccd8a0a 221void AliAnalyseLeadingTrackUE::RemoveInjectedSignals(TObjArray* tracks, TObject* mcObj, Int_t maxLabel)
222{
223 // remove injected signals (primaries above <maxLabel>)
224 // <tracks> can be the following cases:
225 // a. tracks: in this case the label is taken and then case b.
226 // b. particles: the first stable mother is searched and checked if it is <= <maxLabel>
227 // <mcObj> can be AOD (TClonesArray) or ESD (AliMCEvent)
228
229 TClonesArray* arrayMC = 0;
230 AliMCEvent* mcEvent = 0;
231 if (mcObj->InheritsFrom("AliMCEvent"))
232 mcEvent = static_cast<AliMCEvent*>(mcObj);
233 else if (mcObj->InheritsFrom("TClonesArray"))
234 arrayMC = static_cast<TClonesArray*>(mcObj);
235 else
236 {
0ac98da8 237 mcObj->Dump();
1ccd8a0a 238 AliFatal("Invalid object passed");
239 }
240
241 Int_t before = tracks->GetEntriesFast();
242
243 for (Int_t i=0; i<before; ++i)
244 {
245 AliVParticle* part = (AliVParticle*) tracks->At(i);
246
247 if (part->InheritsFrom("AliESDtrack") || part->InheritsFrom("AliAODTrack"))
248 part = ((mcEvent) ? mcEvent->GetTrack(TMath::Abs(part->GetLabel())) : (AliVParticle*)arrayMC->At(TMath::Abs(part->GetLabel())));
249
250 AliVParticle* mother = part;
251 if (mcEvent)
252 {
253 while (!mcEvent->IsPhysicalPrimary(mother->GetLabel()))
254 {
255 if (((AliMCParticle*)mother)->GetMother() < 0)
256 {
257 mother = 0;
258 break;
259 }
260
261 mother = (AliMCParticle*) mcEvent->GetTrack(((AliMCParticle*)mother)->GetMother());
262 if (!mother)
263 break;
264 }
265 }
266 else
267 {
268 // find the primary mother
269 while (!((AliAODMCParticle*)mother)->IsPhysicalPrimary())
270 {
271 if (((AliAODMCParticle*)mother)->GetMother() < 0)
272 {
273 mother = 0;
274 break;
275 }
276
277 mother = (AliVParticle*) arrayMC->At(((AliAODMCParticle*)mother)->GetMother());
278 if (!mother)
279 break;
280 }
281 }
282
283 if (!mother)
284 {
285 Printf("WARNING: No mother found for particle %d:", part->GetLabel());
286 continue;
287 }
b3724924 288
289// Printf("%d %d %d", i, part->GetLabel(), mother->GetLabel());
3f3f12d9 290 if (mother->GetLabel() >= maxLabel)
1ccd8a0a 291 {
b3724924 292// Printf("Removing %d with label %d", i, part->GetLabel()); ((AliMCParticle*)part)->Particle()->Print(); ((AliMCParticle*)mother)->Particle()->Print();
1ccd8a0a 293 TObject* object = tracks->RemoveAt(i);
294 if (tracks->IsOwner())
295 delete object;
296 }
297 }
298
299 tracks->Compress();
300
301 AliInfo(Form("Reduced from %d to %d", before, tracks->GetEntriesFast()));
302}
303
092db0d7 304//____________________________________________________________________
f613255f 305void AliAnalyseLeadingTrackUE::RemoveWeakDecays(TObjArray* tracks, TObject* mcObj)
306{
307 // remove particles from weak decays
308 // <tracks> can be the following cases:
309 // a. tracks: in this case the label is taken and then case b.
310 // b. particles: it is checked if IsSecondaryFromWeakDecay is true
311 // <mcObj> can be AOD (TClonesArray) or ESD (AliMCEvent)
312
313 TClonesArray* arrayMC = 0;
314 AliMCEvent* mcEvent = 0;
315 if (mcObj->InheritsFrom("AliMCEvent"))
316 mcEvent = static_cast<AliMCEvent*>(mcObj);
317 else if (mcObj->InheritsFrom("TClonesArray"))
318 arrayMC = static_cast<TClonesArray*>(mcObj);
319 else
320 {
0ac98da8 321 mcObj->Dump();
f613255f 322 AliFatal("Invalid object passed");
323 }
324
325 Int_t before = tracks->GetEntriesFast();
326
327 for (Int_t i=0; i<before; ++i)
328 {
329 AliVParticle* part = (AliVParticle*) tracks->At(i);
330
331 if (part->InheritsFrom("AliESDtrack") || part->InheritsFrom("AliAODTrack"))
332 part = ((mcEvent) ? mcEvent->GetTrack(TMath::Abs(part->GetLabel())) : (AliVParticle*)arrayMC->At(TMath::Abs(part->GetLabel())));
333
334 if (part->InheritsFrom("AliAODMCParticle"))
335 {
336 if (!((AliAODMCParticle*) part)->IsSecondaryFromWeakDecay())
337 continue;
338 }
339 else if (part->InheritsFrom("AliMCParticle") && mcEvent)
340 {
d6a8903f 341 if (!(mcEvent->Stack()->IsSecondaryFromWeakDecay(part->GetLabel())))
f613255f 342 continue;
343 }
344 else
345 {
346 part->Dump();
347 AliFatal("Unknown particle");
348 }
349
350// Printf("Removing %d with label %d", i, part->GetLabel()); part->Dump();
351 TObject* object = tracks->RemoveAt(i);
352 if (tracks->IsOwner())
353 delete object;
354 }
355
356 tracks->Compress();
357
358 if (before > tracks->GetEntriesFast())
359 AliInfo(Form("Reduced from %d to %d", before, tracks->GetEntriesFast()));
360}
361
092db0d7 362//____________________________________________________________________
363TObjArray* AliAnalyseLeadingTrackUE::GetAcceptedParticles(TObject* obj, TObject* arrayMC, Bool_t onlyprimaries, Int_t particleSpecies, Bool_t useEtaPtCuts, Bool_t speciesOnTracks, Double_t evtPlane)
b1831bcb 364{
365 // Returns an array of particles that pass the cuts, if arrayMC is given each reconstructed particle is replaced by its corresponding MC particles, depending on the parameter onlyprimaries only for primaries
366 // particleSpecies: -1 all particles are returned
367 // 0 (pions) 1 (kaons) 2 (protons) 3 (others) particles
59375a30 368 // speciesOnTracks if kFALSE, particleSpecies is only applied on the matched MC particle (not on the track itself)
092db0d7 369 // Passing down the Double_t* evtPlane (range [-pi/2,pi/2]) will apply a phi cut with respect to the eventplane between fTrackPhiCutEvPlMin and fTrackPhiCutEvPlMax. For values outside [-pi/2,pi/2], this will be ignored.
b3724924 370
b1831bcb 371 Int_t nTracks = NParticles(obj);
372 TObjArray* tracks = new TObjArray;
85bfac17 373
374 // for TPC only tracks
eed401dc 375 Bool_t hasOwnership = kFALSE;
8b43ff78 376 if ((fFilterBit == 128 || fFilterBit == 256 || fFilterBit == 512 || fFilterBit == 1024 || fFilterBit == 2048) && obj->InheritsFrom("AliESDEvent"))
eed401dc 377 hasOwnership = kTRUE;
378
379 if (!arrayMC)
380 tracks->SetOwner(hasOwnership);
b1831bcb 381
382 // Loop over tracks or jets
383 for (Int_t ipart=0; ipart<nTracks; ++ipart) {
59375a30 384 AliVParticle* part = ParticleWithCuts( obj, ipart, onlyprimaries, (speciesOnTracks) ? particleSpecies : -1);
b1831bcb 385 if (!part) continue;
386
092db0d7 387 if (TMath::Abs(evtPlane)<=TMath::Pi()/2) { //evtPlane range: (-pi/2,pi/2)
388 Double_t phiPart = part->Phi(); //range: [0,2*pi)
389 if(phiPart>TMath::Pi()) phiPart-=2*TMath::Pi();
390
391 Double_t dPhi = 0; //range: [0,pi/2], i.e. the difference over the shortest angle.
392 Double_t diff = TMath::Abs(phiPart-evtPlane);
393 if(diff<=TMath::Pi()/2) dPhi = diff;
394 else if(diff<=TMath::Pi()) dPhi = TMath::Pi()-diff;
395 else dPhi = diff-TMath::Pi();
396
397 if(dPhi<fTrackPhiCutEvPlMin || dPhi>fTrackPhiCutEvPlMax) {
398 if (hasOwnership)
399 delete part;
400 continue;
401 }
402 }
403
e0331fd9 404 if (useEtaPtCuts)
97dc2b4e 405 if (TMath::Abs(part->Eta()) > fTrackEtaCut || TMath::Abs(part->Eta()) < fTrackEtaCutMin || part->Pt() < fTrackPtMin)
92834c86 406 {
407 if (hasOwnership)
408 delete part;
e0331fd9 409 continue;
92834c86 410 }
b3724924 411
412// Printf("%p %p %d Accepted %d %f %f %f", obj, arrayMC, particleSpecies, ipart, part->Eta(), part->Phi(), part->Pt());
e0331fd9 413
eed401dc 414 if (arrayMC) {
415 Int_t label = part->GetLabel();
416 if (hasOwnership)
417 delete part;
b1831bcb 418 // re-define part as the matched MC particle
eed401dc 419 part = ParticleWithCuts(arrayMC, TMath::Abs(label),onlyprimaries, particleSpecies);
b1831bcb 420 if (!part)continue;
421 }
422
423 tracks->Add(part);
424 }
425
426 return tracks;
427}
428
092db0d7 429//____________________________________________________________________
b591fb9c 430TObjArray* AliAnalyseLeadingTrackUE::GetFakeParticles(TObject* obj, TObject* arrayMC, Bool_t onlyprimaries, Int_t particleSpecies, Bool_t useEtaPtCuts)
431{
432 // particleSpecies: -1 all particles are returned
433 // 0 (pions) 1 (kaons) 2 (protons) 3 (others) particles
434
435 Int_t nTracks = NParticles(obj);
436 TObjArray* tracksReconstructed = new TObjArray;
437 TObjArray* tracksOriginal = new TObjArray;
438 TObjArray* tracksFake = new TObjArray;
439
440 // for TPC only tracks
441 Bool_t hasOwnership = kFALSE;
8b43ff78 442 if ((fFilterBit == 128 || fFilterBit == 256 || fFilterBit == 512 || fFilterBit == 1024 || fFilterBit == 2048) && obj->InheritsFrom("AliESDEvent"))
b591fb9c 443 hasOwnership = kTRUE;
444
445 tracksReconstructed->SetOwner(hasOwnership);
446 tracksFake->SetOwner(hasOwnership);
447
448 // Loop over tracks or jets
449 for (Int_t ipart=0; ipart<nTracks; ++ipart) {
450 AliVParticle* partReconstructed = ParticleWithCuts( obj, ipart, onlyprimaries, particleSpecies );
451 if (!partReconstructed) continue;
452
453 if (useEtaPtCuts)
97dc2b4e 454 if (TMath::Abs(partReconstructed->Eta()) > fTrackEtaCut || TMath::Abs(partReconstructed->Eta()) < fTrackEtaCutMin || partReconstructed->Pt() < fTrackPtMin)
b591fb9c 455 {
456 if (hasOwnership)
457 delete partReconstructed;
458 continue;
459 }
460
461 Int_t label = partReconstructed->GetLabel();
462 if (label == 0)
463 {
d728f490 464 /*
465 Printf(">>> TPC only track:");
466 partReconstructed->Print();
467 partReconstructed->Dump();
468 Printf(">>> Global track:");
469 ((AliESDEvent*) obj)->GetTrack(ipart)->Dump();
470 Printf("Fake (TPC only): eta = %f, phi = %f, pT = %f, ncl = %d, dedx = %f", partReconstructed->Eta(), partReconstructed->Phi(), partReconstructed->Pt(), ((AliESDtrack*) partReconstructed)->GetTPCclusters(0), ((AliESDtrack*) partReconstructed)->GetTPCsignal());
471 Printf("Fake (global ): eta = %f, phi = %f, pT = %f, ncl = %d, dedx = %f", ((AliESDEvent*) obj)->GetTrack(ipart)->Eta(), ((AliESDEvent*) obj)->GetTrack(ipart)->Phi(), ((AliESDEvent*) obj)->GetTrack(ipart)->Pt(), ((AliESDEvent*) obj)->GetTrack(ipart)->GetTPCclusters(0), ((AliESDEvent*) obj)->GetTrack(ipart)->GetTPCsignal());
472 */
b591fb9c 473 tracksFake->AddLast(partReconstructed);
474 continue;
475 }
d728f490 476
b591fb9c 477 AliVParticle* partOriginal = ParticleWithCuts(arrayMC, TMath::Abs(label),onlyprimaries, particleSpecies);
d728f490 478 if (!partOriginal)
479 {
480 if (hasOwnership)
481 delete partReconstructed;
482 continue;
483 }
b591fb9c 484
485 tracksReconstructed->AddLast(partReconstructed);
486 tracksOriginal->AddLast(partOriginal);
487 }
488 TObjArray* pairs = new TObjArray;
489 pairs->SetOwner(kTRUE);
490 pairs->Add(tracksReconstructed);
491 pairs->Add(tracksOriginal);
492 pairs->Add(tracksFake);
493 return pairs;
494}
495
092db0d7 496//____________________________________________________________________
a75aacd6 497TObjArray* AliAnalyseLeadingTrackUE::GetMinMaxRegion(TList *transv1, TList *transv2)
498{
499
500 // Returns two lists of particles, one for MIN and one for MAX region
501 Double_t sumpT1 = 0.;
502 Double_t sumpT2 = 0.;
503
504 Int_t particles1 = transv1->GetEntries();
505 Int_t particles2 = transv2->GetEntries();
506
507 // Loop on transverse region 1
508 for (Int_t i=0; i<particles1; i++){
509 AliVParticle *part = (AliVParticle*)transv1->At(i);
510 sumpT1 += part->Pt();
511 }
512
513 // Loop on transverse region 2
514 for (Int_t i=0; i<particles2; i++){
515 AliVParticle *part = (AliVParticle*)transv2->At(i);
516 sumpT2 += part->Pt();
517 }
518
519 TObjArray *regionParticles = new TObjArray;
520 if ( sumpT2 >= sumpT1 ){
521 regionParticles->AddLast(transv1); // MIN
522 regionParticles->AddLast(transv2); // MAX
523 }else {
524 regionParticles->AddLast(transv2); // MIN
525 regionParticles->AddLast(transv1); // MAX
526 }
527
528 return regionParticles;
529}
530
092db0d7 531//____________________________________________________________________
a75aacd6 532Int_t AliAnalyseLeadingTrackUE::NParticles(TObject* obj)
533{
534
535 //Returns the number of particles in AliAODMCParticle array or AliAODTracks or AliESDTracks
536
537 Int_t nTracks;
538
539 if (obj->InheritsFrom("TClonesArray")){ // MC particles
ea1919ac 540 TClonesArray *arrayMC = static_cast<TClonesArray*>(obj);
a75aacd6 541 nTracks = arrayMC->GetEntriesFast();
542 }else if (obj->InheritsFrom("TObjArray")){ // list of AliVParticle
ea1919ac 543 TObjArray *array = static_cast<TObjArray*>(obj);
a75aacd6 544 nTracks = array->GetEntriesFast();
545 }else if (obj->InheritsFrom("AliAODEvent")){ // RECO AOD tracks
ea1919ac 546 AliAODEvent *aodEvent = static_cast<AliAODEvent*>(obj);
a75aacd6 547 nTracks = aodEvent->GetNTracks();
548 }else if (obj->InheritsFrom("AliESDEvent")){ // RECO ESD tracks
ea1919ac 549 AliESDEvent *esdEvent = static_cast<AliESDEvent*>(obj);
a75aacd6 550 nTracks = esdEvent->GetNumberOfTracks();
3712ba26 551 }else if (obj->InheritsFrom("AliMCEvent")){ // RECO ESD tracks
ea1919ac 552 AliMCEvent *mcEvent = static_cast<AliMCEvent*>(obj);
3712ba26 553 nTracks = mcEvent->GetNumberOfTracks();
a75aacd6 554 }else {
555 if (fDebug > 1) AliFatal(" Analysis type not defined !!! ");
556 return 0;
557 }
558
559 return nTracks;
560}
561
092db0d7 562//____________________________________________________________________
b1831bcb 563AliVParticle* AliAnalyseLeadingTrackUE::ParticleWithCuts(TObject* obj, Int_t ipart, Bool_t onlyprimaries, Int_t particleSpecies)
a75aacd6 564{
565 // Returns track or MC particle at position "ipart" if passes selection criteria
b1831bcb 566 // particleSpecies: -1 all particles are returned
567 // 0 (pions) 1 (kaons) 2 (protons) 3 (others) particles
a75aacd6 568 AliVParticle *part=0;
569
570 if (obj->InheritsFrom("TClonesArray")){ // AOD-MC PARTICLE
ea1919ac 571 TClonesArray *arrayMC = static_cast<TClonesArray*>(obj);
a75aacd6 572 part = (AliVParticle*)arrayMC->At( ipart );
573 if (!part)return 0;
574 // eventually only primaries
575 if (onlyprimaries && !( ((AliAODMCParticle*)part)->IsPhysicalPrimary()) )return 0;
576 // eventually only hadrons
577 if (fOnlyHadrons){
578 Int_t pdgCode = ((AliAODMCParticle*)part)->GetPdgCode();
579 Bool_t isHadron = TMath::Abs(pdgCode)==211 || // Pion
580 TMath::Abs(pdgCode)==2212 || // Proton
581 TMath::Abs(pdgCode)==321; // Kaon
582 if (!isHadron) return 0;
583 }
b1831bcb 584 if (particleSpecies != -1) {
585 // find the primary mother
586 AliVParticle* mother = part;
9e35c487 587 if(fCheckMotherPDG) {
588 while (!((AliAODMCParticle*)mother)->IsPhysicalPrimary())
589 {
b1831bcb 590 if (((AliAODMCParticle*)mother)->GetMother() < 0)
591 {
592 mother = 0;
593 break;
594 }
595
596 mother = (AliVParticle*) arrayMC->At(((AliAODMCParticle*)mother)->GetMother());
597 if (!mother)
598 break;
9e35c487 599 }
b1831bcb 600 }
b1831bcb 601 if (mother)
602 {
603 Int_t pdgCode = ((AliAODMCParticle*)mother)->GetPdgCode();
604 if (particleSpecies == 0 && TMath::Abs(pdgCode)!=211)
605 return 0;
606 if (particleSpecies == 1 && TMath::Abs(pdgCode)!=321)
607 return 0;
608 if (particleSpecies == 2 && TMath::Abs(pdgCode)!=2212)
609 return 0;
610 if (particleSpecies == 3 && (TMath::Abs(pdgCode)==211 || TMath::Abs(pdgCode)==321 || TMath::Abs(pdgCode)==2212))
611 return 0;
612 }
1c6b6c97 613 else
614 {
615 // if mother not found, accept particle only in case of particleSpecies == 3. To include it in all or no sample is no solution
ea1919ac 616 Printf("WARNING: No mother found for particle %d:", part->GetLabel());
617 part->Print();
618
619 /*
620 // this code prints the details of the mother that is missing in the AOD
621 AliMCEventHandler* fMcHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
622
623 AliMCEvent* fMcEvent = fMcHandler->MCEvent();
624
625 fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(part->GetLabel())->GetMother(0))->Print();
626 fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(part->GetLabel())->GetMother(0))->GetMother(0))->Print();
627 Printf("eta = %f", fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(part->GetLabel())->GetMother(0))->GetMother(0))->Eta());
628 */
629
1c6b6c97 630 if (particleSpecies != 3)
631 return 0;
632 }
b1831bcb 633 }
a75aacd6 634
635 }else if (obj->InheritsFrom("TObjArray")){ // list of AliVParticle
ea1919ac 636 TObjArray *array = static_cast<TObjArray*>(obj);
a75aacd6 637 part = (AliVParticle*)array->At( ipart );
638 if (!part)return 0;
639 }else if (obj->InheritsFrom("AliMCEvent")){ // MC PARTICLE
ea1919ac 640 AliMCEvent* mcEvent = static_cast<AliMCEvent*>(obj);
a75aacd6 641 part = mcEvent->GetTrack( ipart );
642 if (!part) return 0;
643 // eventually only primaries
644 if (onlyprimaries && !( mcEvent->IsPhysicalPrimary(ipart)) )return 0;
645 // eventually only hadrons
646 //TO-DO
647 /*if (fOnlyHadrons){
648 Int_t pdgCode = part->GetPdgCode();
649 Bool_t isHadron = TMath::Abs(pdgCode)==211 || // Pion
650 TMath::Abs(pdgCode)==2212 || // Proton
651 TMath::Abs(pdgCode)==321; // Kaon
652 if (!isHadron) return 0;
653 }
654 */
eed401dc 655 if (particleSpecies != -1) {
656 // find the primary mother
657 AliMCParticle* mother = (AliMCParticle*) part;
658// Printf("");
9e35c487 659 if(fCheckMotherPDG) {
660 while (!mcEvent->IsPhysicalPrimary(mother->GetLabel()))
661 {
eed401dc 662// Printf("pdg = %d; mother = %d", mother->PdgCode(), mother->GetMother());
663 if (mother->GetMother() < 0)
664 {
665 mother = 0;
666 break;
667 }
668
669 mother = (AliMCParticle*) mcEvent->GetTrack(mother->GetMother());
670 if (!mother)
671 break;
9e35c487 672 }
eed401dc 673 }
eed401dc 674 if (mother)
675 {
676 Int_t pdgCode = mother->PdgCode();
677 if (particleSpecies == 0 && TMath::Abs(pdgCode)!=211)
678 return 0;
679 if (particleSpecies == 1 && TMath::Abs(pdgCode)!=321)
680 return 0;
681 if (particleSpecies == 2 && TMath::Abs(pdgCode)!=2212)
682 return 0;
683 if (particleSpecies == 3 && (TMath::Abs(pdgCode)==211 || TMath::Abs(pdgCode)==321 || TMath::Abs(pdgCode)==2212))
684 return 0;
685 }
686 else
687 {
688 // if mother not found, accept particle only in case of particleSpecies == 3. To include it in all or no sample is no solution
689 Printf("WARNING: No mother found for particle %d:", part->GetLabel());
690 //part->Dump();
691 //part->Print();
692
693 /*
694 // this code prints the details of the mother that is missing in the AOD
695 AliMCEventHandler* fMcHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
696
697 AliMCEvent* fMcEvent = fMcHandler->MCEvent();
698
699 fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(part->GetLabel())->GetMother(0))->Print();
700 fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(part->GetLabel())->GetMother(0))->GetMother(0))->Print();
701 Printf("eta = %f", fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(fMcEvent->Stack()->Particle(part->GetLabel())->GetMother(0))->GetMother(0))->Eta());
702 */
703
704 if (particleSpecies != 3)
705 return 0;
706 }
707 }
a75aacd6 708 }else if (obj->InheritsFrom("AliAODEvent")){ // RECO AOD TRACKS
ea1919ac 709 AliAODEvent *aodEvent = static_cast<AliAODEvent*>(obj);
a75aacd6 710 part = aodEvent->GetTrack(ipart);
418b56c5 711
a75aacd6 712 // track selection cuts
105e7451 713 if (fFilterBit != 0 && !(((AliAODTrack*)part)->TestFilterBit(fFilterBit))) return 0;
418b56c5 714 if (fTrackStatus != 0 && !CheckTrack(part)) return 0;
97270ee2 715
716 // DCA XY
717 if (fDCAXYCut)
718 {
719 const AliVVertex* vertex = aodEvent->GetPrimaryVertex();
720 if (!vertex)
721 return 0;
722
723 Double_t pos[2];
b3724924 724 Double_t covar[3];
97270ee2 725 AliAODTrack* clone = (AliAODTrack*) part->Clone();
726 Bool_t success = clone->PropagateToDCA(vertex, aodEvent->GetHeader()->GetMagneticField(), 3, pos, covar);
727 delete clone;
728 if (!success)
729 return 0;
730
731// Printf("%f", ((AliAODTrack*)part)->DCA());
732// Printf("%f", pos[0]);
733 if (TMath::Abs(pos[0]) > fDCAXYCut->Eval(part->Pt()))
734 return 0;
735 }
7d756130
JFGO		 736
737 if (fSharedClusterCut >= 0)
738 {
739 Double_t frac = Double_t(((AliAODTrack*)part)->GetTPCnclsS()) / Double_t(((AliAODTrack*)part)->GetTPCncls());
740 if (frac > fSharedClusterCut)
741 return 0;
742 }
132b6963 743
744 if (fCrossedRowsCut >= 0)
745 {
746 if (((AliAODTrack*) part)->GetTPCNCrossedRows() < fCrossedRowsCut)
747 return 0;
748 }
749
750 if (fFoundFractionCut >= 0)
751 {
752 UInt_t findableClusters = ((AliAODTrack*) part)->GetTPCNclsF();
753 if (findableClusters == 0)
754 return 0;
755 if (((Double_t) ((AliAODTrack*) part)->GetTPCNCrossedRows() / findableClusters) < fFoundFractionCut)
756 return 0;
757 }
418b56c5 758
a75aacd6 759 // eventually only hadrons
760 if (fOnlyHadrons){
761 Bool_t isHadron = ((AliAODTrack*)part)->GetMostProbablePID()==AliAODTrack::kPion ||
762 ((AliAODTrack*)part)->GetMostProbablePID()==AliAODTrack::kKaon ||
763 ((AliAODTrack*)part)->GetMostProbablePID()==AliAODTrack::kProton;
764 if (!isHadron) return 0;
765 }
6a6b706c 766
32e49607 767 if (particleSpecies != -1 && fHelperPID->GetParticleSpecies((AliVTrack*) part,kTRUE) != particleSpecies) return 0;
a75aacd6 768
769 }else if (obj->InheritsFrom("AliESDEvent")){ // RECO ESD TRACKS
ea1919ac 770 AliESDEvent *esdEvent = static_cast<AliESDEvent*>(obj);
a75aacd6 771 part = esdEvent->GetTrack(ipart);
772 if (!part)return 0;
418b56c5 773
a75aacd6 774 // track selection cuts
e0331fd9 775 if (!( ApplyCuts(part)) )
418b56c5 776 return 0;
a75aacd6 777
418b56c5 778 if (fTrackStatus != 0 && !CheckTrack(part)) return 0;
779
1bba939a 780 if (fFilterBit == 128 || fFilterBit == 256 || fFilterBit == 512 || fFilterBit == 1024)
85bfac17 781 {
782 // create TPC only tracks constrained to the SPD vertex
783
784 const AliESDVertex *vtxSPD = esdEvent->GetPrimaryVertexSPD();
785
786 AliESDtrack* track = AliESDtrackCuts::GetTPCOnlyTrack(esdEvent, ipart);
787 if(!track) return 0;
788
defad170 789// Printf(">%f %f %f", track->Eta(), track->Phi(), track->Pt());
790
85bfac17 791 if(track->Pt()>0.){
792 // only constrain tracks above threshold
793 AliExternalTrackParam exParam;
794 // take the B-feild from the ESD, no 3D fieldMap available at this point
795 Bool_t relate = kFALSE;
caa8c7b2 796 relate = track->RelateToVertexTPC(vtxSPD,esdEvent->GetMagneticField(),kVeryBig,&exParam);
85bfac17 797 if(!relate)
798 {
799// Printf("relating failed");
800 delete track;
801 return 0;
802 }
803 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
804 }
805
defad170 806// Printf(">%f %f %f\n", track->Eta(), track->Phi(), track->Pt());
807
85bfac17 808 part = track;
809 }
8b43ff78 810 else if (fFilterBit == 2048)
811 {
812 // hybrid tracks
813
814 // clone
815 AliESDtrack* esdTrack = new AliESDtrack(*((AliESDtrack*) part));
816// Printf("%d %d %d %d %d", fEsdTrackCuts->IsSelected(esdTrack), fEsdTrackCutsExtra1->IsSelected(esdTrack), fEsdTrackCutsExtra2->IsSelected(esdTrack), esdTrack->HasPointOnITSLayer(0), esdTrack->HasPointOnITSLayer(1));
817
818 if (fEsdTrackCutsExtra2->IsSelected(esdTrack))
819 {
820// Float_t ptBefore = esdTrack->Pt();
821 // set constrained pT as default pT
822 if (!esdTrack->GetConstrainedParam())
823 return 0;
824 esdTrack->CopyFromVTrack(esdTrack->GetConstrainedParam());
825// Printf("%f %f", ptBefore, esdTrack->Pt());
826 }
827 part = esdTrack;
828 }
a75aacd6 829
830 // eventually only hadrons
831 //TO-DO
832 /*if (fOnlyHadrons){
833 Bool_t isHadron = ((AliAODTrack*)part)->GetMostProbablePID()==AliAODTrack::kPion ||
834 ((AliAODTrack*)part)->GetMostProbablePID()==AliAODTrack::kKaon ||
835 ((AliAODTrack*)part)->GetMostProbablePID()==AliAODTrack::kProton;
836 if (!isHadron) return 0;
837 }
838 */
32e49607 839 if (particleSpecies != -1 && fHelperPID->GetParticleSpecies((AliVTrack*) part,kTRUE) != particleSpecies) return 0; // If it is -1 you take all the particles
39c2cb38 840
a75aacd6 841 }else {
842 if (fDebug > 1) AliFatal(" Analysis type not defined !!! ");
843 return 0;
844 }
845
846 // only charged
847 if (!part->Charge())return 0;
848
416af868 849 part->SetUniqueID(fEventCounter * 100000 + ipart);
a75aacd6 850 return part;
851}
852
092db0d7 853//____________________________________________________________________
a75aacd6 854void AliAnalyseLeadingTrackUE::QSortTracks(TObjArray &a, Int_t first, Int_t last)
855{
856 // Sort array of TObjArray of tracks by Pt using a quicksort algorithm.
857
858 static TObject *tmp;
859 static int i; // "static" to save stack space
860 int j;
861
862 while (last - first > 1) {
863 i = first;
864 j = last;
865 for (;;) {
866 while (++i < last && ((AliVParticle*)a[i])->Pt() > ((AliVParticle*)a[first])->Pt() )
867 ;
868 while (--j > first && ((AliVParticle*)a[j])->Pt() < ((AliVParticle*)a[first])->Pt() )
869 ;
870 if (i >= j)
871 break;
872
873 tmp = a[i];
874 a[i] = a[j];
875 a[j] = tmp;
876 }
877 if (j == first) {
878 ++first;
879 continue;
880 }
881 tmp = a[first];
882 a[first] = a[j];
883 a[j] = tmp;
884 if (j - first < last - (j + 1)) {
885 QSortTracks(a, first, j);
886 first = j + 1; // QSortTracks(j + 1, last);
887 } else {
888 QSortTracks(a, j + 1, last);
889 last = j; // QSortTracks(first, j);
890 }
891 }
892}
893
894//____________________________________________________________________
895TObjArray* AliAnalyseLeadingTrackUE::SortRegions(const AliVParticle* leading, TObject* obj, TObject* arrayMC, Bool_t onlyprimaries)
896{
897
898 // Assign particles to towards, away or transverse regions.
899 // Returns a lists of particles for each region.
900
901 static const Double_t k60rad = 60.*TMath::Pi()/180.;
902 static const Double_t k120rad = 120.*TMath::Pi()/180.;
903
904 // Define output lists of particles
905 TList *toward = new TList();
906 TList *away = new TList();
907 // Two transverse regions, for the moment those are not yet MIN and MAX!!!
908 // MIN and MAX can be sorted in GetMinMaxRegion function
909 TList *transverse1 = new TList();
910 TList *transverse2 = new TList();
911
912 TObjArray *regionParticles = new TObjArray;
05c47aff 913 regionParticles->SetOwner(kTRUE);
914
a75aacd6 915 regionParticles->AddLast(toward);
916 regionParticles->AddLast(away);
917 regionParticles->AddLast(transverse1);
918 regionParticles->AddLast(transverse2);
919
920 if (!leading)
921 return regionParticles;
922
923 // Switch to vector for leading particle
924 TVector3 leadVect(leading->Px(),leading->Py(),leading->Pz());
925
926 Int_t nTracks = NParticles(obj);
927 if( !nTracks ) return 0;
928 // Loop over tracks
929 for (Int_t ipart=0; ipart<nTracks; ++ipart) {
930 AliVParticle* part = ParticleWithCuts(obj, ipart);
931 if (!part)continue;
932 //Switch to vectors for particles
933 TVector3 partVect(part->Px(), part->Py(), part->Pz());
934
935 Int_t region = 0;
97dc2b4e 936 if( TMath::Abs(partVect.Eta()) > fTrackEtaCut || TMath::Abs(partVect.Eta()) < fTrackEtaCutMin) continue;
a75aacd6 937 // transverse regions
938 if (leadVect.DeltaPhi(partVect) < -k60rad && leadVect.DeltaPhi(partVect) > -k120rad )region = -1; //left
939 if (leadVect.DeltaPhi(partVect) > k60rad && leadVect.DeltaPhi(partVect) < k120rad ) region = 1; //right
940
941 if (TMath::Abs(leadVect.DeltaPhi(partVect)) < k60rad ) region = 2; //forward
942 if (TMath::Abs(leadVect.DeltaPhi(partVect)) > k120rad ) region = -2; //backward
943
944 // skip leading particle
b1831bcb 945 if (leading == part)
a75aacd6 946 continue;
947
948 if (!region)continue;
949 if (arrayMC && arrayMC->InheritsFrom("TClonesArray") && obj->InheritsFrom("AliAODEvent")){
950 Int_t label = ((AliAODTrack*)part)->GetLabel();
951 // re-define part as the matched MC particle
952 part = (AliAODMCParticle*)ParticleWithCuts(arrayMC, TMath::Abs(label),onlyprimaries);
953 if (!part)continue;
954 // skip leading particle
955 if (leading == part)
956 continue;
957 }
958 if (arrayMC && arrayMC->InheritsFrom("AliMCEvent") && obj->InheritsFrom("AliESDEvent")){
959 Int_t label = ((AliESDtrack*)part)->GetLabel();
960 // look for the matched MC particle (but do not re-define part)
961 if (!ParticleWithCuts(arrayMC, TMath::Abs(label),onlyprimaries)) continue;
962 }
963
964 if ( region == 1 ) transverse1->Add(part);
965 if ( region == -1 ) transverse2->Add(part);
966 if ( region == 2 ) toward->Add(part);
967 if ( region == -2 ) away->Add(part);
968
969 }//end loop on tracks
970
971 return regionParticles;
972
973}
974
a75aacd6 975//____________________________________________________________________
976Bool_t AliAnalyseLeadingTrackUE::TriggerSelection(const TObject* obj)
977{
1c6b6c97 978 if (!obj) // MC
979 return kFALSE;
a75aacd6 980
85bfac17 981 // Use AliPhysicsSelection to select good events, works for ESD and AOD
5cabd2cd 982 if (!(((AliInputEventHandler*)obj)->IsEventSelected()&(fEventSelection)))
85bfac17 983 return kFALSE;
05c47aff 984
a75aacd6 985 return kTRUE;
a75aacd6 986}
987
988//____________________________________________________________________
989Bool_t AliAnalyseLeadingTrackUE::VertexSelection(const TObject* obj, Int_t ntracks, Double_t zed)
990{
991
992 //Require 1 vertex (no TPC stand-alone) with a minimum number of tracks and z-coordinate in a limited range
993
994 if (obj->InheritsFrom("AliAODEvent")){
995 Int_t nVertex = ((AliAODEvent*)obj)->GetNumberOfVertices();
996 if( nVertex > 0 ) {
997 AliAODVertex* vertex = (AliAODVertex*)((AliAODEvent*)obj)->GetPrimaryVertex();
144bd037 998 Int_t nTracksPrim = vertex->GetNContributors();
a75aacd6 999 Double_t zVertex = vertex->GetZ();
1000 if (fDebug > 1)AliInfo(Form(" Vertex in = %f with %d particles by %s data ...",zVertex,nTracksPrim,vertex->GetName()));
144bd037 1001 // Reject TPC only vertex
1002 TString name(vertex->GetName());
1003 if (name.CompareTo("PrimaryVertex") && name.CompareTo("SPDVertex"))return kFALSE;
1004
1005 // Select a quality vertex by number of tracks?
4da05e3e 1006 if( nTracksPrim < ntracks || TMath::Abs(zVertex) >= zed ) {
a75aacd6 1007 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event REJECTED ...");
1008 return kFALSE;
1009 }
1010 // TODO remove vertexer Z events with dispersion > 0.02: Doesn't work for AOD at present
1011 //if (strcmp(vertex->GetTitle(), "AliVertexerZ") == 0 && vertex->GetDispersion() > 0.02)
1012 // return kFALSE;
1013 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event ACCEPTED...");
1014 } else {
1015 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event REJECTED ...");
1016 return kFALSE;
1017 }
1018 }
1019
1020 if (obj->InheritsFrom("AliMCEvent"))
1021 {
4da05e3e 1022 if (TMath::Abs(((AliMCEvent*) obj)->GetPrimaryVertex()->GetZ()) >= zed)
a75aacd6 1023 {
1024 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event (based on MC) REJECTED ...");
1025 return kFALSE;
1026 }
1027 }
144bd037 1028
7dd4dec4 1029 if (obj->InheritsFrom("AliAODMCHeader"))
1030 {
4da05e3e 1031 if (TMath::Abs(((AliAODMCHeader*) obj)->GetVtxZ()) >= zed)
7dd4dec4 1032 {
1033 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event (based on MC) REJECTED ...");
1034 return kFALSE;
1035 }
1036 }
1037
144bd037 1038 // ESD case for DCA studies
1039 if (obj->InheritsFrom("AliESDEvent")){
1040 AliESDVertex* vertex = (AliESDVertex*)((AliESDEvent*)obj)->GetPrimaryVertex();
1041 if ( vertex){
1042 Int_t nTracksPrim = vertex->GetNContributors();
1043 Double_t zVertex = vertex->GetZ();
1044 if (fDebug > 1)AliInfo(Form(" Vertex in = %f with %d particles by %s data ...",zVertex,nTracksPrim,vertex->GetName()));
1045 // Reject SPD or TPC only vertex
1046 TString name(vertex->GetName());
1047 if (name.CompareTo("PrimaryVertex") && name.CompareTo("SPDVertex"))return kFALSE;
1048
1049 // Select a quality vertex by number of tracks?
4da05e3e 1050 if( nTracksPrim < ntracks || TMath::Abs(zVertex) >= zed ) {
144bd037 1051 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event REJECTED ...");
1052 return kFALSE;
1053 }
1054 // TODO remove vertexer Z events with dispersion > 0.02: Doesn't work for AOD at present
1055 //if (strcmp(vertex->GetTitle(), "AliVertexerZ") == 0 && vertex->GetDispersion() > 0.02)
1056 // return kFALSE;
1057 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event ACCEPTED...");
1058 } else {
1059 if (fDebug > 1) AliInfo(" Primary-vertex Selection: event REJECTED ...");
1060 return kFALSE;
1061 }
1062 }
a75aacd6 1063
1064 return kTRUE;
1065}
418b56c5 1066
1067//____________________________________________________________________
418b56c5 1068Bool_t AliAnalyseLeadingTrackUE::CheckTrack(AliVParticle * part)
1069{
1070 // check if the track status flags are set
1071
1072 UInt_t status=((AliVTrack*)part)->GetStatus();
1073 if ((status & fTrackStatus) == fTrackStatus)
1074 return kTRUE;
1075 return kFALSE;
1076}