]>
Commit | Line | Data |
---|---|---|
76d0b522 | 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 | * * | |
19 | * Class for the Selection of Non-Heavy-Flavour-Electrons trought * | |
20 | * the invariant mass method. The selection can be done from two * | |
21 | * different algorithms, which can be choosed calling the function * | |
22 | * "SetAlgorithm(TString Algorithm)". * | |
23 | * * | |
24 | * Authors: R.Bailhache, C.A.Schmidt * | |
25 | * * | |
26 | *************************************************************************************/ | |
27 | ||
28 | #include "TVector2.h" | |
29 | #include "THnSparse.h" | |
30 | #include "TMath.h" | |
31 | #include "TLorentzVector.h" | |
32 | #include "TParticle.h" | |
33 | #include "TList.h" | |
34 | #include "TDatabasePDG.h" | |
35 | ||
36 | #include "AliVEvent.h" | |
37 | #include "AliMCEvent.h" | |
38 | #include "AliESDEvent.h" | |
39 | #include "AliMCParticle.h" | |
40 | #include "AliAODMCParticle.h" | |
41 | #include "AliAODEvent.h" | |
42 | #include "AliAODVertex.h" | |
43 | #include "AliAODTrack.h" | |
44 | #include "AliVTrack.h" | |
45 | #include "AliESDtrack.h" | |
46 | #include "AliESDtrackCuts.h" | |
47 | #include "AliPIDResponse.h" | |
8a9b2231 | 48 | #include "AliPID.h" |
76d0b522 | 49 | |
50 | #include "AliKFParticle.h" | |
51 | #include "AliKFVertex.h" | |
52 | ||
53 | #include "AliHFEcuts.h" | |
54 | #include "AliHFEpid.h" | |
55 | #include "AliHFEpidQAmanager.h" | |
56 | #include "AliHFEtools.h" | |
57 | ||
58 | #include "AliHFENonPhotonicElectron.h" | |
59 | ||
60 | ClassImp(AliHFENonPhotonicElectron) | |
61 | //________________________________________________________________________ | |
62 | AliHFENonPhotonicElectron::AliHFENonPhotonicElectron(const char *name, const Char_t *title) | |
8a9b2231 | 63 | :TNamed (name, title) |
64 | ,fIsAOD (kFALSE) | |
65 | ,fMCEvent (NULL) | |
66 | ,fAODArrayMCInfo (NULL) | |
67 | ,fHFEBackgroundCuts (NULL) | |
68 | ,fPIDBackground (0x0) | |
69 | ,fPIDBackgroundQA (0) | |
70 | ,fkPIDRespons (NULL) | |
71 | ,fAlgorithmMA (kTRUE) | |
8a9b2231 | 72 | ,fChi2OverNDFCut (3.0) |
73 | ,fMaxDCA (3.0) | |
74 | // ,fMaxOpeningTheta (0.02) | |
75 | // ,fMaxOpeningPhi (0.1) | |
76 | ,fMaxOpening3D (TMath::Pi()) | |
77 | ,fMaxInvMass (1000) | |
78 | ,fSetMassConstraint (kFALSE) | |
4437a0d2 | 79 | ,fSelectCategory1tracks(kTRUE) |
80 | ,fSelectCategory2tracks(kFALSE) | |
bbeea05b | 81 | ,fITSmeanShift(0.) |
8a9b2231 | 82 | ,fArraytrack (NULL) |
83 | ,fCounterPoolBackground (0) | |
84 | ,fnumberfound (0) | |
85 | ,fListOutput (NULL) | |
86 | ,fAssElectron (NULL) | |
87 | ,fIncElectron (NULL) | |
88 | ,fUSign (NULL) | |
89 | ,fLSign (NULL) | |
c3e32eae | 90 | ,fUSmatches(NULL) |
91 | ,fLSmatches(NULL) | |
4437a0d2 | 92 | ,fHnsigmaITS(NULL) |
8a9b2231 | 93 | // ,fUSignAngle (NULL) |
94 | // ,fLSignAngle (NULL) | |
76d0b522 | 95 | { |
96 | // | |
97 | // Constructor | |
98 | // | |
8a9b2231 | 99 | fPIDBackground = new AliHFEpid("hfePidBackground"); |
76d0b522 | 100 | fPIDBackgroundQA = new AliHFEpidQAmanager; |
101 | } | |
102 | ||
103 | //________________________________________________________________________ | |
104 | AliHFENonPhotonicElectron::AliHFENonPhotonicElectron() | |
8a9b2231 | 105 | :TNamed () |
106 | ,fIsAOD (kFALSE) | |
107 | ,fMCEvent (NULL) | |
108 | ,fAODArrayMCInfo (NULL) | |
109 | ,fHFEBackgroundCuts (NULL) | |
110 | ,fPIDBackground (0x0) | |
111 | ,fPIDBackgroundQA (0) | |
112 | ,fkPIDRespons (NULL) | |
113 | ,fAlgorithmMA (kTRUE) | |
8a9b2231 | 114 | ,fChi2OverNDFCut (3.0) |
115 | ,fMaxDCA (3.0) | |
116 | // ,fMaxOpeningTheta (0.02) | |
117 | // ,fMaxOpeningPhi (0.1) | |
118 | ,fMaxOpening3D (TMath::TwoPi()) | |
119 | ,fMaxInvMass (1000) | |
120 | ,fSetMassConstraint (kFALSE) | |
4437a0d2 | 121 | ,fSelectCategory1tracks(kTRUE) |
122 | ,fSelectCategory2tracks(kFALSE) | |
bbeea05b | 123 | ,fITSmeanShift(0.) |
8a9b2231 | 124 | ,fArraytrack (NULL) |
125 | ,fCounterPoolBackground (0) | |
126 | ,fnumberfound (0) | |
127 | ,fListOutput (NULL) | |
128 | ,fAssElectron (NULL) | |
129 | ,fIncElectron (NULL) | |
130 | ,fUSign (NULL) | |
131 | ,fLSign (NULL) | |
c3e32eae | 132 | ,fUSmatches(NULL) |
133 | ,fLSmatches(NULL) | |
4437a0d2 | 134 | ,fHnsigmaITS(NULL) |
8a9b2231 | 135 | // ,fUSignAngle (NULL) |
136 | // ,fLSignAngle (NULL) | |
76d0b522 | 137 | { |
138 | // | |
139 | // Constructor | |
140 | // | |
141 | fPIDBackground = new AliHFEpid("hfePidBackground"); | |
142 | fPIDBackgroundQA = new AliHFEpidQAmanager; | |
143 | } | |
144 | ||
145 | //________________________________________________________________________ | |
146 | AliHFENonPhotonicElectron::AliHFENonPhotonicElectron(const AliHFENonPhotonicElectron &ref) | |
147 | :TNamed(ref) | |
8a9b2231 | 148 | ,fIsAOD (ref.fIsAOD) |
149 | ,fMCEvent (NULL) | |
150 | ,fAODArrayMCInfo (NULL) | |
151 | ,fHFEBackgroundCuts (ref.fHFEBackgroundCuts) | |
152 | ,fPIDBackground (ref.fPIDBackground) | |
153 | ,fPIDBackgroundQA (ref.fPIDBackgroundQA) | |
154 | ,fkPIDRespons (ref.fkPIDRespons) | |
155 | ,fAlgorithmMA (ref.fAlgorithmMA) | |
8a9b2231 | 156 | ,fChi2OverNDFCut (ref.fChi2OverNDFCut) |
157 | ,fMaxDCA (ref.fMaxDCA) | |
158 | // ,fMaxOpeningTheta (ref.fMaxOpeningTheta) | |
159 | // ,fMaxOpeningPhi (ref.fMaxOpeningPhi) | |
160 | ,fMaxOpening3D (ref.fMaxOpening3D) | |
161 | ,fMaxInvMass (ref.fMaxInvMass) | |
162 | ,fSetMassConstraint (ref.fSetMassConstraint) | |
4437a0d2 | 163 | ,fSelectCategory1tracks(ref.fSelectCategory1tracks) |
164 | ,fSelectCategory2tracks(ref.fSelectCategory2tracks) | |
bbeea05b | 165 | ,fITSmeanShift(ref.fITSmeanShift) |
8a9b2231 | 166 | ,fArraytrack (NULL) |
167 | ,fCounterPoolBackground (0) | |
168 | ,fnumberfound (0) | |
169 | ,fListOutput (ref.fListOutput) | |
170 | ,fAssElectron (ref.fAssElectron) | |
171 | ,fIncElectron (ref.fIncElectron) | |
172 | ,fUSign (ref.fUSign) | |
173 | ,fLSign (ref.fLSign) | |
c3e32eae | 174 | ,fUSmatches(ref.fUSmatches) |
175 | ,fLSmatches(ref.fLSmatches) | |
4437a0d2 | 176 | ,fHnsigmaITS(ref.fHnsigmaITS) |
8a9b2231 | 177 | // ,fUSignAngle (ref.fUSignAngle) |
178 | // ,fLSignAngle (ref.fLSignAngle) | |
76d0b522 | 179 | { |
180 | // | |
181 | // Copy Constructor | |
182 | // | |
183 | ref.Copy(*this); | |
184 | } | |
185 | ||
186 | //____________________________________________________________ | |
187 | AliHFENonPhotonicElectron &AliHFENonPhotonicElectron::operator=(const AliHFENonPhotonicElectron &ref){ | |
188 | // | |
189 | // Assignment operator | |
190 | // | |
191 | if(this == &ref) ref.Copy(*this); | |
192 | return *this; | |
193 | } | |
194 | ||
195 | //_________________________________________ | |
196 | AliHFENonPhotonicElectron::~AliHFENonPhotonicElectron() | |
197 | { | |
198 | // | |
199 | // Destructor | |
200 | // | |
8a9b2231 | 201 | if(fArraytrack) delete fArraytrack; |
202 | //if(fHFEBackgroundCuts) delete fHFEBackgroundCuts; | |
203 | if(fPIDBackground) delete fPIDBackground; | |
204 | if(fPIDBackgroundQA) delete fPIDBackgroundQA; | |
76d0b522 | 205 | } |
206 | ||
207 | //_____________________________________________________________________________________________ | |
208 | void AliHFENonPhotonicElectron::Init() | |
209 | { | |
210 | // | |
211 | // Init | |
212 | // | |
213 | ||
8a9b2231 | 214 | //printf("Analysis Mode for AliHFENonPhotonicElectron: %s Analysis\n", fIsAOD ? "AOD" : "ESD"); |
215 | ||
76d0b522 | 216 | if(!fListOutput) fListOutput = new TList; |
217 | fListOutput->SetName("HFENonPhotonicElectron"); | |
218 | fListOutput->SetOwner(); | |
219 | ||
8a9b2231 | 220 | if(!fHFEBackgroundCuts) fHFEBackgroundCuts = new AliHFEcuts(); |
221 | if(fIsAOD) fHFEBackgroundCuts->SetAOD(); | |
222 | fHFEBackgroundCuts->Initialize(); | |
223 | if(fHFEBackgroundCuts->IsQAOn()) { | |
224 | fListOutput->Add(fHFEBackgroundCuts->GetQAhistograms()); | |
225 | } | |
76d0b522 | 226 | |
227 | // Initialize PID | |
228 | if(!fPIDBackground) fPIDBackground = new AliHFEpid("default pid"); | |
8a9b2231 | 229 | if(fMCEvent || fAODArrayMCInfo) fPIDBackground->SetHasMCData(kTRUE); // does nothing since the fMCEvent are set afterwards at the moment |
230 | if(!fPIDBackground->GetNumberOfPIDdetectors()) | |
231 | { | |
232 | //fPIDBackground->AddDetector("TOF", 0); | |
233 | fPIDBackground->AddDetector("TPC", 0); | |
234 | } | |
76d0b522 | 235 | AliInfo("PID Background QA switched on"); |
236 | fPIDBackgroundQA->Initialize(fPIDBackground); | |
237 | fListOutput->Add(fPIDBackgroundQA->MakeList("HFENP_PID_Background")); | |
238 | fPIDBackground->SortDetectors(); | |
239 | ||
8a9b2231 | 240 | Int_t nBinsPt = 35; |
241 | //Double_t binLimPt[25] = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5, 1.75, 2., 2.25, 2.5, 3., 3.5, 4., 5., 6.}; | |
242 | Double_t binLimPt[36] = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5, 1.75, 2., 2.25, 2.5, 2.75, 3., 3.5, 4., 4.5, 5., 5.5, 6., 7., 8., 10., 12., 14., 16., 18., 20.}; | |
4437a0d2 | 243 | const Int_t kBinsEtaInclusive = 8; |
244 | Double_t binLimEtaInclusive[kBinsEtaInclusive+1] = {-0.8, -0.6, -0.4, -0.2, 0., 0.2, 0.4, 0.6, 0.8}; | |
245 | const Int_t kBinsEtaAssociated = 30; | |
246 | Double_t binLimEtaAssociat[kBinsEtaAssociated+1] = {-1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5}; | |
8a9b2231 | 247 | |
4437a0d2 | 248 | //Int_t nBinsP = 400; |
249 | //Double_t minP = 0.0; | |
250 | //Double_t maxP = 20.0; | |
251 | //Double_t binLimP[nBinsP+1]; | |
252 | //for(Int_t i=0; i<=nBinsP; i++) binLimP[i]=(Double_t)minP + (maxP-minP)/nBinsP*(Double_t)i ; | |
76d0b522 | 253 | |
254 | Int_t nBinsC = 11; | |
255 | Double_t minC = 0.0; | |
256 | Double_t maxC = 11.0; | |
257 | Double_t binLimC[nBinsC+1]; | |
258 | for(Int_t i=0; i<=nBinsC; i++) binLimC[i]=(Double_t)minC + (maxC-minC)/nBinsC*(Double_t)i ; | |
259 | ||
260 | Int_t nBinsSource = 10; | |
261 | Double_t minSource = 0.; | |
262 | Double_t maxSource = 10.; | |
263 | Double_t binLimSource[nBinsSource+1]; | |
264 | for(Int_t i=0; i<=nBinsSource; i++) binLimSource[i]=(Double_t)minSource + (maxSource-minSource)/nBinsSource*(Double_t)i ; | |
265 | ||
4437a0d2 | 266 | Int_t nBinsInvMass = 100; |
76d0b522 | 267 | Double_t minInvMass = 0.; |
4437a0d2 | 268 | Double_t maxInvMass = 1.; |
76d0b522 | 269 | Double_t binLimInvMass[nBinsInvMass+1]; |
270 | for(Int_t i=0; i<=nBinsInvMass; i++) binLimInvMass[i]=(Double_t)minInvMass + (maxInvMass-minInvMass)/nBinsInvMass*(Double_t)i ; | |
271 | ||
272 | Int_t nBinsPhi = 180; | |
273 | Double_t minPhi = 0.0; | |
274 | Double_t maxPhi = TMath::Pi(); | |
275 | Double_t binLimPhi[nBinsPhi+1]; | |
276 | for(Int_t i=0; i<=nBinsPhi; i++) | |
277 | { | |
278 | binLimPhi[i]=(Double_t)minPhi + (maxPhi-minPhi)/nBinsPhi*(Double_t)i ; | |
279 | AliDebug(2,Form("bin phi is %f for %d",binLimPhi[i],i)); | |
280 | } | |
281 | ||
282 | Int_t nBinsAngle = 180; | |
283 | Double_t minAngle = 0.0; | |
284 | Double_t maxAngle = TMath::Pi(); | |
285 | Double_t binLimAngle[nBinsAngle+1]; | |
286 | for(Int_t i=0; i<=nBinsAngle; i++) | |
287 | { | |
288 | binLimAngle[i]=(Double_t)minAngle + (maxAngle-minAngle)/nBinsAngle*(Double_t)i ; | |
8a9b2231 | 289 | AliDebug(2,Form("bin phi is %f for %d",binLimAngle[i],i)); |
290 | } | |
291 | ||
4437a0d2 | 292 | // Constrain histograms |
293 | const Int_t nDimSingle=4; | |
294 | const Int_t nDimPair=9; | |
295 | Int_t nBinPair[nDimPair] = {nBinsPhi,nBinsC,nBinsPt,nBinsInvMass,nBinsSource,nBinsAngle,nBinsPt,kBinsEtaInclusive,kBinsEtaAssociated}; | |
296 | ||
8a9b2231 | 297 | // Associated Electron |
4437a0d2 | 298 | Int_t nBinAssElectron[nDimSingle] = {nBinsC,nBinsPt,nBinsSource,kBinsEtaAssociated}; |
299 | fAssElectron = new THnSparseF("fAssElectron","fAssElectron",nDimSingle,nBinAssElectron); | |
8a9b2231 | 300 | fAssElectron->SetBinEdges(0,binLimC); |
301 | fAssElectron->SetBinEdges(1,binLimPt); | |
302 | fAssElectron->SetBinEdges(2,binLimSource); | |
4437a0d2 | 303 | fAssElectron->SetBinEdges(3,binLimEtaAssociat); |
8a9b2231 | 304 | fAssElectron->Sumw2(); |
305 | AliDebug(2,"AliHFENonPhotonicElectron: fAssElectron"); | |
306 | ||
307 | // Inclusive Electron | |
4437a0d2 | 308 | Int_t nBinIncElectron[nDimSingle] = {nBinsC,nBinsPt,nBinsSource,kBinsEtaInclusive}; |
309 | fIncElectron = new THnSparseF("fIncElectron","fIncElectron",nDimSingle,nBinIncElectron); | |
8a9b2231 | 310 | fIncElectron->SetBinEdges(0,binLimC); |
311 | fIncElectron->SetBinEdges(1,binLimPt); | |
312 | fIncElectron->SetBinEdges(2,binLimSource); | |
4437a0d2 | 313 | fIncElectron->SetBinEdges(3,binLimEtaInclusive); |
8a9b2231 | 314 | fIncElectron->Sumw2(); |
315 | AliDebug(2,"AliHFENonPhotonicElectron: fIncElectron"); | |
76d0b522 | 316 | |
317 | // ee invariant mass Unlike Sign | |
4437a0d2 | 318 | fUSign = new THnSparseF("fUSign","fUSign",nDimPair,nBinPair); |
959ea9d8 | 319 | fUSign->SetBinEdges(0,binLimPhi); |
320 | fUSign->SetBinEdges(1,binLimC); | |
321 | fUSign->SetBinEdges(2,binLimPt); | |
322 | fUSign->SetBinEdges(3,binLimInvMass); | |
323 | fUSign->SetBinEdges(4,binLimSource); | |
324 | fUSign->SetBinEdges(5,binLimAngle); | |
8a9b2231 | 325 | fUSign->SetBinEdges(6,binLimPt); |
4437a0d2 | 326 | fUSign->SetBinEdges(7,binLimEtaInclusive); |
327 | fUSign->SetBinEdges(8,binLimEtaAssociat); | |
959ea9d8 | 328 | fUSign->Sumw2(); |
329 | AliDebug(2,"AliHFENonPhotonicElectron: fUSign"); | |
76d0b522 | 330 | |
331 | // ee invariant mass Like Sign | |
4437a0d2 | 332 | fLSign = new THnSparseF("fLSign","fLSign",nDimPair,nBinPair); |
959ea9d8 | 333 | fLSign->SetBinEdges(0,binLimPhi); |
334 | fLSign->SetBinEdges(1,binLimC); | |
335 | fLSign->SetBinEdges(2,binLimPt); | |
336 | fLSign->SetBinEdges(3,binLimInvMass); | |
337 | fLSign->SetBinEdges(4,binLimSource); | |
338 | fLSign->SetBinEdges(5,binLimAngle); | |
8a9b2231 | 339 | fLSign->SetBinEdges(6,binLimPt); |
4437a0d2 | 340 | fLSign->SetBinEdges(7,binLimEtaInclusive); |
341 | fLSign->SetBinEdges(8,binLimEtaAssociat); | |
959ea9d8 | 342 | fLSign->Sumw2(); |
343 | AliDebug(2,"AliHFENonPhotonicElectron: fLSign"); | |
344 | ||
c3e32eae | 345 | // Histograms counting the number of like sign / unlike sign matches per inclusive track |
346 | const Int_t nBinsMatches = 50; | |
347 | Double_t binLimMatches[nBinsMatches+1]; | |
348 | for(int ib = 0; ib <= nBinsMatches; ib++) binLimMatches[ib] = ib; | |
349 | const Int_t nDimMatches = 3; // centrality, pt_inc, number of matches | |
350 | const Int_t nBinsMatchHist[nDimMatches] = {nBinsC, nBinsPt, nBinsMatches}; | |
351 | fUSmatches = new THnSparseF("fUSmatches", "fUSmatches", nDimMatches, nBinsMatchHist); | |
352 | fUSmatches->SetBinEdges(0,binLimC); | |
353 | fUSmatches->SetBinEdges(1,binLimPt); | |
354 | fUSmatches->SetBinEdges(2,binLimMatches); | |
355 | ||
356 | fLSmatches = new THnSparseF("fLSmatches", "fLSmatches", nDimMatches, nBinsMatchHist); | |
357 | fLSmatches->SetBinEdges(0,binLimC); | |
358 | fLSmatches->SetBinEdges(1,binLimPt); | |
359 | fLSmatches->SetBinEdges(2,binLimMatches); | |
360 | ||
959ea9d8 | 361 | /* |
76d0b522 | 362 | // ee angle Unlike Sign |
363 | const Int_t nDimUSignAngle=3; | |
364 | Int_t nBinUSignAngle[nDimUSignAngle] = {nBinsAngle,nBinsC,nBinsSource}; | |
365 | fUSignAngle = new THnSparseF("fUSignAngle","fUSignAngle",nDimUSignAngle,nBinUSignAngle); | |
366 | fUSignAngle->SetBinEdges(0,binLimAngle); | |
367 | fUSignAngle->SetBinEdges(1,binLimC); | |
368 | fUSignAngle->SetBinEdges(2,binLimSource); | |
76d0b522 | 369 | fUSignAngle->Sumw2(); |
370 | AliDebug(2,"AliHFENonPhotonicElectron: fUSignAngle"); | |
371 | ||
372 | // ee angle Like Sign | |
373 | const Int_t nDimLSignAngle=3; | |
374 | Int_t nBinLSignAngle[nDimLSignAngle] = {nBinsAngle,nBinsC,nBinsSource}; | |
375 | fLSignAngle = new THnSparseF("fLSignAngle","fLSignAngle",nDimLSignAngle,nBinLSignAngle); | |
376 | fLSignAngle->SetBinEdges(0,binLimAngle); | |
377 | fLSignAngle->SetBinEdges(1,binLimC); | |
378 | fLSignAngle->SetBinEdges(2,binLimSource); | |
76d0b522 | 379 | fLSignAngle->Sumw2(); |
380 | AliDebug(2,"AliHFENonPhotonicElectron: fLSignAngle"); | |
959ea9d8 | 381 | */ |
76d0b522 | 382 | |
4437a0d2 | 383 | // control histogram for ITS PID |
384 | fHnsigmaITS = new TH2F("fHnsigmaITS", "Number of sigmas in the ITS", 30, 0., 0.3, 1200, -10., 10.); | |
385 | ||
8a9b2231 | 386 | fListOutput->Add(fAssElectron); |
387 | fListOutput->Add(fIncElectron); | |
959ea9d8 | 388 | fListOutput->Add(fUSign); |
389 | fListOutput->Add(fLSign); | |
c3e32eae | 390 | fListOutput->Add(fUSmatches); |
391 | fListOutput->Add(fLSmatches); | |
4437a0d2 | 392 | fListOutput->Add(fHnsigmaITS); |
959ea9d8 | 393 | // fListOutput->Add(fUSignAngle); |
394 | // fListOutput->Add(fLSignAngle); | |
76d0b522 | 395 | |
396 | } | |
397 | ||
398 | //_____________________________________________________________________________________________ | |
663a2523 | 399 | void AliHFENonPhotonicElectron::InitRun(const AliVEvent *inputEvent,const AliPIDResponse *pidResponse) |
76d0b522 | 400 | { |
401 | // | |
402 | // Init run | |
403 | // | |
404 | ||
405 | if(!pidResponse) | |
406 | { | |
407 | AliDebug(1, "Using default PID Response"); | |
408 | Bool_t hasmc = kFALSE; | |
409 | if(fMCEvent || fAODArrayMCInfo) hasmc=kTRUE; | |
410 | pidResponse = AliHFEtools::GetDefaultPID(hasmc, inputEvent->IsA() == AliESDEvent::Class()); | |
411 | } | |
412 | ||
413 | if(!fPIDBackground) return; | |
414 | fPIDBackground->SetPIDResponse(pidResponse); | |
415 | ||
416 | if(!fPIDBackground->IsInitialized()) | |
417 | { | |
418 | // Initialize PID with the given run number | |
419 | fPIDBackground->InitializePID(inputEvent->GetRunNumber()); | |
420 | } | |
421 | ||
422 | } | |
423 | ||
424 | //_____________________________________________________________________________________________ | |
8a9b2231 | 425 | Int_t AliHFENonPhotonicElectron::FillPoolAssociatedTracks(AliVEvent *inputEvent, Int_t binct) |
76d0b522 | 426 | { |
427 | // | |
428 | // Fill the pool of associated tracks | |
429 | // Return the number of associated tracks | |
430 | // | |
431 | ||
8a9b2231 | 432 | fnumberfound = 0; |
433 | ||
4437a0d2 | 434 | fHFEBackgroundCuts->SetRecEvent(inputEvent); |
76d0b522 | 435 | Int_t nbtracks = inputEvent->GetNumberOfTracks(); |
436 | ||
4437a0d2 | 437 | if( fArraytrack ){ |
76d0b522 | 438 | fArraytrack->~TArrayI(); |
439 | new(fArraytrack) TArrayI(nbtracks); | |
4437a0d2 | 440 | } else { |
76d0b522 | 441 | fArraytrack = new TArrayI(nbtracks); |
442 | } | |
443 | ||
444 | fCounterPoolBackground = 0; | |
445 | ||
4437a0d2 | 446 | Bool_t isSelected(kFALSE); |
447 | Bool_t isAOD = (dynamic_cast<AliAODEvent *>(inputEvent) != NULL); | |
448 | AliDebug(2, Form("isAOD: %s", isAOD ? "yes" : "no")); | |
449 | for(Int_t k = 0; k < nbtracks; k++) { | |
76d0b522 | 450 | AliVTrack *track = (AliVTrack *) inputEvent->GetTrack(k); |
451 | if(!track) continue; | |
4437a0d2 | 452 | |
453 | // | |
454 | isSelected = kFALSE; | |
455 | if(fSelectCategory1tracks && FilterCategory1Track(track, isAOD, binct)) isSelected = kTRUE; | |
456 | else if(fSelectCategory2tracks && FilterCategory2Track(track, isAOD)) isSelected = kTRUE; | |
457 | ||
458 | if(isSelected){ | |
459 | AliDebug(2,Form("fCounterPoolBackground %d, track %d",fCounterPoolBackground,k)); | |
460 | fArraytrack->AddAt(k,fCounterPoolBackground); | |
461 | fCounterPoolBackground++; | |
76d0b522 | 462 | } |
463 | } // loop tracks | |
464 | ||
8a9b2231 | 465 | //printf(Form("Associated Pool: Tracks %d, fCounterPoolBackground %d \n", nbtracks, fCounterPoolBackground)); |
76d0b522 | 466 | |
467 | return fCounterPoolBackground; | |
8a9b2231 | 468 | |
469 | } | |
470 | ||
471 | //_____________________________________________________________________________________________ | |
472 | Int_t AliHFENonPhotonicElectron::CountPoolAssociated(AliVEvent *inputEvent, Int_t binct) | |
473 | { | |
474 | // | |
475 | // Count the pool of assiocated tracks | |
476 | // | |
477 | ||
478 | ||
479 | if(fnumberfound > 0) //!count only events with an inclusive electron | |
480 | { | |
4437a0d2 | 481 | Double_t valueAssElectron[4] = { binct, -1, -1}; //Centrality Pt Source |
8a9b2231 | 482 | Int_t iTrack2 = 0; |
483 | Int_t indexmother2 = -1; | |
484 | AliVTrack *track2 = 0x0; | |
485 | ||
c3e32eae | 486 | for(Int_t ii = 0; ii < fCounterPoolBackground; ii++){ |
8a9b2231 | 487 | iTrack2 = fArraytrack->At(ii); |
488 | AliDebug(2,Form("track %d",iTrack2)); | |
489 | track2 = (AliVTrack *)inputEvent->GetTrack(iTrack2); | |
490 | ||
c3e32eae | 491 | if(!track2){ |
492 | //printf("ERROR: Could not receive track %d", iTrack2); | |
493 | continue; | |
8a9b2231 | 494 | } |
495 | ||
496 | // if MC look | |
c3e32eae | 497 | if(fMCEvent || fAODArrayMCInfo) valueAssElectron[2] = FindMother(TMath::Abs(track2->GetLabel()), indexmother2) ; |
8a9b2231 | 498 | |
499 | fkPIDRespons = fPIDBackground->GetPIDResponse(); | |
500 | ||
501 | valueAssElectron[1] = track2->Pt() ; | |
4437a0d2 | 502 | valueAssElectron[3] = track2->Eta() ; |
8a9b2231 | 503 | |
504 | fAssElectron->Fill( valueAssElectron) ; | |
505 | } | |
506 | //printf(Form("Associated Pool: fCounterPoolBackground %d \n", fCounterPoolBackground)); | |
507 | } | |
508 | return fnumberfound; | |
76d0b522 | 509 | } |
510 | ||
511 | //_____________________________________________________________________________________________ | |
512 | Int_t AliHFENonPhotonicElectron::LookAtNonHFE(Int_t iTrack1, AliVTrack *track1, AliVEvent *vEvent, Double_t weight, Int_t binct, Double_t deltaphi, Int_t source, Int_t indexmother) | |
513 | { | |
514 | // | |
515 | // Look At Non HFE | |
516 | // | |
517 | ||
518 | /*********************************************************************************** | |
519 | * * | |
520 | * iTrack1: index of the tagged electrons in AliVEvent * | |
521 | * track1: tagged electron * | |
522 | * vEvent: event * | |
523 | * weight: weight in pt if not realistic * | |
524 | * binct: centrality bin * | |
525 | * deltaphi: phi-phi event plane for v2 * | |
526 | * source: MC sources * | |
527 | * indexmother: MC index mother * | |
528 | * * | |
529 | * * | |
530 | * return -1 if nothing * | |
531 | * return 2 if opposite charge within the mass range * | |
532 | * return 4 if like charge within the mass range * | |
533 | * return 6 if opposite & like charge within the mass range * | |
534 | * * | |
535 | ***********************************************************************************/ | |
536 | ||
537 | AliAODEvent *aodeventu = dynamic_cast<AliAODEvent*>(vEvent); | |
538 | Int_t taggedphotonic = -1; | |
539 | ||
540 | AliDebug(2,Form("fCounterPoolBackground %d in LookAtNonHFE!!!",fCounterPoolBackground)); | |
541 | if(!fArraytrack) return taggedphotonic; | |
542 | AliDebug(2,Form("process track %d",iTrack1)); | |
39427568 | 543 | AliDebug(1,Form("Inclusive source is %d\n", source)); |
76d0b522 | 544 | |
8a9b2231 | 545 | fkPIDRespons = fPIDBackground->GetPIDResponse(); |
76d0b522 | 546 | |
8a9b2231 | 547 | //Set Fill-Arrays for THnSparse |
4437a0d2 | 548 | Double_t valueIncElectron[4] = { binct, track1->Pt(), source, track1->Eta()}; //Centrality Pt Source P |
549 | Double_t valueSign[9] = { deltaphi, binct, track1->Pt(), -1, source, -1, -1, track1->Eta(), -1}; //DeltaPhi Centrality Pt InvariantMass Source Angle Pt | |
8a9b2231 | 550 | //Double_t valueAngle[3] = { -1, binct, source}; //Angle Centrality Source |
76d0b522 | 551 | |
552 | Int_t pdg1 = CheckPdg(TMath::Abs(track1->GetLabel())); | |
4437a0d2 | 553 | AliKFParticle::SetField(vEvent->GetMagneticField()); |
554 | AliKFVertex primV(*(vEvent->GetPrimaryVertex())); | |
8a9b2231 | 555 | |
4437a0d2 | 556 | AliVTrack *track2(NULL); |
76d0b522 | 557 | Int_t iTrack2 = 0; |
76d0b522 | 558 | Int_t indexmother2 = -1; |
8a9b2231 | 559 | Int_t pdg2 = -100; |
560 | Int_t source2 = -1; | |
8a9b2231 | 561 | Float_t fCharge2 = 0; |
562 | ||
c3e32eae | 563 | // count number of matches with opposite/same sign track in the given mass range |
564 | Int_t countsMatchLikesign(0), | |
565 | countsMatchUnlikesign(0); | |
566 | ||
4437a0d2 | 567 | // Values to fill |
568 | Double_t angle(-1.); | |
569 | Double_t invmass(-1); | |
76d0b522 | 570 | |
8a9b2231 | 571 | Float_t fCharge1 = track1->Charge(); //Charge from track1 |
76d0b522 | 572 | |
8a9b2231 | 573 | Bool_t kUSignPhotonic = kFALSE; |
574 | Bool_t kLSignPhotonic = kFALSE; | |
76d0b522 | 575 | |
8a9b2231 | 576 | //! FILL Inclusive Electron |
577 | fIncElectron->Fill(valueIncElectron,weight); | |
578 | fnumberfound++; | |
579 | //printf(Form("Inclusive Pool: TrackNr. %d, fnumberfound %d \n", iTrack1, fnumberfound)); | |
76d0b522 | 580 | |
c3e32eae | 581 | for(Int_t idex = 0; idex < fCounterPoolBackground; idex++){ |
76d0b522 | 582 | iTrack2 = fArraytrack->At(idex); |
583 | AliDebug(2,Form("track %d",iTrack2)); | |
584 | track2 = (AliVTrack *)vEvent->GetTrack(iTrack2); | |
585 | ||
c3e32eae | 586 | if(!track2){ |
8a9b2231 | 587 | //printf("ERROR: Could not receive track %d", iTrack2); |
76d0b522 | 588 | continue; |
589 | } | |
590 | ||
76d0b522 | 591 | fCharge2 = track2->Charge(); //Charge from track2 |
592 | ||
593 | // Reset the MC info | |
959ea9d8 | 594 | //valueAngle[2] = source; |
595 | valueSign[4] = source; | |
8a9b2231 | 596 | valueSign[6] = track2->Pt(); |
4437a0d2 | 597 | valueSign[8] = track2->Eta(); |
76d0b522 | 598 | |
599 | // track cuts and PID already done | |
600 | ||
8a9b2231 | 601 | // Checking if it is the same Track! |
602 | if(iTrack2==iTrack1) continue; | |
603 | AliDebug(2,"Different"); | |
604 | ||
76d0b522 | 605 | // if MC look |
c3e32eae | 606 | if(fMCEvent || fAODArrayMCInfo){ |
39427568 | 607 | AliDebug(2, "Checking for source"); |
76d0b522 | 608 | source2 = FindMother(TMath::Abs(track2->GetLabel()), indexmother2); |
39427568 | 609 | AliDebug(2, Form("source is %d", source2)); |
76d0b522 | 610 | pdg2 = CheckPdg(TMath::Abs(track2->GetLabel())); |
611 | ||
39427568 | 612 | if(source == kElectronfromconversion){ |
613 | AliDebug(2, Form("Electron from conversion (source %d), paired with source %d", source, source2)); | |
614 | AliDebug(2, Form("Index of the mothers: incl %d, associated %d", indexmother, indexmother2)); | |
615 | AliDebug(2, Form("PDGs: incl %d, associated %d", pdg1, pdg2)); | |
616 | } | |
617 | ||
c3e32eae | 618 | if(source2 >=0 ){ |
619 | if((indexmother2 == indexmother) && (source == source2) && ((pdg1*pdg2)<0.0)){ | |
39427568 | 620 | AliDebug(1, "Real pair"); |
c3e32eae | 621 | switch(source){ |
4437a0d2 | 622 | case kElectronfromconversion: |
623 | valueSign[4] = kElectronfromconversionboth; | |
624 | break; | |
625 | case kElectronfrompi0: | |
626 | valueSign[4] = kElectronfrompi0both; | |
627 | break; | |
628 | case kElectronfrometa: | |
629 | valueSign[4] = kElectronfrometaboth; | |
630 | break; | |
c3e32eae | 631 | }; |
632 | } | |
76d0b522 | 633 | } |
634 | } | |
635 | ||
4437a0d2 | 636 | if(fAlgorithmMA){ |
637 | // Use TLorentzVector | |
638 | if(!MakePairDCA(track1, track2, vEvent, (aodeventu != NULL), invmass, angle)) continue; | |
c3e32eae | 639 | } else { |
4437a0d2 | 640 | // Use AliKF package |
641 | if(!MakePairKF(track1, track2, primV, invmass, angle)) continue; | |
642 | } | |
76d0b522 | 643 | |
4437a0d2 | 644 | valueSign[3] = invmass; |
645 | valueSign[5] = angle; | |
76d0b522 | 646 | |
4437a0d2 | 647 | //if((fCharge1*fCharge2)>0.0) fLSignAngle->Fill(&valueAngle[0],weight); |
648 | //else fUSignAngle->Fill(&valueAngle[0],weight); | |
76d0b522 | 649 | |
4437a0d2 | 650 | if(angle > fMaxOpening3D) continue; //! Cut on Opening Angle |
651 | if(invmass > fMaxInvMass) continue; //! Cut on Invariant Mass | |
8a9b2231 | 652 | |
4437a0d2 | 653 | if((fCharge1*fCharge2)>0.0){ |
654 | if(invmass < 1.0) fLSign->Fill( valueSign, weight); | |
655 | // count like-sign background matched pairs per inclusive based on mass cut | |
656 | if(invmass < 0.14) countsMatchLikesign++; | |
39427568 | 657 | AliDebug(1, "Selected Like sign"); |
4437a0d2 | 658 | } else { |
659 | if(invmass < 1.0)fUSign->Fill( valueSign, weight); | |
660 | // count unlike-sign matched pairs per inclusive based on mass cut | |
661 | if(invmass < 0.14) countsMatchUnlikesign++; | |
39427568 | 662 | AliDebug(1, "Selected Unike sign"); |
76d0b522 | 663 | } |
4437a0d2 | 664 | |
665 | if((fCharge1*fCharge2)>0.0) kLSignPhotonic=kTRUE; | |
666 | else kUSignPhotonic=kTRUE; | |
76d0b522 | 667 | } |
668 | ||
c3e32eae | 669 | // Fill counted |
670 | Double_t valCountsLS[3] = {binct, track1->Pt(), countsMatchLikesign}, | |
671 | valCountsUS[3] = {binct, track1->Pt(), countsMatchUnlikesign}; | |
672 | fUSmatches->Fill(valCountsUS); | |
673 | fLSmatches->Fill(valCountsLS); | |
674 | ||
8a9b2231 | 675 | if( kUSignPhotonic && kLSignPhotonic) taggedphotonic = 6; |
676 | if(!kUSignPhotonic && kLSignPhotonic) taggedphotonic = 4; | |
677 | if( kUSignPhotonic && !kLSignPhotonic) taggedphotonic = 2; | |
76d0b522 | 678 | |
679 | return taggedphotonic; | |
680 | } | |
681 | ||
682 | //_________________________________________________________________________ | |
39427568 | 683 | Int_t AliHFENonPhotonicElectron::FindMother(Int_t tr, Int_t &indexmother) const { |
76d0b522 | 684 | // |
685 | // Find the mother if MC | |
686 | // | |
687 | ||
688 | if(!fMCEvent && !fAODArrayMCInfo) return 0; | |
689 | ||
690 | Int_t pdg = CheckPdg(tr); | |
691 | if(TMath::Abs(pdg)!= 11) | |
692 | { | |
693 | indexmother = -1; | |
694 | return kNoElectron; | |
695 | } | |
696 | ||
697 | indexmother = IsMotherGamma(tr); | |
698 | if(indexmother > 0) return kElectronfromconversion; | |
699 | indexmother = IsMotherPi0(tr); | |
700 | if(indexmother > 0) return kElectronfrompi0; | |
701 | indexmother = IsMotherC(tr); | |
702 | if(indexmother > 0) return kElectronfromC; | |
703 | indexmother = IsMotherB(tr); | |
704 | if(indexmother > 0) return kElectronfromB; | |
705 | indexmother = IsMotherEta(tr); | |
706 | if(indexmother > 0) return kElectronfrometa; | |
707 | ||
708 | return kElectronfromother; | |
709 | } | |
710 | ||
711 | //________________________________________________________________________________________________ | |
39427568 | 712 | Int_t AliHFENonPhotonicElectron::CheckPdg(Int_t tr) const { |
76d0b522 | 713 | |
714 | // | |
715 | // Return the pdg of the particle | |
716 | // | |
717 | ||
718 | Int_t pdgcode = -1; | |
719 | if(tr < 0) return pdgcode; | |
720 | ||
39427568 | 721 | AliMCParticle *mctrackesd = NULL; AliAODMCParticle *mctrackaod = NULL; |
722 | if(fMCEvent){ | |
76d0b522 | 723 | AliVParticle *mctrack = fMCEvent->GetTrack(tr); |
39427568 | 724 | if(mctrack){ |
725 | if((mctrackesd = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tr))))) pdgcode = mctrackesd->PdgCode(); | |
726 | else if((mctrackaod = dynamic_cast<AliAODMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tr))))) pdgcode = mctrackaod->GetPdgCode(); | |
727 | } | |
728 | } else if(fAODArrayMCInfo) { | |
729 | if(tr < fAODArrayMCInfo->GetEntriesFast()){ | |
730 | mctrackaod = (AliAODMCParticle *) fAODArrayMCInfo->At(tr); | |
731 | if(mctrackaod) return pdgcode = mctrackaod->GetPdgCode(); | |
732 | } | |
76d0b522 | 733 | } |
734 | ||
735 | return pdgcode; | |
736 | } | |
737 | ||
738 | //_______________________________________________________________________________________________ | |
39427568 | 739 | Int_t AliHFENonPhotonicElectron::GetMotherPDG(Int_t tr, Int_t &motherIndex) const { |
76d0b522 | 740 | // |
39427568 | 741 | // Returns the mother PDG of the track (return value) and the index of the |
742 | // mother track | |
76d0b522 | 743 | // |
76d0b522 | 744 | if(tr < 0) return -1; |
745 | ||
39427568 | 746 | Int_t pdg(-1); |
747 | AliMCParticle *mctrackesd(NULL); AliAODMCParticle *mctrackaod(NULL); | |
748 | ||
749 | motherIndex = -1; | |
750 | if(fMCEvent) { | |
751 | AliDebug(2, "Using MC Event"); | |
76d0b522 | 752 | AliVParticle *mctrack = fMCEvent->GetTrack(tr); |
39427568 | 753 | if(mctrack){ |
754 | if((mctrackesd = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tr))))){ | |
755 | // Case ESD | |
756 | TParticle *particle = mctrackesd->Particle(); | |
757 | ||
758 | // Take mother | |
759 | if(particle){ | |
760 | motherIndex = particle->GetFirstMother(); | |
761 | if(motherIndex >= 0){ | |
762 | AliMCParticle *mothertrack = NULL; | |
763 | if((mothertrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(motherIndex))))){ | |
764 | TParticle * mother = mothertrack->Particle(); | |
765 | pdg = mother->GetPdgCode(); | |
766 | } | |
767 | } | |
768 | } | |
769 | } else if((mctrackaod = dynamic_cast<AliAODMCParticle *>(fMCEvent->GetTrack(TMath::Abs(tr))))){ | |
770 | // Case AOD | |
771 | // Take mother | |
772 | motherIndex = mctrackaod->GetMother(); | |
773 | if(motherIndex >= 0){ | |
774 | AliAODMCParticle *mothertrack = dynamic_cast<AliAODMCParticle *>(fMCEvent->GetTrack(motherIndex)); | |
775 | if(mothertrack) pdg = mothertrack->GetPdgCode(); | |
776 | } | |
777 | } | |
778 | } | |
779 | } else if(fAODArrayMCInfo) { | |
780 | AliDebug(2, "Using AOD list"); | |
781 | if(tr < fAODArrayMCInfo->GetEntriesFast()){ | |
782 | mctrackaod = (AliAODMCParticle *) fAODArrayMCInfo->At(tr); | |
783 | ||
784 | // Take mother | |
785 | if(mctrackaod){ | |
786 | motherIndex = mctrackaod->GetMother(); | |
787 | if(motherIndex >= 0 && motherIndex < fAODArrayMCInfo->GetEntriesFast()){ | |
788 | AliAODMCParticle *mothertrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(TMath::Abs(motherIndex))); | |
789 | if(mothertrack) pdg = mothertrack->GetPdgCode(); | |
790 | } | |
791 | } | |
76d0b522 | 792 | } |
76d0b522 | 793 | } |
39427568 | 794 | return pdg; |
795 | } | |
76d0b522 | 796 | |
39427568 | 797 | //_______________________________________________________________________________________________ |
798 | Int_t AliHFENonPhotonicElectron::IsMotherGamma(Int_t tr) const { | |
799 | ||
800 | // | |
801 | // Return the lab of gamma mother or -1 if not gamma | |
802 | // | |
803 | ||
804 | Int_t imother(-1), pdg(-1); | |
805 | pdg = GetMotherPDG(tr, imother); | |
806 | ||
807 | // Check gamma | |
808 | if(imother >= 0){ | |
809 | if(TMath::Abs(pdg) == 22){ | |
810 | AliDebug(2, "Gamma Mother selected"); | |
811 | return imother; | |
812 | } | |
813 | if(TMath::Abs(pdg) == 11){ | |
814 | AliDebug(2, "Mother is electron - look further in hierarchy"); | |
76d0b522 | 815 | return IsMotherGamma(imother); |
816 | } | |
39427568 | 817 | AliDebug(2, "Nothing selected"); |
76d0b522 | 818 | return -1; |
819 | } | |
39427568 | 820 | AliDebug(2, "Not mother"); |
76d0b522 | 821 | return -1; |
822 | } | |
823 | ||
824 | //________________________________________________________________________________________________ | |
39427568 | 825 | Int_t AliHFENonPhotonicElectron::IsMotherPi0(Int_t tr) const { |
76d0b522 | 826 | |
827 | // | |
828 | // Return the lab of pi0 mother or -1 if not pi0 | |
829 | // | |
830 | ||
39427568 | 831 | Int_t imother(-1), pdg(-1); |
832 | pdg = GetMotherPDG(tr, imother); | |
76d0b522 | 833 | |
39427568 | 834 | // Check pi0 |
835 | if(imother >= 0){ | |
836 | if(TMath::Abs(pdg) == 111){ | |
837 | AliDebug(2, "Pi0 Mother selected"); | |
838 | return imother; | |
76d0b522 | 839 | } |
39427568 | 840 | if(TMath::Abs(pdg) == 11){ |
841 | AliDebug(2, "Mother is electron - look further in hierarchy"); | |
76d0b522 | 842 | return IsMotherPi0(imother); |
843 | } | |
39427568 | 844 | AliDebug(2, "Nothing selected"); |
76d0b522 | 845 | return -1; |
846 | } | |
39427568 | 847 | AliDebug(2, "Not mother"); |
76d0b522 | 848 | return -1; |
849 | } | |
850 | //________________________________________________________________________________________________ | |
39427568 | 851 | Int_t AliHFENonPhotonicElectron::IsMotherC(Int_t tr) const { |
76d0b522 | 852 | |
853 | // | |
854 | // Return the lab of signal mother or -1 if not from C | |
855 | // | |
856 | ||
39427568 | 857 | Int_t imother(-1), pdg(-1); |
858 | pdg = GetMotherPDG(tr, imother); | |
76d0b522 | 859 | |
860 | // Check C | |
39427568 | 861 | if(imother >= 0){ |
862 | if((TMath::Abs(pdg)==411) || (TMath::Abs(pdg)==421) || (TMath::Abs(pdg)==431) || (TMath::Abs(pdg)==4122) || (TMath::Abs(pdg)==4132) || (TMath::Abs(pdg)==4232) || (TMath::Abs(pdg)==43320)){ | |
863 | AliDebug(2, "Charm Mother selected"); | |
864 | return imother; | |
76d0b522 | 865 | } |
39427568 | 866 | if(TMath::Abs(pdg) == 11){ |
867 | AliDebug(2, "Mother is electron - look further in hierarchy"); | |
76d0b522 | 868 | return IsMotherC(imother); |
869 | } | |
39427568 | 870 | AliDebug(2, "Nothing selected"); |
76d0b522 | 871 | return -1; |
872 | } | |
39427568 | 873 | AliDebug(2, "Not mother"); |
76d0b522 | 874 | return -1; |
875 | } | |
39427568 | 876 | |
76d0b522 | 877 | //_______________________________________________________________________________________________ |
39427568 | 878 | Int_t AliHFENonPhotonicElectron::IsMotherB(Int_t tr) const { |
76d0b522 | 879 | |
880 | // | |
881 | // Return the lab of signal mother or -1 if not B | |
882 | // | |
883 | ||
39427568 | 884 | Int_t imother(-1), pdg(-1); |
885 | pdg = GetMotherPDG(tr, imother); | |
76d0b522 | 886 | |
39427568 | 887 | // Check B |
888 | if(imother >= 0){ | |
889 | if((TMath::Abs(pdg)==511) || (TMath::Abs(pdg)==521) || (TMath::Abs(pdg)==531) || (TMath::Abs(pdg)==5122) || (TMath::Abs(pdg)==5132) || (TMath::Abs(pdg)==5232) || (TMath::Abs(pdg)==53320)){ | |
890 | AliDebug(2, "Bottom Mother selected"); | |
891 | return imother; | |
76d0b522 | 892 | } |
39427568 | 893 | if(TMath::Abs(pdg) == 11){ |
76d0b522 | 894 | return IsMotherB(imother); |
39427568 | 895 | AliDebug(2, "Mother is electron - look further in hierarchy"); |
76d0b522 | 896 | } |
39427568 | 897 | AliDebug(2, "Nothing selected"); |
76d0b522 | 898 | return -1; |
899 | } | |
39427568 | 900 | AliDebug(2, "Not mother"); |
76d0b522 | 901 | return -1; |
902 | } | |
903 | ||
904 | //_______________________________________________________________________________________________ | |
39427568 | 905 | Int_t AliHFENonPhotonicElectron::IsMotherEta(Int_t tr) const { |
76d0b522 | 906 | |
907 | // | |
908 | // Return the lab of eta mother or -1 if not eta | |
909 | // | |
910 | ||
39427568 | 911 | Int_t imother(-1), pdg(-1); |
912 | pdg = GetMotherPDG(tr, imother); | |
76d0b522 | 913 | |
39427568 | 914 | // Check eta |
915 | if(imother >= 0){ | |
916 | if(TMath::Abs(pdg) == 221){ | |
917 | AliDebug(2, "Eta mother selected"); | |
918 | return imother; | |
76d0b522 | 919 | } |
39427568 | 920 | if(TMath::Abs(pdg) == 11){ |
921 | AliDebug(2, "Mother is electron - look further in hierarchy"); | |
76d0b522 | 922 | return IsMotherEta(imother); |
923 | } | |
39427568 | 924 | AliDebug(2, "Nothing selected"); |
76d0b522 | 925 | return -1; |
926 | } | |
39427568 | 927 | AliDebug(2, "Not mother"); |
76d0b522 | 928 | return -1; |
929 | } | |
4437a0d2 | 930 | |
931 | //_______________________________________________________________________________________________ | |
932 | Bool_t AliHFENonPhotonicElectron::MakePairDCA(const AliVTrack *inclusive, const AliVTrack *associated, AliVEvent *vEvent, Bool_t isAOD, Double_t &invMass, Double_t &angle) const { | |
933 | // | |
934 | // Make Pairs of electrons using TLorentzVector | |
935 | // | |
936 | Double_t eMass = TDatabasePDG::Instance()->GetParticle(11)->Mass(); //Electron mass in GeV | |
937 | Double_t bfield = vEvent->GetMagneticField(); | |
938 | ||
939 | AliESDtrack *esdtrack1, *esdtrack2; | |
940 | if(isAOD){ | |
941 | // call copy constructor for AODs | |
942 | esdtrack1 = new AliESDtrack(inclusive); | |
943 | esdtrack2 = new AliESDtrack(associated); | |
944 | } else { | |
945 | // call copy constructor for ESDs | |
bbeea05b | 946 | esdtrack1 = new AliESDtrack(*(dynamic_cast<const AliESDtrack *>(inclusive))); |
947 | esdtrack2 = new AliESDtrack(*(dynamic_cast<const AliESDtrack *>(associated))); | |
4437a0d2 | 948 | } |
949 | if((!esdtrack1) || (!esdtrack2)){ | |
950 | delete esdtrack1; | |
951 | delete esdtrack2; | |
952 | return kFALSE; | |
953 | } | |
954 | ||
955 | Double_t xt1 = 0; //radial position track 1 at the DCA point | |
956 | Double_t xt2 = 0; //radial position track 2 at the DCA point | |
957 | Double_t dca = esdtrack2->GetDCA(esdtrack1,bfield,xt2,xt1); //DCA track1-track2 | |
958 | if(dca > fMaxDCA){ | |
959 | // Apply DCA cut already in the function | |
960 | delete esdtrack1; | |
961 | delete esdtrack2; | |
962 | return kFALSE; | |
963 | } | |
964 | ||
965 | //Momenta of the track extrapolated to DCA track-track | |
966 | Double_t p1[3] = {0,0,0}; | |
967 | Double_t p2[3] = {0,0,0}; | |
968 | Bool_t kHasdcaT1 = esdtrack1->GetPxPyPzAt(xt1,bfield,p1); //Track1 | |
969 | Bool_t kHasdcaT2 = esdtrack2->GetPxPyPzAt(xt2,bfield,p2); //Track2 | |
970 | if(!kHasdcaT1 || !kHasdcaT2) AliWarning("It could be a problem in the extrapolation"); | |
971 | ||
972 | TLorentzVector electron1, electron2, mother; | |
973 | electron1.SetXYZM(p1[0], p1[1], p1[2], eMass); | |
974 | electron2.SetXYZM(p2[0], p2[1], p2[2], eMass); | |
975 | ||
976 | mother = electron1 + electron2; | |
977 | invMass = mother.M(); | |
978 | angle = TVector2::Phi_0_2pi(electron1.Angle(electron2.Vect())); | |
979 | ||
980 | delete esdtrack1; | |
981 | delete esdtrack2; | |
982 | return kTRUE; | |
983 | } | |
984 | ||
985 | //_______________________________________________________________________________________________ | |
986 | Bool_t AliHFENonPhotonicElectron::MakePairKF(const AliVTrack *inclusive, const AliVTrack *associated, AliKFVertex &primV, Double_t &invMass, Double_t &angle) const { | |
987 | // | |
988 | // Make pairs of electrons using the AliKF package | |
989 | // | |
990 | ||
991 | //printf("AOD HFE non photonic\n"); | |
992 | ||
993 | Int_t fPDGtrack1 = 11; | |
994 | if(inclusive->Charge()>0) fPDGtrack1 = -11; | |
995 | Int_t fPDGtrack2 = 11; | |
996 | if(associated->Charge()>0) fPDGtrack2 = -11; | |
997 | ||
998 | AliKFParticle ktrack1(*inclusive, fPDGtrack1); | |
999 | AliKFParticle ktrack2(*associated, fPDGtrack2); | |
1000 | AliKFParticle recoGamma(ktrack1,ktrack2); | |
1001 | ||
1002 | if(recoGamma.GetNDF()<1) return kFALSE; //! Cut on Reconstruction | |
1003 | ||
1004 | Double_t chi2OverNDF = recoGamma.GetChi2()/recoGamma.GetNDF(); | |
1005 | if(TMath::Sqrt(TMath::Abs(chi2OverNDF))>fChi2OverNDFCut) return kFALSE; | |
1006 | ||
1007 | if(fSetMassConstraint){ | |
1008 | primV += recoGamma; | |
1009 | primV -= ktrack1; | |
1010 | primV -= ktrack2; | |
1011 | recoGamma.SetProductionVertex(primV); | |
1012 | recoGamma.SetMassConstraint(0,0.0001); | |
1013 | } | |
1014 | ||
1015 | Double_t width(0.); | |
1016 | recoGamma.GetMass(invMass,width); | |
1017 | angle = ktrack1.GetAngle(ktrack2); | |
1018 | return kTRUE; | |
1019 | } | |
1020 | ||
1021 | //_______________________________________________________________________________________________ | |
1022 | Bool_t AliHFENonPhotonicElectron::FilterCategory1Track(const AliVTrack * const track, Bool_t isAOD, Int_t binct){ | |
1023 | // | |
1024 | // Selection of good associated tracks for the pool | |
1025 | // selection is done using strong cuts | |
1026 | // Tracking in the TPC and the ITS is a minimal requirement | |
1027 | // | |
1028 | Bool_t survivedbackground = kTRUE; | |
1029 | ||
1030 | if(!fHFEBackgroundCuts->CheckParticleCuts(AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack, (TObject *) track)) survivedbackground = kFALSE; | |
1031 | AliDebug(3, Form("First cut: %s\n", survivedbackground == kTRUE ? "yes" : "no")); | |
1032 | if(!fHFEBackgroundCuts->CheckParticleCuts(AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack, (TObject *) track)) survivedbackground = kFALSE; | |
1033 | AliDebug(3, Form("Second cut: %s\n", survivedbackground == kTRUE ? "yes" : "no")); | |
1034 | ||
1035 | if(survivedbackground){ | |
1036 | // PID track cuts | |
1037 | AliHFEpidObject hfetrack2; | |
1038 | ||
1039 | if(!isAOD) hfetrack2.SetAnalysisType(AliHFEpidObject::kESDanalysis); | |
1040 | else hfetrack2.SetAnalysisType(AliHFEpidObject::kAODanalysis); | |
1041 | ||
1042 | hfetrack2.SetRecTrack(track); | |
1043 | if(binct>-1){ | |
1044 | hfetrack2.SetCentrality((Int_t)binct); | |
1045 | AliDebug(3,Form("centrality %d and %d",binct,hfetrack2.GetCentrality())); | |
1046 | hfetrack2.SetPbPb(); | |
1047 | } | |
1048 | ||
1049 | if(fPIDBackground->IsSelected(&hfetrack2,0x0,"recTrackCont",fPIDBackgroundQA)){ | |
1050 | survivedbackground = kTRUE; | |
1051 | } else survivedbackground = kFALSE; | |
1052 | } | |
1053 | AliDebug(3, Form("PID: %s\n", survivedbackground == kTRUE ? "yes" : "no")); | |
1054 | return survivedbackground; | |
1055 | } | |
1056 | ||
1057 | //_______________________________________________________________________________________________ | |
1058 | Bool_t AliHFENonPhotonicElectron::FilterCategory2Track(const AliVTrack * const track, Bool_t isAOD){ | |
1059 | // | |
1060 | // Selection of category 2 tracks: These tracks are exclusively low pt tracks below | |
1061 | // 300 MeV/c which have at least 2 hits in the 4 outer ITS layers and are identified as | |
1062 | // electron candidates by the ITS | |
1063 | // | |
1064 | if(TMath::Abs(track->Pt()) > 0.3) return kFALSE; | |
1065 | Int_t nclustersITS(0), nclustersOuter(0); | |
1066 | if(isAOD){ | |
1067 | const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track); | |
39427568 | 1068 | if(!(aodtrack->TestFilterBit(AliAODTrack::kTrkGlobalNoDCA) || aodtrack->TestFilterBit(AliAODTrack::kTrkITSsa))) return kFALSE; |
4437a0d2 | 1069 | nclustersITS = aodtrack->GetITSNcls(); |
1070 | for(int ily = 2; ily < 5; ily++) | |
1071 | if(aodtrack->HasPointOnITSLayer(ily)) nclustersOuter++; | |
1072 | } else { | |
1073 | const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track); | |
1074 | if(esdtrack->GetStatus() & AliESDtrack::kITSpureSA) return kFALSE; | |
1075 | nclustersITS = esdtrack->GetITSclusters(NULL); | |
1076 | for(int ily = 2; ily < 5; ily++) | |
1077 | if(esdtrack->HasPointOnITSLayer(ily)) nclustersOuter++; | |
1078 | } | |
1079 | if(nclustersITS < 4) return kFALSE; | |
1080 | if(nclustersOuter < 3) return kFALSE; | |
1081 | ||
1082 | // Do ITS PID | |
1083 | Double_t nsigmaITS = fPIDBackground->GetPIDResponse()->NumberOfSigmasITS(track, AliPID::kElectron); | |
1084 | fHnsigmaITS->Fill(track->Pt(), nsigmaITS); | |
bbeea05b | 1085 | if(TMath::Abs(nsigmaITS - fITSmeanShift) > 3.) return kFALSE; |
4437a0d2 | 1086 | // if global track, we apply also TPC PID |
1087 | return kTRUE; | |
1088 | } |