]>
Commit | Line | Data |
---|---|---|
81ae6b8d | 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 | // Analysis task for Kinematic filtering | |
18 | // Fill AOD tracks from Kinematic stack | |
19 | // | |
20 | // Code taken from macro CreateAODfromKineTree.C by Markus Oldenburg | |
21 | // | |
22 | ||
23 | #include <TChain.h> | |
24 | #include <TFile.h> | |
25 | ||
26 | #include "AliAnalysisTaskKineFilter.h" | |
27 | #include "AliAnalysisManager.h" | |
28 | #include "AliAnalysisFilter.h" | |
29 | #include "AliHeader.h" | |
30 | #include "AliStack.h" | |
31 | #include "TParticle.h" | |
32 | #include "AliMCEvent.h" | |
33 | #include "AliAODEvent.h" | |
34 | #include "AliAODHeader.h" | |
35 | #include "AliAODVertex.h" | |
36 | #include "AliAODTrack.h" | |
37 | ||
38 | #include "AliLog.h" | |
39 | ||
40 | ClassImp(AliAnalysisTaskKineFilter) | |
41 | ||
42 | //////////////////////////////////////////////////////////////////////// | |
43 | ||
44 | //____________________________________________________________________ | |
45 | AliAnalysisTaskKineFilter::AliAnalysisTaskKineFilter(): | |
46 | fTrackFilter(0x0) | |
47 | { | |
48 | // Default constructor | |
49 | } | |
50 | ||
51 | //____________________________________________________________________ | |
52 | AliAnalysisTaskKineFilter::AliAnalysisTaskKineFilter(const char* name): | |
53 | AliAnalysisTaskSE(name), | |
54 | fTrackFilter(0x0) | |
55 | { | |
56 | // Default constructor | |
57 | DefineInput (0, TChain::Class()); | |
58 | DefineOutput(0, TTree::Class()); | |
59 | } | |
60 | ||
61 | //____________________________________________________________________ | |
62 | AliAnalysisTaskKineFilter::AliAnalysisTaskKineFilter(const AliAnalysisTaskKineFilter& obj): | |
63 | AliAnalysisTaskSE(obj), | |
64 | fTrackFilter(0) | |
65 | { | |
66 | // Copy constructor | |
67 | fTrackFilter = obj.fTrackFilter; | |
68 | } | |
69 | ||
70 | //____________________________________________________________________ | |
71 | AliAnalysisTaskKineFilter& AliAnalysisTaskKineFilter::operator=(const AliAnalysisTaskKineFilter& other) | |
72 | { | |
73 | // Assignment | |
74 | AliAnalysisTaskSE::operator=(other); | |
75 | fTrackFilter = other.fTrackFilter; | |
76 | return *this; | |
77 | } | |
78 | ||
79 | //____________________________________________________________________ | |
80 | void AliAnalysisTaskKineFilter::UserCreateOutputObjects() | |
81 | { | |
82 | // Create the output container | |
83 | ||
84 | OutputTree()->GetUserInfo()->Add(fTrackFilter); | |
85 | } | |
86 | ||
87 | ||
88 | //____________________________________________________________________ | |
89 | void AliAnalysisTaskKineFilter::Exec(Option_t */*option*/) | |
90 | { | |
91 | // Execute analysis for current event | |
92 | // | |
93 | ||
94 | // Fill AOD tracks from Kinematic stack | |
95 | ||
96 | // get AliAOD Event | |
97 | AliAODEvent* aod = AODEvent(); | |
98 | // aod->CreateStdContent(); | |
99 | ||
100 | AliStack* stack = MCEvent()->Stack(); | |
101 | Int_t nTracks = stack->GetNtrack(); | |
102 | Int_t nPrims = stack->GetNprimary(); | |
103 | ||
104 | AliAODVertex *primary = NULL; | |
105 | Int_t nPos = 0; | |
106 | Int_t nNeg = 0; | |
107 | Int_t jVertices = 0; | |
108 | Int_t jTracks = 0; | |
109 | Float_t p[3]; | |
110 | Float_t x[3]; | |
111 | ||
112 | // Access to the header | |
113 | AliAODHeader *header = aod->GetHeader(); | |
114 | ||
115 | Double_t emEnergy[2] = {-999., -999.}; | |
116 | ||
117 | // fill the header | |
118 | *header = AliAODHeader(MCEvent()->Header()->GetRun(), | |
119 | 0, // bunchX number | |
120 | 0, // orbit number | |
121 | 0, // period number | |
122 | nTracks, | |
123 | nPos, | |
124 | nNeg, | |
125 | -999, // mag. field | |
126 | -999., // muon mag. field | |
127 | -999., // centrality | |
128 | -999., // ZDCN1Energy | |
129 | -999., // ZDCP1Energy | |
130 | -999., // ZDCN2Energy | |
131 | -999., // ZDCP2Energy | |
132 | emEnergy, // emEnergy | |
133 | 0, // TriggerMask | |
134 | 0, // TriggerCluster | |
135 | 0, // EventType | |
136 | ""); // title | |
137 | ||
138 | // Access to the AOD container of vertices | |
139 | TClonesArray &vertices = *(aod->GetVertices()); | |
140 | ||
141 | // Access to the AOD container of tracks | |
142 | TClonesArray &tracks = *(aod->GetTracks()); | |
143 | ||
144 | aod->ResetStd(nTracks, 1); | |
145 | ||
146 | // track loop | |
147 | for (Int_t iTrack = 0; iTrack < nPrims; ++iTrack) { | |
148 | ||
149 | TParticle *part = stack->Particle(iTrack); | |
150 | ||
151 | if (iTrack == 0) { | |
152 | // add primary vertex | |
153 | x[0] = part->Vx(); x[1] = part->Vy(); x[2] = part->Vz(); | |
154 | primary = new(vertices[jVertices++]) | |
155 | AliAODVertex(x, NULL, -999., NULL, AliAODVertex::kPrimary); | |
156 | } | |
157 | ||
158 | // only final particles | |
159 | if( part->GetStatusCode() !=1 ) continue; | |
160 | ||
161 | // | |
162 | // Track selection | |
163 | UInt_t selectInfo = 0; | |
164 | if (fTrackFilter) { | |
165 | selectInfo = fTrackFilter->IsSelected(part); | |
166 | if (!selectInfo) continue; | |
167 | } | |
168 | ||
169 | x[0] = part->Vx(); x[1] = part->Vy(); x[2] = part->Vz(); | |
170 | p[0] = part->Px(); p[1] = part->Py(); p[2] = part->Pz(); | |
171 | ||
172 | // add primary tracks | |
173 | primary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID, | |
174 | 0, // Label | |
175 | p, | |
176 | kTRUE, | |
177 | x, | |
178 | kFALSE, | |
179 | NULL, | |
180 | (Short_t)-99, | |
181 | 0, // no ITSClusterMap | |
182 | NULL, | |
183 | primary, | |
184 | kFALSE, // no fit performed | |
185 | kFALSE, // no fit preformed | |
186 | AliAODTrack::kPrimary, | |
187 | selectInfo)); | |
188 | ||
189 | AliAODTrack* currTrack = (AliAODTrack*)tracks.Last(); | |
190 | SetChargeAndPID(part->GetPdgCode(), currTrack); | |
191 | if (currTrack->Charge() != -99) { | |
192 | if (currTrack->Charge() > 0) { | |
193 | nPos++; | |
194 | } else if (currTrack->Charge() < 0) { | |
195 | nNeg++; | |
196 | } | |
197 | } | |
198 | LoopOverSecondaries(part, jTracks, jVertices, nPos, nNeg); | |
199 | ||
200 | } // end of track loop | |
201 | ||
202 | header->SetRefMultiplicityPos(nPos); | |
203 | header->SetRefMultiplicityNeg(nNeg); | |
204 | ||
205 | ||
206 | if( fDebug > 1 ) | |
207 | AliInfo(Form("primaries: %d secondaries: %d (pos: %d neg: %d), vertices: %d", | |
208 | nPrims, tracks.GetEntriesFast()-nPrims, nPos, nNeg, vertices.GetEntriesFast() ) ); | |
209 | return; | |
210 | } | |
211 | ||
212 | ||
213 | //____________________________________________________________________ | |
214 | Int_t AliAnalysisTaskKineFilter::LoopOverSecondaries(TParticle *mother, Int_t &jTracks, Int_t &jVertices, Int_t &nPos, Int_t &nNeg ) | |
215 | { | |
216 | ||
217 | if (mother->GetNDaughters() > 0) { | |
218 | ||
219 | AliStack* stack = MCEvent()->Stack(); | |
220 | ||
221 | TClonesArray &vertices = *(AODEvent()->GetVertices()); | |
222 | TClonesArray &tracks = *(AODEvent()->GetTracks()); | |
223 | Float_t p[3]; | |
224 | Float_t x[3]; | |
225 | AliAODVertex* secondary = NULL; | |
226 | ||
227 | for (Int_t iDaughter = mother->GetFirstDaughter(); iDaughter <= mother->GetLastDaughter(); iDaughter++) { | |
228 | TParticle *part = stack->Particle(iDaughter); | |
229 | // only final particles | |
230 | if( part->GetStatusCode() !=1 ) continue; | |
231 | ||
232 | p[0] = part->Px(); | |
233 | p[1] = part->Py(); | |
234 | p[2] = part->Pz(); | |
235 | x[0] = part->Vx(); | |
236 | x[1] = part->Vy(); | |
237 | x[2] = part->Vz(); | |
238 | ||
239 | if (iDaughter == mother->GetFirstDaughter()) { | |
240 | // add secondary vertex | |
241 | secondary = new(vertices[jVertices++]) | |
242 | AliAODVertex(x, NULL, -999., tracks.Last(), AliAODVertex::kUndef); | |
243 | ||
244 | SetVertexType(part, secondary); | |
245 | } | |
246 | ||
247 | UInt_t selectInfo = 0; | |
248 | // | |
249 | // Track selection | |
250 | if (fTrackFilter) { | |
251 | selectInfo = fTrackFilter->IsSelected(part); | |
252 | if (!selectInfo) continue; | |
253 | } | |
254 | ||
255 | // add secondary tracks | |
256 | secondary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID | |
257 | 0, // label | |
258 | p, | |
259 | kTRUE, | |
260 | x, | |
261 | kFALSE, | |
262 | NULL, | |
263 | (Short_t)-99, | |
264 | 0, // no cluster map available | |
265 | NULL, | |
266 | secondary, | |
267 | kFALSE, // no fit performed | |
268 | kFALSE, // no fit performed | |
269 | AliAODTrack::kSecondary, | |
270 | selectInfo)); | |
271 | ||
272 | AliAODTrack* currTrack = (AliAODTrack*)tracks.Last(); | |
273 | SetChargeAndPID(part->GetPdgCode(), currTrack); | |
274 | if (currTrack->Charge() != -99) { | |
275 | if (currTrack->Charge() > 0) { | |
276 | nPos++; | |
277 | } else if (currTrack->Charge() < 0) { | |
278 | nNeg++; | |
279 | } | |
280 | } | |
281 | ||
282 | LoopOverSecondaries(part, jTracks, jVertices, nPos, nNeg); | |
283 | } | |
284 | return 1; | |
285 | } else { | |
286 | return 0; | |
287 | } | |
288 | } | |
289 | ||
290 | //____________________________________________________________________ | |
291 | void AliAnalysisTaskKineFilter::SetChargeAndPID(Int_t pdgCode, AliAODTrack *track) { | |
292 | ||
293 | Float_t PID[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}; | |
294 | ||
295 | switch (pdgCode) { | |
296 | ||
297 | case 22: // gamma | |
298 | track->SetCharge(0); | |
299 | PID[AliAODTrack::kUnknown] = 1.; | |
300 | track->SetPID(PID); | |
301 | break; | |
302 | ||
303 | case 11: // e- | |
304 | track->SetCharge(-1); | |
305 | PID[AliAODTrack::kElectron] = 1.; | |
306 | track->SetPID(PID); | |
307 | break; | |
308 | ||
309 | case -11: // e+ | |
310 | track->SetCharge(+1); | |
311 | PID[AliAODTrack::kElectron] = 1.; | |
312 | track->SetPID(PID); | |
313 | break; | |
314 | ||
315 | case 13: // mu- | |
316 | track->SetCharge(-1); | |
317 | PID[AliAODTrack::kMuon] = 1.; | |
318 | track->SetPID(PID); | |
319 | break; | |
320 | ||
321 | case -13: // mu+ | |
322 | track->SetCharge(+1); | |
323 | PID[AliAODTrack::kMuon] = 1.; | |
324 | track->SetPID(PID); | |
325 | break; | |
326 | ||
327 | case 111: // pi0 | |
328 | track->SetCharge(0); | |
329 | PID[AliAODTrack::kUnknown] = 1.; | |
330 | track->SetPID(PID); | |
331 | break; | |
332 | ||
333 | case 211: // pi+ | |
334 | track->SetCharge(+1); | |
335 | PID[AliAODTrack::kPion] = 1.; | |
336 | track->SetPID(PID); | |
337 | break; | |
338 | ||
339 | case -211: // pi- | |
340 | track->SetCharge(-1); | |
341 | PID[AliAODTrack::kPion] = 1.; | |
342 | track->SetPID(PID); | |
343 | break; | |
344 | ||
345 | case 130: // K0L | |
346 | track->SetCharge(0); | |
347 | PID[AliAODTrack::kUnknown] = 1.; | |
348 | track->SetPID(PID); | |
349 | break; | |
350 | ||
351 | case 321: // K+ | |
352 | track->SetCharge(+1); | |
353 | PID[AliAODTrack::kKaon] = 1.; | |
354 | track->SetPID(PID); | |
355 | break; | |
356 | ||
357 | case -321: // K- | |
358 | track->SetCharge(-1); | |
359 | PID[AliAODTrack::kKaon] = 1.; | |
360 | track->SetPID(PID); | |
361 | break; | |
362 | ||
363 | case 2112: // n | |
364 | track->SetCharge(0); | |
365 | PID[AliAODTrack::kUnknown] = 1.; | |
366 | track->SetPID(PID); | |
367 | break; | |
368 | ||
369 | case 2212: // p | |
370 | track->SetCharge(+1); | |
371 | PID[AliAODTrack::kProton] = 1.; | |
372 | track->SetPID(PID); | |
373 | break; | |
374 | ||
375 | case -2212: // anti-p | |
376 | track->SetCharge(-1); | |
377 | PID[AliAODTrack::kProton] = 1.; | |
378 | track->SetPID(PID); | |
379 | break; | |
380 | ||
381 | case 310: // K0S | |
382 | track->SetCharge(0); | |
383 | PID[AliAODTrack::kUnknown] = 1.; | |
384 | track->SetPID(PID); | |
385 | break; | |
386 | ||
387 | case 311: // K0 | |
388 | track->SetCharge(0); | |
389 | PID[AliAODTrack::kUnknown] = 1.; | |
390 | track->SetPID(PID); | |
391 | break; | |
392 | ||
393 | case -311: // anti-K0 | |
394 | track->SetCharge(0); | |
395 | PID[AliAODTrack::kUnknown] = 1.; | |
396 | track->SetPID(PID); | |
397 | break; | |
398 | ||
399 | case 221: // eta | |
400 | track->SetCharge(0); | |
401 | PID[AliAODTrack::kUnknown] = 1.; | |
402 | track->SetPID(PID); | |
403 | break; | |
404 | ||
405 | case 3122: // lambda | |
406 | track->SetCharge(0); | |
407 | PID[AliAODTrack::kUnknown] = 1.; | |
408 | track->SetPID(PID); | |
409 | break; | |
410 | ||
411 | case 3222: // Sigma+ | |
412 | track->SetCharge(+1); | |
413 | PID[AliAODTrack::kUnknown] = 1.; | |
414 | track->SetPID(PID); | |
415 | break; | |
416 | ||
417 | case 3212: // Sigma0 | |
418 | track->SetCharge(-1); | |
419 | PID[AliAODTrack::kUnknown] = 1.; | |
420 | track->SetPID(PID); | |
421 | break; | |
422 | ||
423 | case 3112: // Sigma- | |
424 | track->SetCharge(-1); | |
425 | PID[AliAODTrack::kUnknown] = 1.; | |
426 | track->SetPID(PID); | |
427 | break; | |
428 | ||
429 | case 3322: // Xi0 | |
430 | track->SetCharge(0); | |
431 | PID[AliAODTrack::kUnknown] = 1.; | |
432 | track->SetPID(PID); | |
433 | break; | |
434 | ||
435 | case 3312: // Xi- | |
436 | track->SetCharge(-1); | |
437 | PID[AliAODTrack::kUnknown] = 1.; | |
438 | track->SetPID(PID); | |
439 | break; | |
440 | ||
441 | case 3334: // Omega- | |
442 | track->SetCharge(-1); | |
443 | PID[AliAODTrack::kUnknown] = 1.; | |
444 | track->SetPID(PID); | |
445 | break; | |
446 | ||
447 | case -2112: // n-bar | |
448 | track->SetCharge(0); | |
449 | PID[AliAODTrack::kUnknown] = 1.; | |
450 | track->SetPID(PID); | |
451 | break; | |
452 | ||
453 | case -3122: // anti-Lambda | |
454 | track->SetCharge(0); | |
455 | PID[AliAODTrack::kUnknown] = 1.; | |
456 | track->SetPID(PID); | |
457 | break; | |
458 | ||
459 | case -3222: // anti-Sigma- | |
460 | track->SetCharge(-1); | |
461 | PID[AliAODTrack::kUnknown] = 1.; | |
462 | track->SetPID(PID); | |
463 | break; | |
464 | ||
465 | case -3212: // anti-Sigma0 | |
466 | track->SetCharge(0); | |
467 | PID[AliAODTrack::kUnknown] = 1.; | |
468 | track->SetPID(PID); | |
469 | break; | |
470 | ||
471 | case -3112: // anti-Sigma+ | |
472 | track->SetCharge(+1); | |
473 | PID[AliAODTrack::kUnknown] = 1.; | |
474 | track->SetPID(PID); | |
475 | break; | |
476 | ||
477 | case -3322: // anti-Xi0 | |
478 | track->SetCharge(0); | |
479 | PID[AliAODTrack::kUnknown] = 1.; | |
480 | track->SetPID(PID); | |
481 | break; | |
482 | ||
483 | case -3312: // anti-Xi+ | |
484 | track->SetCharge(+1); | |
485 | break; | |
486 | ||
487 | case -3334: // anti-Omega+ | |
488 | track->SetCharge(+1); | |
489 | PID[AliAODTrack::kUnknown] = 1.; | |
490 | track->SetPID(PID); | |
491 | break; | |
492 | ||
493 | case 411: // D+ | |
494 | track->SetCharge(+1); | |
495 | PID[AliAODTrack::kUnknown] = 1.; | |
496 | track->SetPID(PID); | |
497 | break; | |
498 | ||
499 | case -411: // D- | |
500 | track->SetCharge(-1); | |
501 | PID[AliAODTrack::kUnknown] = 1.; | |
502 | track->SetPID(PID); | |
503 | break; | |
504 | ||
505 | case 421: // D0 | |
506 | track->SetCharge(0); | |
507 | PID[AliAODTrack::kUnknown] = 1.; | |
508 | track->SetPID(PID); | |
509 | break; | |
510 | ||
511 | case -421: // anti-D0 | |
512 | track->SetCharge(0); | |
513 | PID[AliAODTrack::kUnknown] = 1.; | |
514 | track->SetPID(PID); | |
515 | break; | |
516 | ||
517 | default : // unknown | |
518 | track->SetCharge(-99); | |
519 | PID[AliAODTrack::kUnknown] = 1.; | |
520 | track->SetPID(PID); | |
521 | } | |
522 | ||
523 | return; | |
524 | } | |
525 | ||
526 | //____________________________________________________________________ | |
527 | void AliAnalysisTaskKineFilter::SetVertexType(TParticle *part, AliAODVertex *vertex) | |
528 | { | |
529 | // this whole thing doesn't make much sense. but anyhow... | |
530 | AliStack* stack = MCEvent()->Stack(); | |
531 | TParticle *mother = stack->Particle(part->GetFirstMother()); | |
532 | Int_t pdgMother = mother->GetPdgCode(); | |
533 | Int_t pdgPart = part->GetPdgCode(); | |
534 | ||
535 | // kinks | |
536 | if (mother->GetNDaughters() == 2) { | |
537 | Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode(); | |
538 | Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode(); | |
539 | ||
540 | if (!(pdgMother == 22 || pdgMother == 111 || pdgMother == 130 || | |
541 | TMath::Abs(pdgMother) == 2112 || pdgMother == 310 || pdgMother == 221 || | |
542 | TMath::Abs(pdgMother) == 3122 || TMath::Abs(pdgMother) == 3322 || | |
543 | pdgMother == -3212 || TMath::Abs(pdgMother) == 421 || | |
544 | TMath::Abs(pdgMother) == 311) // not neutral | |
545 | && (((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || | |
546 | TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || | |
547 | firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || | |
548 | TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || | |
549 | TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // neutral | |
550 | && !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || | |
551 | TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || | |
552 | lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || | |
553 | TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || | |
554 | TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) // not neutral | |
555 | || !((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || | |
556 | TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || | |
557 | firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || | |
558 | TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || | |
559 | TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral | |
560 | && (lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || | |
561 | TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || | |
562 | lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || | |
563 | TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || | |
564 | TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)))) { // neutral | |
565 | ||
566 | vertex->SetType(AliAODVertex::kKink); | |
567 | // jKinks++; | |
568 | } | |
569 | } | |
570 | ||
571 | // V0 | |
572 | else if (mother->GetNDaughters() == 2) { | |
573 | Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode(); | |
574 | Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode(); | |
575 | ||
576 | if ((pdgMother == 22 || pdgMother == 111 || pdgMother == 130 || | |
577 | TMath::Abs(pdgMother) == 2112 || pdgMother == 310 || | |
578 | pdgMother == 221 || TMath::Abs(pdgMother) == 3122 || | |
579 | TMath::Abs(pdgMother) == 3322 || pdgMother == -3212 || | |
580 | TMath::Abs(pdgMother) == 421 || TMath::Abs(pdgMother) == 311) // neutral | |
581 | && !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || | |
582 | TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || | |
583 | lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || | |
584 | TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || | |
585 | TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral | |
586 | && !(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || | |
587 | TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || | |
588 | firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || | |
589 | TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || | |
590 | TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) { // not neutral | |
591 | ||
592 | vertex->SetType(AliAODVertex::kV0); | |
593 | // jV0s++; | |
594 | } | |
595 | } | |
596 | ||
597 | // Cascade | |
598 | else if (mother->GetNDaughters() == 2) { | |
599 | Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode(); | |
600 | Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode(); | |
601 | ||
602 | if ((TMath::Abs(pdgMother) == 3334 || TMath::Abs(pdgMother) == 3312 || TMath::Abs(pdgMother) == 3322) && | |
603 | (TMath::Abs(pdgPart) == 3122 || TMath::Abs(pdgPart) == 211 || TMath::Abs(pdgPart) == 321) | |
604 | && ((!(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || | |
605 | TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || | |
606 | firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || | |
607 | TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || | |
608 | TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral | |
609 | && TMath::Abs(lastPdgCode) == 3122) // labmda or anti-lambda | |
610 | || ((!(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || | |
611 | TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || | |
612 | lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || | |
613 | TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || | |
614 | TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral | |
615 | && TMath::Abs(firstPdgCode) == 3122)))) { // lambda or anti-lambda | |
616 | vertex->SetType(AliAODVertex::kCascade); | |
617 | // jCascades++; | |
618 | } | |
619 | } | |
620 | ||
621 | // Multi | |
622 | else if (mother->GetNDaughters() > 2) { | |
623 | ||
624 | vertex->SetType(AliAODVertex::kMulti); | |
625 | // jMultis++; | |
626 | } | |
627 | ||
628 | else { | |
629 | vertex->SetType(AliAODVertex::kUndef); | |
630 | } | |
631 | } |