]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliESDEvent.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Use AliESDEvent instead of AliESD.
[u/mrichter/AliRoot.git] / STEER / AliESDEvent.cxx
CommitLineData
af885e0f 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/* $Id$ */
17
18//-----------------------------------------------------------------
19// Implementation of the ESD class
20// This is the class to deal with during the phisical analysis of data
21// This class is generated directly by the reconstruction methods
22// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
23//-----------------------------------------------------------------
24
25#include "TList.h"
26#include <TNamed.h>
27
28#include "AliESDEvent.h"
29#include "AliESDfriend.h"
30#include "AliESDVZERO.h"
31#include "AliESDHLTtrack.h"
32#include "AliESDFMD.h"
33#include "AliESD.h"
34
35
36ClassImp(AliESDEvent)
37
38//______________________________________________________________________________
39AliESDEvent::AliESDEvent():
40 fESDObjects(new TList()),
41 fESDRun(0),
42 fHeader(0),
43 fESDZDC(0),
44 fESDFMD(0),
45 fESDVZERO(0),
46 fESDTZERO(0),
47 fSPDVertex(0),
48 fPrimaryVertex(0),
49 fSPDMult(0),
50 fPHOSTrigger(0),
51 fEMCALTrigger(0),
52 fTracks(0),
53 fMuonTracks(0),
54 fPmdTracks(0),
55 fTrdTracks(0),
56 fV0s(0),
57 fCascades(0),
58 fKinks(0),
59 fCaloClusters(0),
60 fErrorLogs(0),
61 fESDOld(0),
62 fEMCALClusters(0),
63 fFirstEMCALCluster(-1),
64 fPHOSClusters(0),
65 fFirstPHOSCluster(-1)
66{
67}
68//______________________________________________________________________________
69AliESDEvent::AliESDEvent(const AliESDEvent& esd):
70 TObject(esd),
71 fESDObjects(new TList()),
72 fESDRun(new AliESDRun(*esd.fESDRun)),
73 fHeader(new AliESDHeader(*esd.fHeader)),
74 fESDZDC(new AliESDZDC(*esd.fESDZDC)),
75 fESDFMD(new AliESDFMD(*esd.fESDFMD)),
76 fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
77 fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
78 fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
79 fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
80 fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
81 fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
82 fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
83 fTracks(new TClonesArray(*esd.fTracks)),
84 fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
85 fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
86 fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
87 fV0s(new TClonesArray(*esd.fV0s)),
88 fCascades(new TClonesArray(*esd.fCascades)),
89 fKinks(new TClonesArray(*esd.fKinks)),
90 fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
91 fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
92 fESDOld(new AliESD(*esd.fESDOld)),
93 fEMCALClusters(esd.fEMCALClusters),
94 fFirstEMCALCluster(esd.fFirstEMCALCluster),
95 fPHOSClusters(esd.fPHOSClusters),
96 fFirstPHOSCluster(esd.fFirstPHOSCluster)
97
98{
99 // CKB init in the constructor list and only add here ...
100 AddObject(fESDRun);
101 AddObject(fHeader);
102 AddObject(fESDZDC);
103 AddObject(fESDFMD);
104 AddObject(fESDVZERO);
105 AddObject(fESDTZERO);
106 AddObject(fSPDVertex);
107 AddObject(fPrimaryVertex);
108 AddObject(fSPDMult);
109 AddObject(fPHOSTrigger);
110 AddObject(fEMCALTrigger);
111 AddObject(fTracks);
112 AddObject(fMuonTracks);
113 AddObject(fPmdTracks);
114 AddObject(fTrdTracks);
115 AddObject(fV0s);
116 AddObject(fCascades);
117 AddObject(fKinks);
118 AddObject(fCaloClusters);
119 AddObject(fErrorLogs);
120
121 GetStdContent();
122
123}
124
125//______________________________________________________________________________
126AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
127
128 // Assignment operator
129
130 if(&source == this) return *this;
131 TObject::operator=(source);
132
133 fESDRun = new AliESDRun(*source.fESDRun);
134 fHeader = new AliESDHeader(*source.fHeader);
135 fESDZDC = new AliESDZDC(*source.fESDZDC);
136 fESDFMD = new AliESDFMD(*source.fESDFMD);
137 fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
138 fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
139 fSPDVertex = new AliESDVertex(*source.fSPDVertex);
140 fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
141 fSPDMult = new AliMultiplicity(*source.fSPDMult);
142 fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
143 fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
144 fTracks = new TClonesArray(*source.fTracks);
145 fMuonTracks = new TClonesArray(*source.fMuonTracks);
146 fPmdTracks = new TClonesArray(*source.fPmdTracks);
147 fTrdTracks = new TClonesArray(*source.fTrdTracks);
148 fV0s = new TClonesArray(*source.fV0s);
149 fCascades = new TClonesArray(*source.fCascades);
150 fKinks = new TClonesArray(*source.fKinks);
151 fCaloClusters = new TClonesArray(*source.fCaloClusters);
152 fErrorLogs = new TClonesArray(*source.fErrorLogs);
153 fESDOld = new AliESD(*source.fESDOld);
154 // CKB this way?? or
155 // or AddObject( fESDZDC = new AliESDZDC(*source.fESDZDC));
156
157 fESDObjects = new TList();
158 AddObject(fESDRun);
159 AddObject(fHeader);
160 AddObject(fESDZDC);
161 AddObject(fESDFMD);
162 AddObject(fESDVZERO);
163 AddObject(fESDTZERO);
164 AddObject(fSPDVertex);
165 AddObject(fPrimaryVertex);
166 AddObject(fSPDMult);
167 AddObject(fPHOSTrigger);
168 AddObject(fEMCALTrigger);
169 AddObject(fTracks);
170 AddObject(fMuonTracks);
171 AddObject(fPmdTracks);
172 AddObject(fTrdTracks);
173 AddObject(fV0s);
174 AddObject(fCascades);
175 AddObject(fKinks);
176 AddObject(fCaloClusters);
177 AddObject(fErrorLogs);
178
179
180 fEMCALClusters = source.fEMCALClusters;
181 fFirstEMCALCluster = source.fFirstEMCALCluster;
182 fPHOSClusters = source.fPHOSClusters;
183 fFirstPHOSCluster = source.fFirstPHOSCluster;
184
185
186
187 return *this;
188
189}
190
191
192//______________________________________________________________________________
193AliESDEvent::~AliESDEvent()
194{
195 //
196 // Standard destructor
197 //
198
001b9beb 199 // everthing on the list gets deleted automatically
af885e0f 200 delete fESDObjects;
201 fESDObjects = 0;
af885e0f 202}
203
204//______________________________________________________________________________
205void AliESDEvent::Reset()
206{
207
208
209 // Reset the standard contents
210 ResetStdContent();
211
212 if(fESDOld)fESDOld->Reset();
001b9beb 213 // call reset for user supplied data?
af885e0f 214}
215
216void AliESDEvent::ResetStdContent()
217{
218 // Reset the standard contents
219 if(fESDRun) fESDRun->Reset();
220 if(fHeader) fHeader->Reset();
221 if(fESDZDC) fESDZDC->Reset();
222 if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
223 // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
224 // if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
225 if(fESDTZERO) fESDTZERO->Reset();
226 // CKB no clear/reset implemented
227 if(fSPDVertex){
228 new (fSPDVertex) AliESDVertex();
229 fSPDVertex->SetName("SPDVertex");
230 }
231 if(fPrimaryVertex){
232 new (fPrimaryVertex) AliESDVertex();
233 fPrimaryVertex->SetName("PrimaryVertex");
234 }
235 if(fSPDMult)new (fSPDMult) AliMultiplicity();
236 if(fPHOSTrigger)fPHOSTrigger->Reset();
237 if(fEMCALTrigger)fEMCALTrigger->Reset();
238 if(fTracks)fTracks->Clear();
239 if(fMuonTracks)fMuonTracks->Clear();
240 if(fPmdTracks)fPmdTracks->Clear();
241 if(fTrdTracks)fTrdTracks->Clear();
242 if(fV0s)fV0s->Clear();
243 if(fCascades)fCascades->Clear();
244 if(fKinks)fKinks->Clear();
245 if(fCaloClusters)fCaloClusters->Clear();
246 if(fErrorLogs) fErrorLogs->Clear();
247
248 fEMCALClusters=0;
249 fFirstEMCALCluster=-1;
250 fPHOSClusters=0;
251 fFirstPHOSCluster=-1;
252}
253
254
255Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
256 //
257 // Add V0
258 //
259 TClonesArray &fv = *fV0s;
260 Int_t idx=fV0s->GetEntriesFast();
261 new(fv[idx]) AliESDv0(*v);
262 return idx;
263}
264
265//______________________________________________________________________________
266void AliESDEvent::Print(Option_t *) const
267{
268 //
269 // Print header information of the event
270 //
271 printf("ESD run information\n");
272 printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
273 GetEventNumberInFile(),
274 GetBunchCrossNumber(),
275 GetOrbitNumber(),
276 GetPeriodNumber(),
277 GetRunNumber(),
278 GetTriggerMask(),
279 GetMagneticField() );
280 printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
281 fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
282 fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
283 fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
284 printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
285 GetDiamondX(),GetDiamondY());
286 printf("SPD Multiplicity. Number of tracklets %d \n",
287 fSPDMult->GetNumberOfTracklets());
288 printf("Number of tracks: \n");
289 printf(" charged %d\n", GetNumberOfTracks());
290 printf(" muon %d\n", GetNumberOfMuonTracks());
291 printf(" pmd %d\n", GetNumberOfPmdTracks());
292 printf(" trd %d\n", GetNumberOfTrdTracks());
293 printf(" v0 %d\n", GetNumberOfV0s());
294 printf(" cascades %d\n", GetNumberOfCascades());
295 printf(" kinks %d\n", GetNumberOfKinks());
296 printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
297 printf(" phos %d\n", GetNumberOfPHOSClusters());
298 printf(" emcal %d\n", GetNumberOfEMCALClusters());
299 printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
300 printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
301}
302
303void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
304 //
305 // Attaches the complementary info to the ESD
306 //
307 if (!ev) return;
308
309 Int_t ntrk=ev->GetNumberOfTracks();
310
311 for (Int_t i=0; i<ntrk; i++) {
312 const AliESDfriendTrack *f=ev->GetTrack(i);
313 GetTrack(i)->SetFriendTrack(f);
314 }
315}
316
317Int_t AliESDEvent::AddTrack(const AliESDtrack *t) {
318 // Add track
319 TClonesArray &ftr = *fTracks;
320 AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
321 track->SetID(fTracks->GetEntriesFast()-1);
322 return track->GetID();
323}
324
325Int_t AliESDEvent::AddKink(const AliESDkink *c) {
326 // Add kink
327 TClonesArray &fk = *fKinks;
328 AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
329 kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
330 return fKinks->GetEntriesFast()-1;
331}
332
333Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
334 // Add calocluster
335 TClonesArray &fc = *fCaloClusters;
336 AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
337 clus->SetID(fCaloClusters->GetEntriesFast()-1);
338 return fCaloClusters->GetEntriesFast()-1;
339 }
340
341
342void AliESDEvent::SetFMDData(AliESDFMD * obj) {
343 // use already allocated space
344 if(fESDFMD){
345 new(fESDFMD) AliESDFMD(*obj);
346 }
347}
348
349void AliESDEvent::SetVZEROData(AliESDVZERO * obj){
350 // use already allocated space
351 if(fESDVZERO)
352 new(fESDVZERO) AliESDVZERO(*obj);
353}
354
355void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
356 //
357 // Extracts the complementary info from the ESD
358 //
359 if (!ev) return;
360
361 Int_t ntrk=GetNumberOfTracks();
362
363 for (Int_t i=0; i<ntrk; i++) {
364 const AliESDtrack *t=GetTrack(i);
365 const AliESDfriendTrack *f=t->GetFriendTrack();
366 ev->AddTrack(f);
367 }
368}
369
370
371void AliESDEvent::AddObject(TObject* obj)
372{
373 // Add an object to the list of object.
374 // Please be aware that in order to increase performance you should
375 // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
376 fESDObjects->SetOwner(kTRUE);
377 fESDObjects->AddLast(obj);
378}
379
380
381void AliESDEvent::GetStdContent()
382{
383 // set pointers for standard content
001b9beb 384 // eventually get by name?
af885e0f 385 fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
386 fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
387 fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
388 fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
389 fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
390 fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
391 fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
392 fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
393 fSPDMult = (AliMultiplicity*)fESDObjects->At(kSPDMult);
394 fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
395 fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
396 fTracks = (TClonesArray*)fESDObjects->At(kTracks);
397 fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
398 fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
399 fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
400 fV0s = (TClonesArray*)fESDObjects->At(kV0s);
401 fCascades = (TClonesArray*)fESDObjects->At(kCascades);
402 fKinks = (TClonesArray*)fESDObjects->At(kKinks);
403 fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
404 fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
405
406}
407
408void AliESDEvent::SetStdNames(){
409 // Set the names of the standard contents
410 fSPDVertex->SetName("SPDVertex");
411 fPrimaryVertex->SetName("PrimaryVertex");
412 fPHOSTrigger->SetName("PHOSTrigger");
413 fEMCALTrigger->SetName("EMCALTrigger");
414 fTracks->SetName("Tracks");
415 fMuonTracks->SetName("MuonTracks");
416 fPmdTracks->SetName("PmdTracks");
417 fTrdTracks->SetName("TrdTracks");
418 fV0s->SetName("V0s");
419 fCascades->SetName("Cascades");
420 fKinks->SetName("Kinks");
421 fCaloClusters->SetName("CaloClusters");
422
423}
424
425void AliESDEvent::CreateStdContent()
426{
427 // create the standard AOD content and set pointers
428
429 // create standard objects and add them to the TList of objects
430 AddObject(new AliESDRun());
431 AddObject(new AliESDHeader());
432 AddObject(new AliESDZDC());
433 AddObject(new AliESDFMD());
434 AddObject(new AliESDVZERO());
435 AddObject(new AliESDTZERO());
436 AddObject(new AliESDVertex());
437 AddObject(new AliESDVertex());
438 AddObject(new AliMultiplicity());
439 AddObject(new AliESDCaloTrigger());
440 AddObject(new AliESDCaloTrigger());
441 AddObject(new TClonesArray("AliESDtrack",0));
442 AddObject(new TClonesArray("AliESDMuonTrack",0));
443 AddObject(new TClonesArray("AliESDPmdTrack",0));
444 AddObject(new TClonesArray("AliESDTrdTrack",0));
445 AddObject(new TClonesArray("AliESDv0",0));
446 AddObject(new TClonesArray("AliESDcascade",0));
447 AddObject(new TClonesArray("AliESDkink",0));
448 AddObject(new TClonesArray("AliESDCaloCluster",0));
449 AddObject(new TClonesArray("AliRawDataErrorLog",0));
450
451 // check the order of the indices against enum...
452
453 // read back pointers
454 GetStdContent();
455 // set names
456 SetStdNames();
457
458}
459
001b9beb 460TObject* AliESDEvent::FindListObject(const char *name){
461 if(fESDObjects)return fESDObjects->FindObject(name);
462 return 0;
463}
464
af885e0f 465void AliESDEvent::ReadFromTree(TTree *tree){
466
467
001b9beb 468 // if we find the "ESD" branch on the tree we do have the old structure
af885e0f 469 if(tree->GetBranch("ESD")){
470 printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
471 tree->SetBranchAddress("ESD",&fESDOld);
af885e0f 472 CreateStdContent(); // create for copy
473 // when reading back we are not owner of the list
474 // must not delete it
475 fESDObjects->SetOwner(kFALSE);
476 return;
477 }
478
479 fESDOld = 0;
480
481
482 // Try to find AliESDEvent
483 AliESDEvent *esdEvent = 0;
484 esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
485
486
001b9beb 487 if(esdEvent){
488 if(fESDObjects->GetEntries()!=0){
489 // this should not happen here put a warning?
490 }
491 // prevent a memory leak when reading back the TList
492 delete fESDObjects;
493 fESDObjects = 0;
af885e0f 494 // create a new TList from the UserInfo TList...
495 // copy constructor does not work...
496 fESDObjects = (TList*)(esdEvent->GetList()->Clone());
af885e0f 497 if(fESDObjects->GetEntries()<kESDListN){
498 printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",(char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
499 }
500 // set the branch addresses
501 TIter next(fESDObjects);
502 TNamed *el;
503 while((el=(TNamed*)next())){
504 TString bname(el->GetName());
505
506 if(bname.CompareTo("AliESDfriend")==0)
507 {
508 // AliESDfriend does not have a name ...
af885e0f 509 tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
510 }
511 else{
512 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
513 }
514 }
515 GetStdContent();
516 // when reading back we are not owner of the list
517 // must not delete it
518 fESDObjects->SetOwner(kFALSE);
519 }// no esdEvent
520 else {
001b9beb 521 // we can't get the list from the user data, create standard content
522 // and set it by hand (no ESDfriend at the moment
af885e0f 523 CreateStdContent();
524 TIter next(fESDObjects);
525 TNamed *el;
526 while((el=(TNamed*)next())){
527 TString bname(el->GetName());
528 tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
529 }
530 GetStdContent();
531 // when reading back we are not owner of the list
532 // must not delete it
533 fESDObjects->SetOwner(kFALSE);
534 }
535
536
537
538}
539
540
541void AliESDEvent::CopyFromOldESD()
542{
543 // Method which copies over everthing from the old esd structure to the
544 // new
545
546 if(fESDOld){
547 ResetStdContent();
548 // Run
549 SetRunNumber(fESDOld->GetRunNumber());
550 SetPeriodNumber(fESDOld->GetPeriodNumber());
551 SetMagneticField(fESDRun->GetMagneticField());
552
553 // leave out diamond ...
554 // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
555
556 // header
557 SetTriggerMask(fESDOld->GetTriggerMask());
558 SetOrbitNumber(fESDOld->GetOrbitNumber());
559 SetTimeStamp(fESDOld->GetTimeStamp());
560 SetEventType(fESDOld->GetEventType());
561 SetEventNumberInFile(fESDOld->GetEventNumberInFile());
562 SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
563 SetTriggerCluster(fESDOld->GetTriggerCluster());
564
565 // ZDC
566
567 SetZDC(fESDOld->GetZDCN1Energy(),
568 fESDOld->GetZDCP1Energy(),
569 fESDOld->GetZDCEMEnergy(),
570 fESDOld->GetZDCN2Energy(),
571 fESDOld->GetZDCP2Energy(),
572 fESDOld->GetZDCParticipants());
573
574 // FMD
575
576 SetFMDData(fESDOld->GetFMDData());
577
578 // T0
579
580 SetT0zVertex(fESDOld->GetT0zVertex());
581 SetT0(fESDOld->GetT0());
582 // leave amps out
583
584 // VZERO
585 SetVZEROData(fESDOld->GetVZEROData());
586
587 SetVertex(fESDOld->GetVertex());
588
589 SetPrimaryVertex(fESDOld->GetPrimaryVertex());
590
591 SetMultiplicity(fESDOld->GetMultiplicity());
592
593 for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
594 AddTrack(fESDOld->GetTrack(i));
595 }
596
597 for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
598 AddMuonTrack(fESDOld->GetMuonTrack(i));
599 }
600
601 for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
602 AddPmdTrack(fESDOld->GetPmdTrack(i));
603 }
604
605 for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
606 AddTrdTrack(fESDOld->GetTrdTrack(i));
607 }
608
609 for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
610 AddV0(fESDOld->GetV0(i));
611 }
612
613 for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
614 AddCascade(fESDOld->GetCascade(i));
615 }
616
617 for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
618 AddKink(fESDOld->GetKink(i));
619 }
620
621
622 for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
623 AddCaloCluster(fESDOld->GetCaloCluster(i));
624 }
625 }// if fesdold
626}
627
628
629