]>
Commit | Line | Data |
---|---|---|
e985a35a | 1 | #if !defined(__CINT__) || defined(__MAKECINT__) |
2 | ||
cf22b3fc | 3 | #include <Riostream.h> |
4 | #include <TFile.h> | |
5 | #include <TTree.h> | |
6 | #include <TMath.h> | |
df9db588 | 7 | |
8 | #include "AliAODEvent.h" | |
31fd97b2 | 9 | #include "AliAODHeader.h" |
cf22b3fc | 10 | #include "AliAODVertex.h" |
11 | #include "AliAODTrack.h" | |
a9255000 | 12 | #include "AliAODCluster.h" |
cf22b3fc | 13 | |
df9db588 | 14 | #include "AliESD.h" |
15 | #include "AliESDtrack.h" | |
16 | #include "AliESDVertex.h" | |
17 | #include "AliESDv0.h" | |
31fd97b2 | 18 | #include "AliESDcascade.h" |
cf22b3fc | 19 | #include "AliESDCaloCluster.h" |
df9db588 | 20 | |
e985a35a | 21 | #endif |
22 | ||
cf22b3fc | 23 | void CreateAODfromESD(const char *inFileName = "AliESDs.root", |
24 | const char *outFileName = "AliAOD.root") { | |
df9db588 | 25 | |
26 | // create an AliAOD object | |
27 | AliAODEvent *aod = new AliAODEvent(); | |
28 | aod->CreateStdContent(); | |
29 | ||
30 | // open the file | |
31 | TFile *outFile = TFile::Open(outFileName, "RECREATE"); | |
32 | ||
33 | // create the tree | |
34 | TTree *aodTree = new TTree("AOD", "AliAOD tree"); | |
35 | aodTree->Branch(aod->GetList()); | |
36 | ||
37 | // connect to ESD | |
38 | TFile *inFile = TFile::Open(inFileName, "READ"); | |
39 | TTree *t = (TTree*) inFile->Get("esdTree"); | |
40 | TBranch *b = t->GetBranch("ESD"); | |
41 | AliESD *esd = 0; | |
42 | b->SetAddress(&esd); | |
43 | ||
44 | Int_t nEvents = b->GetEntries(); | |
45 | ||
46 | // loop over events and fill them | |
47 | for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) { | |
48 | b->GetEntry(iEvent); | |
49 | ||
50 | // Multiplicity information needed by the header (to be revised!) | |
51 | Int_t nTracks = esd->GetNumberOfTracks(); | |
52 | Int_t nPosTracks = 0; | |
53 | for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) | |
54 | if (esd->GetTrack(iTrack)->GetSign()> 0) nPosTracks++; | |
55 | ||
56 | // create the header | |
31fd97b2 | 57 | aod->AddHeader(new AliAODHeader(esd->GetRunNumber(), |
58 | esd->GetBunchCrossNumber(), | |
59 | esd->GetOrbitNumber(), | |
df9db588 | 60 | nTracks, |
61 | nPosTracks, | |
62 | nTracks-nPosTracks, | |
63 | esd->GetMagneticField(), | |
64 | -999., // centrality; to be filled, still | |
65 | esd->GetTriggerMask(), | |
66 | esd->GetTriggerCluster(), | |
67 | esd->GetEventType())); | |
68 | ||
69 | Int_t nV0s = esd->GetNumberOfV0s(); | |
70 | Int_t nCascades = esd->GetNumberOfCascades(); | |
71 | Int_t nKinks = esd->GetNumberOfKinks(); | |
72 | Int_t nVertices = nV0s + nCascades + nKinks; | |
73 | ||
74 | aod->ResetStd(nTracks, nVertices); | |
75 | ||
76 | ||
77 | // Array to take into account the tracks already added to the AOD | |
78 | Bool_t * usedTrack = NULL; | |
79 | if (nTracks>0) { | |
80 | usedTrack = new Bool_t[nTracks]; | |
81 | for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE; | |
82 | } | |
83 | // Array to take into account the V0s already added to the AOD | |
84 | Bool_t * usedV0 = NULL; | |
85 | if (nV0s>0) { | |
86 | usedV0 = new Bool_t[nV0s]; | |
87 | for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE; | |
88 | } | |
cf22b3fc | 89 | // Array to take into account the kinks already added to the AOD |
90 | Bool_t * usedKink = NULL; | |
91 | if (nKinks>0) { | |
92 | usedKink = new Bool_t[nKinks]; | |
93 | for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE; | |
94 | } | |
df9db588 | 95 | |
96 | // Access to the AOD container of vertices | |
97 | TClonesArray &vertices = *(aod->GetVertices()); | |
98 | Int_t jVertices=0; | |
99 | ||
100 | // Access to the AOD container of tracks | |
101 | TClonesArray &tracks = *(aod->GetTracks()); | |
102 | Int_t jTracks=0; | |
103 | ||
104 | // Add primary vertex. The primary tracks will be defined | |
105 | // after the loops on the composite objects (V0, cascades, kinks) | |
106 | const AliESDVertex *vtx = esd->GetPrimaryVertex(); | |
107 | ||
108 | Double_t pos[3]; | |
109 | vtx->GetXYZ(pos); // position | |
31fd97b2 | 110 | Double_t covVtx[6]; // We have to give changing names to the variables (like cov?, x?, and p?) because CINT doesn't recognize blocks correctly. |
111 | vtx->GetCovMatrix(covVtx); //covariance matrix | |
df9db588 | 112 | |
113 | AliAODVertex * primary = new(vertices[jVertices++]) | |
31fd97b2 | 114 | AliAODVertex(pos, covVtx, vtx->GetChi2(), NULL, AliAODVertex::kPrimary); |
df9db588 | 115 | |
116 | // Create vertices starting from the most complex objects | |
117 | ||
118 | // Cascades | |
119 | for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) { | |
120 | AliESDcascade *cascade = esd->GetCascade(nCascade); | |
121 | ||
122 | Double_t posXi[3]; | |
123 | cascade->GetXYZ(posXi[0], posXi[1], posXi[2]); | |
124 | Double_t covXi[6]; | |
125 | cascade->GetPosCovXi(covXi); | |
126 | ||
127 | // Add the cascade vertex | |
128 | AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(posXi, | |
129 | covXi, | |
130 | cascade->GetChi2Xi(), | |
131 | primary, | |
132 | AliAODVertex::kCascade); | |
133 | ||
134 | primary->AddDaughter(vcascade); | |
135 | ||
136 | // Add the V0 from the cascade. The ESD class have to be optimized... | |
137 | // Now we have to search for the corresponding Vo in the list of V0s | |
138 | // using the indeces of the positive and negative tracks | |
139 | ||
140 | Int_t posFromV0 = cascade->GetPindex(); | |
141 | Int_t negFromV0 = cascade->GetNindex(); | |
142 | ||
143 | ||
144 | AliESDv0 * v0 = 0x0; | |
145 | Int_t indV0 = -1; | |
146 | ||
147 | for (Int_t iV0=0; iV0<nV0s; ++iV0) { | |
148 | ||
149 | v0 = esd->GetV0(iV0); | |
31fd97b2 | 150 | Int_t posV0 = v0->GetPindex(); |
151 | Int_t negV0 = v0->GetNindex(); | |
df9db588 | 152 | |
31fd97b2 | 153 | if (posV0==posFromV0 && negV0==negFromV0) { |
df9db588 | 154 | indV0 = iV0; |
155 | break; | |
156 | } | |
157 | } | |
158 | ||
159 | AliAODVertex * vV0FromCascade = 0x0; | |
160 | ||
cf22b3fc | 161 | if (indV0>-1 && !usedV0[indV0] ) { |
df9db588 | 162 | |
cf22b3fc | 163 | // the V0 exists in the array of V0s and is not used |
164 | ||
df9db588 | 165 | usedV0[indV0] = kTRUE; |
166 | ||
167 | Double_t posV0[3]; | |
168 | v0->GetXYZ(posV0[0], posV0[1], posV0[2]); | |
31fd97b2 | 169 | Double_t covV0_1[6]; |
170 | v0->GetPosCov(covV0_1); | |
cf22b3fc | 171 | |
df9db588 | 172 | vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(posV0, |
31fd97b2 | 173 | covV0_1, |
df9db588 | 174 | v0->GetChi2V0(), |
175 | vcascade, | |
176 | AliAODVertex::kV0); | |
177 | } else { | |
178 | ||
cf22b3fc | 179 | // the V0 doesn't exist in the array of V0s or was used |
180 | cerr << "Error: event " << iEvent << " cascade " << nCascade | |
181 | << " The V0 " << indV0 | |
182 | << " doesn't exist in the array of V0s or was used!" << endl; | |
183 | ||
31fd97b2 | 184 | Double_t posV0_2[3]; |
185 | cascade->GetXYZ(posV0_2[0], posV0_2[1], posV0_2[2]); | |
186 | Double_t covV0_2[6]; | |
187 | cascade->GetPosCov(covV0_2); | |
df9db588 | 188 | |
31fd97b2 | 189 | vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(posV0_2, |
190 | covV0_2, | |
df9db588 | 191 | v0->GetChi2V0(), |
192 | vcascade, | |
193 | AliAODVertex::kV0); | |
194 | vcascade->AddDaughter(vV0FromCascade); | |
195 | } | |
196 | ||
197 | // Add the positive tracks from the V0 | |
198 | ||
cf22b3fc | 199 | if (! usedTrack[posFromV0]) { |
200 | ||
201 | usedTrack[posFromV0] = kTRUE; | |
df9db588 | 202 | |
203 | AliESDtrack *esdTrack = esd->GetTrack(posFromV0); | |
cf22b3fc | 204 | |
31fd97b2 | 205 | Double_t p1[3]; |
206 | esdTrack->GetPxPyPz(p1); | |
df9db588 | 207 | |
31fd97b2 | 208 | Double_t x1[3]; |
209 | esdTrack->GetXYZ(x1); | |
df9db588 | 210 | |
31fd97b2 | 211 | Double_t covV0PosTr[21]; |
212 | esdTrack->GetCovarianceXYZPxPyPz(covV0PosTr); | |
cf22b3fc | 213 | |
31fd97b2 | 214 | Double_t pid1[10]; |
215 | esdTrack->GetESDpid(pid1); | |
df9db588 | 216 | |
217 | vV0FromCascade->AddDaughter( | |
cf22b3fc | 218 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), |
df9db588 | 219 | esdTrack->GetLabel(), |
31fd97b2 | 220 | p1, |
221 | kTRUE, | |
222 | x1, | |
df9db588 | 223 | kFALSE, |
31fd97b2 | 224 | covV0PosTr, |
df9db588 | 225 | (Short_t)esdTrack->GetSign(), |
226 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 227 | pid1, |
df9db588 | 228 | vV0FromCascade, |
229 | AliAODTrack::kSecondary) | |
230 | ); | |
231 | } | |
cf22b3fc | 232 | else { |
233 | cerr << "Error: event " << iEvent << " cascade " << nCascade | |
234 | << " track " << posFromV0 << " has already been used!" << endl; | |
235 | } | |
df9db588 | 236 | |
237 | // Add the negative tracks from the V0 | |
238 | ||
cf22b3fc | 239 | if (!usedTrack[negFromV0]) { |
240 | ||
241 | usedTrack[negFromV0] = kTRUE; | |
242 | ||
df9db588 | 243 | AliESDtrack *esdTrack = esd->GetTrack(negFromV0); |
cf22b3fc | 244 | |
31fd97b2 | 245 | Double_t p2[3]; |
246 | esdTrack->GetPxPyPz(p2); | |
df9db588 | 247 | |
31fd97b2 | 248 | Double_t x2[3]; |
249 | esdTrack->GetXYZ(x2); | |
df9db588 | 250 | |
31fd97b2 | 251 | Double_t covV0NegTr[21]; |
252 | esdTrack->GetCovarianceXYZPxPyPz(covV0NegTr); | |
df9db588 | 253 | |
31fd97b2 | 254 | Double_t pid2[10]; |
255 | esdTrack->GetESDpid(pid2); | |
cf22b3fc | 256 | |
df9db588 | 257 | vV0FromCascade->AddDaughter( |
258 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
259 | esdTrack->GetLabel(), | |
31fd97b2 | 260 | p2, |
df9db588 | 261 | kTRUE, |
31fd97b2 | 262 | x2, |
df9db588 | 263 | kFALSE, |
31fd97b2 | 264 | covV0NegTr, |
df9db588 | 265 | (Short_t)esdTrack->GetSign(), |
266 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 267 | pid2, |
df9db588 | 268 | vV0FromCascade, |
269 | AliAODTrack::kSecondary) | |
270 | ); | |
271 | } | |
cf22b3fc | 272 | else { |
273 | cerr << "Error: event " << iEvent << " cascade " << nCascade | |
274 | << " track " << negFromV0 << " has already been used!" << endl; | |
275 | } | |
df9db588 | 276 | |
277 | // Add the bachelor track from the cascade | |
278 | ||
279 | Int_t bachelor = cascade->GetBindex(); | |
df9db588 | 280 | |
cf22b3fc | 281 | if(!usedTrack[bachelor]) { |
282 | ||
283 | usedTrack[bachelor] = kTRUE; | |
284 | ||
285 | AliESDtrack *esdTrack = esd->GetTrack(bachelor); | |
286 | ||
31fd97b2 | 287 | Double_t p3[3]; |
288 | esdTrack->GetPxPyPz(p3); | |
df9db588 | 289 | |
31fd97b2 | 290 | Double_t x3[3]; |
291 | esdTrack->GetXYZ(x3); | |
df9db588 | 292 | |
31fd97b2 | 293 | Double_t covXiTr[21]; |
294 | esdTrack->GetCovarianceXYZPxPyPz(covXiTr); | |
df9db588 | 295 | |
31fd97b2 | 296 | Double_t pid3[10]; |
297 | esdTrack->GetESDpid(pid3); | |
df9db588 | 298 | |
299 | vcascade->AddDaughter( | |
300 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
301 | esdTrack->GetLabel(), | |
31fd97b2 | 302 | p3, |
df9db588 | 303 | kTRUE, |
31fd97b2 | 304 | x3, |
df9db588 | 305 | kFALSE, |
31fd97b2 | 306 | covXiTr, |
df9db588 | 307 | (Short_t)esdTrack->GetSign(), |
308 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 309 | pid3, |
df9db588 | 310 | vcascade, |
311 | AliAODTrack::kSecondary) | |
312 | ); | |
313 | } | |
cf22b3fc | 314 | else { |
315 | cerr << "Error: event " << iEvent << " cascade " << nCascade | |
316 | << " track " << bachelor << " has already been used!" << endl; | |
317 | } | |
df9db588 | 318 | |
319 | // Add the primary track of the cascade (if any) | |
320 | ||
cf22b3fc | 321 | } // end of the loop on cascades |
df9db588 | 322 | |
323 | // V0s | |
324 | ||
325 | for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) { | |
326 | ||
327 | if (usedV0[nV0]) continue; // skip if aready added to the AOD | |
328 | ||
329 | AliESDv0 *v0 = esd->GetV0(nV0); | |
330 | ||
31fd97b2 | 331 | Double_t posV0_3[3]; |
332 | v0->GetXYZ(posV0_3[0], posV0_3[1], posV0_3[2]); | |
333 | Double_t covV0_3[6]; | |
334 | v0->GetPosCov(covV0_3); | |
df9db588 | 335 | |
336 | AliAODVertex * vV0 = | |
31fd97b2 | 337 | new(vertices[jVertices++]) AliAODVertex(posV0_3, |
338 | covV0_3, | |
df9db588 | 339 | v0->GetChi2V0(), |
340 | primary, | |
341 | AliAODVertex::kV0); | |
342 | primary->AddDaughter(vV0); | |
343 | ||
344 | Int_t posFromV0 = v0->GetPindex(); | |
345 | Int_t negFromV0 = v0->GetNindex(); | |
31fd97b2 | 346 | |
df9db588 | 347 | // Add the positive tracks from the V0 |
348 | ||
cf22b3fc | 349 | if (!usedTrack[posFromV0]) { |
350 | ||
351 | usedTrack[posFromV0] = kTRUE; | |
df9db588 | 352 | |
353 | AliESDtrack *esdTrack = esd->GetTrack(posFromV0); | |
354 | ||
31fd97b2 | 355 | Double_t p4[3]; |
356 | esdTrack->GetPxPyPz(p4); | |
df9db588 | 357 | |
31fd97b2 | 358 | Double_t x4[3]; |
359 | esdTrack->GetXYZ(x4); | |
df9db588 | 360 | |
31fd97b2 | 361 | Double_t covV0PosTr_2[21]; |
362 | esdTrack->GetCovarianceXYZPxPyPz(covV0PosTr_2); | |
cf22b3fc | 363 | |
31fd97b2 | 364 | Double_t pid4[10]; |
365 | esdTrack->GetESDpid(pid4); | |
df9db588 | 366 | |
367 | vV0->AddDaughter( | |
368 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
369 | esdTrack->GetLabel(), | |
31fd97b2 | 370 | p4, |
371 | kTRUE, | |
372 | x4, | |
df9db588 | 373 | kFALSE, |
31fd97b2 | 374 | covV0PosTr_2, |
df9db588 | 375 | (Short_t)esdTrack->GetSign(), |
376 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 377 | pid4, |
df9db588 | 378 | vV0, |
379 | AliAODTrack::kSecondary) | |
380 | ); | |
381 | } | |
cf22b3fc | 382 | else { |
383 | cerr << "Error: event " << iEvent << " V0 " << nV0 | |
384 | << " track " << posFromV0 << " has already been used!" << endl; | |
385 | } | |
df9db588 | 386 | |
387 | // Add the negative tracks from the V0 | |
388 | ||
cf22b3fc | 389 | if (!usedTrack[negFromV0]) { |
390 | ||
391 | usedTrack[negFromV0] = kTRUE; | |
df9db588 | 392 | |
393 | AliESDtrack *esdTrack = esd->GetTrack(negFromV0); | |
394 | ||
31fd97b2 | 395 | Double_t p5[3]; |
396 | esdTrack->GetPxPyPz(p5); | |
df9db588 | 397 | |
31fd97b2 | 398 | Double_t x5[3]; |
399 | esdTrack->GetXYZ(x5); | |
df9db588 | 400 | |
31fd97b2 | 401 | Double_t covV0NegTr_2[21]; |
402 | esdTrack->GetCovarianceXYZPxPyPz(covV0NegTr_2); | |
df9db588 | 403 | |
31fd97b2 | 404 | Double_t pid5[10]; |
405 | esdTrack->GetESDpid(pid5); | |
df9db588 | 406 | |
407 | vV0->AddDaughter( | |
408 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
409 | esdTrack->GetLabel(), | |
31fd97b2 | 410 | p5, |
df9db588 | 411 | kTRUE, |
31fd97b2 | 412 | x5, |
df9db588 | 413 | kFALSE, |
31fd97b2 | 414 | covV0NegTr_2, |
df9db588 | 415 | (Short_t)esdTrack->GetSign(), |
416 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 417 | pid5, |
df9db588 | 418 | vV0, |
419 | AliAODTrack::kSecondary) | |
420 | ); | |
421 | } | |
cf22b3fc | 422 | else { |
423 | cerr << "Error: event " << iEvent << " V0 " << nV0 | |
424 | << " track " << negFromV0 << " has already been used!" << endl; | |
425 | } | |
df9db588 | 426 | |
cf22b3fc | 427 | } // end of the loop on V0s |
df9db588 | 428 | |
cf22b3fc | 429 | // Kinks: it is a big mess the access to the information in the kinks |
430 | // The loop is on the tracks in order to find the mother and daugther of each kink | |
431 | ||
432 | ||
433 | for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) { | |
434 | ||
435 | ||
436 | AliESDtrack * track = esd->GetTrack(iTrack); | |
437 | ||
438 | ||
439 | Int_t ikink = track->GetKinkIndex(0); | |
440 | ||
441 | if (ikink) { | |
442 | // Negative kink index: mother, positive: daughter | |
443 | ||
444 | // Search for the second track of the kink | |
445 | ||
446 | for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) { | |
447 | ||
448 | AliESDtrack * track1 = esd->GetTrack(jTrack); | |
449 | ||
450 | Int_t jkink = track1->GetKinkIndex(0); | |
451 | ||
452 | if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) { | |
453 | ||
454 | // The two tracks are from the same kink | |
455 | ||
456 | if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks | |
457 | ||
458 | Int_t imother = -1; | |
459 | Int_t idaughter = -1; | |
460 | ||
461 | if (ikink<0 && jkink>0) { | |
462 | ||
463 | imother = iTrack; | |
464 | idaughter = jTrack; | |
465 | } | |
466 | else if (ikink>0 && jkink<0) { | |
467 | ||
468 | imother = jTrack; | |
469 | idaughter = iTrack; | |
470 | } | |
471 | else { | |
472 | cerr << "Error: Wrong combination of kink indexes: " | |
473 | << ikink << " " << jkink << endl; | |
474 | continue; | |
475 | } | |
476 | ||
477 | // Add the mother track | |
478 | ||
479 | AliAODTrack * mother = NULL; | |
480 | ||
481 | if (!usedTrack[imother]) { | |
482 | ||
483 | usedTrack[imother] = kTRUE; | |
484 | ||
485 | AliESDtrack *esdTrack = esd->GetTrack(imother); | |
486 | ||
31fd97b2 | 487 | Double_t p6[3]; |
488 | esdTrack->GetPxPyPz(p6); | |
cf22b3fc | 489 | |
31fd97b2 | 490 | Double_t x6[3]; |
491 | esdTrack->GetXYZ(x6); | |
cf22b3fc | 492 | |
31fd97b2 | 493 | Double_t covKinkMother[21]; |
494 | esdTrack->GetCovarianceXYZPxPyPz(covKinkMother); | |
cf22b3fc | 495 | |
31fd97b2 | 496 | Double_t pid6[10]; |
497 | esdTrack->GetESDpid(pid6); | |
498 | ||
cf22b3fc | 499 | mother = |
500 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
501 | esdTrack->GetLabel(), | |
31fd97b2 | 502 | p6, |
cf22b3fc | 503 | kTRUE, |
31fd97b2 | 504 | x6, |
cf22b3fc | 505 | kFALSE, |
31fd97b2 | 506 | covKinkMother, |
cf22b3fc | 507 | (Short_t)esdTrack->GetSign(), |
508 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 509 | pid6, |
cf22b3fc | 510 | primary, |
511 | AliAODTrack::kPrimary); | |
512 | primary->AddDaughter(mother); | |
513 | } | |
514 | else { | |
515 | cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1 | |
516 | << " track " << imother << " has already been used!" << endl; | |
517 | } | |
518 | ||
519 | // Add the kink vertex | |
520 | AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1); | |
521 | ||
522 | AliAODVertex * vkink = | |
523 | new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(), | |
524 | NULL, | |
525 | 0., | |
526 | mother, | |
527 | AliAODVertex::kKink); | |
528 | // Add the daughter track | |
529 | ||
530 | AliAODTrack * daughter = NULL; | |
531 | ||
532 | if (!usedTrack[idaughter]) { | |
533 | ||
534 | usedTrack[idaughter] = kTRUE; | |
535 | ||
536 | AliESDtrack *esdTrack = esd->GetTrack(idaughter); | |
537 | ||
31fd97b2 | 538 | Double_t p7[3]; |
539 | esdTrack->GetPxPyPz(p7); | |
cf22b3fc | 540 | |
31fd97b2 | 541 | Double_t x7[3]; |
542 | esdTrack->GetXYZ(x7); | |
cf22b3fc | 543 | |
31fd97b2 | 544 | Double_t covKinkDaughter[21]; |
545 | esdTrack->GetCovarianceXYZPxPyPz(covKinkDaughter); | |
cf22b3fc | 546 | |
31fd97b2 | 547 | Double_t pid7[10]; |
548 | esdTrack->GetESDpid(pid7); | |
549 | ||
cf22b3fc | 550 | daughter = |
551 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
552 | esdTrack->GetLabel(), | |
31fd97b2 | 553 | p7, |
cf22b3fc | 554 | kTRUE, |
31fd97b2 | 555 | x7, |
cf22b3fc | 556 | kFALSE, |
31fd97b2 | 557 | covKinkDaughter, |
cf22b3fc | 558 | (Short_t)esdTrack->GetSign(), |
559 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 560 | pid7, |
cf22b3fc | 561 | vkink, |
562 | AliAODTrack::kPrimary); | |
563 | vkink->AddDaughter(daughter); | |
564 | } | |
565 | else { | |
566 | cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1 | |
567 | << " track " << idaughter << " has already been used!" << endl; | |
568 | } | |
569 | ||
570 | ||
571 | } | |
572 | } | |
573 | ||
574 | } | |
df9db588 | 575 | |
df9db588 | 576 | } |
cf22b3fc | 577 | |
df9db588 | 578 | |
cf22b3fc | 579 | // Tracks (primary and orphan) |
df9db588 | 580 | |
581 | for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) { | |
582 | ||
583 | ||
584 | if (usedTrack[nTrack]) continue; | |
585 | ||
586 | AliESDtrack *esdTrack = esd->GetTrack(nTrack); | |
587 | ||
31fd97b2 | 588 | Double_t p8[3]; |
589 | esdTrack->GetPxPyPz(p8); | |
df9db588 | 590 | |
31fd97b2 | 591 | Double_t x8[3]; |
592 | esdTrack->GetXYZ(x8); | |
df9db588 | 593 | |
31fd97b2 | 594 | Double_t covTr[21]; |
595 | esdTrack->GetCovarianceXYZPxPyPz(covTr); | |
596 | ||
597 | Double_t pid8[10]; | |
598 | esdTrack->GetESDpid(pid8); | |
cf22b3fc | 599 | |
600 | Float_t impactXY, impactZ; | |
601 | ||
602 | esdTrack->GetImpactParameters(impactXY,impactZ); | |
603 | ||
604 | if (impactXY<3) { | |
605 | // track inside the beam pipe | |
df9db588 | 606 | |
cf22b3fc | 607 | primary->AddDaughter( |
608 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
df9db588 | 609 | esdTrack->GetLabel(), |
31fd97b2 | 610 | p8, |
df9db588 | 611 | kTRUE, |
31fd97b2 | 612 | x8, |
df9db588 | 613 | kFALSE, |
31fd97b2 | 614 | covTr, |
df9db588 | 615 | (Short_t)esdTrack->GetSign(), |
616 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 617 | pid8, |
df9db588 | 618 | primary, |
619 | AliAODTrack::kPrimary) | |
cf22b3fc | 620 | ); |
621 | } | |
622 | else { | |
623 | // outside the beam pipe: orphan track | |
624 | new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), | |
625 | esdTrack->GetLabel(), | |
31fd97b2 | 626 | p8, |
cf22b3fc | 627 | kTRUE, |
31fd97b2 | 628 | x8, |
cf22b3fc | 629 | kFALSE, |
31fd97b2 | 630 | covTr, |
cf22b3fc | 631 | (Short_t)esdTrack->GetSign(), |
632 | esdTrack->GetITSClusterMap(), | |
31fd97b2 | 633 | pid8, |
cf22b3fc | 634 | NULL, |
635 | AliAODTrack::kOrphan); | |
636 | } | |
637 | } // end of loop on tracks | |
638 | ||
639 | ||
640 | // Access to the AOD container of vertices | |
a9255000 | 641 | TClonesArray &clusters = *(aod->GetClusters()); |
cf22b3fc | 642 | Int_t jClusters=0; |
643 | ||
644 | // Clusters | |
645 | Int_t nClusters = esd->GetNumberOfCaloClusters(); | |
646 | ||
647 | for (Int_t iClust=0; iClust<nClusters; ++iClust) { | |
648 | ||
649 | AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust); | |
650 | ||
651 | Int_t id = cluster->GetID(); | |
652 | Int_t label = -1; | |
653 | Float_t energy = cluster->GetClusterEnergy(); | |
31fd97b2 | 654 | Float_t x9[3]; |
655 | cluster->GetGlobalPosition(x9); | |
cf22b3fc | 656 | Float_t * covMatrix = NULL; |
31fd97b2 | 657 | Float_t * pid9 = NULL; |
cf22b3fc | 658 | AliAODVertex *prodVertex = primary; |
659 | AliAODTrack *primTrack = NULL; | |
a9255000 | 660 | Char_t ttype=AliAODCluster::kUndef; |
cf22b3fc | 661 | |
a9255000 | 662 | if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral; |
cf22b3fc | 663 | else if (cluster->IsEMCAL()) { |
664 | ||
665 | if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster) | |
a9255000 | 666 | ttype = AliAODCluster::kEMCALPseudoCluster; |
cf22b3fc | 667 | else |
a9255000 | 668 | ttype = AliAODCluster::kEMCALClusterv1; |
cf22b3fc | 669 | |
670 | } | |
df9db588 | 671 | |
a9255000 | 672 | new(clusters[jClusters++]) AliAODCluster(id, |
cf22b3fc | 673 | label, |
674 | energy, | |
31fd97b2 | 675 | x9, |
cf22b3fc | 676 | covMatrix, |
31fd97b2 | 677 | pid9, |
cf22b3fc | 678 | prodVertex, |
679 | primTrack, | |
680 | ttype); | |
681 | ||
682 | } // end of loop on clusters | |
683 | ||
684 | ||
685 | delete [] usedTrack; | |
686 | delete [] usedV0; | |
687 | delete [] usedKink; | |
688 | ||
df9db588 | 689 | // fill the tree for this event |
690 | aodTree->Fill(); | |
cf22b3fc | 691 | } // end of event loop |
df9db588 | 692 | |
693 | aodTree->GetUserInfo()->Add(aod); | |
694 | ||
695 | // close ESD file | |
696 | inFile->Close(); | |
697 | ||
698 | // write the tree to the specified file | |
699 | outFile = aodTree->GetCurrentFile(); | |
700 | outFile->cd(); | |
701 | aodTree->Write(); | |
702 | outFile->Close(); | |
703 | ||
704 | } |