Added GetListObject() Method, some cosmetic changes
[u/mrichter/AliRoot.git] / STEER / AliESDEvent.cxx
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
36 ClassImp(AliESDEvent)
37
38 //______________________________________________________________________________
39 AliESDEvent::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 //______________________________________________________________________________
69 AliESDEvent::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 //______________________________________________________________________________
126 AliESDEvent & 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 //______________________________________________________________________________
193 AliESDEvent::~AliESDEvent()
194 {
195   //
196   // Standard destructor
197   //
198
199   // everthing on the list gets deleted automatically
200   delete fESDObjects;
201   fESDObjects = 0;
202 }
203
204 //______________________________________________________________________________
205 void AliESDEvent::Reset()
206 {
207
208   
209   // Reset the standard contents
210   ResetStdContent(); 
211
212   if(fESDOld)fESDOld->Reset();
213   // call reset for user supplied data?
214 }
215
216 void 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
255 Int_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 //______________________________________________________________________________
266 void 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
303 void 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
317 Int_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
325 Int_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
333 Int_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
342 void AliESDEvent::SetFMDData(AliESDFMD * obj) { 
343   // use already allocated space
344   if(fESDFMD){
345     new(fESDFMD) AliESDFMD(*obj); 
346   }
347 }
348
349 void AliESDEvent::SetVZEROData(AliESDVZERO * obj){ 
350   // use already allocated space
351   if(fESDVZERO)
352     new(fESDVZERO) AliESDVZERO(*obj);
353 }
354
355 void 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
371 void 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
381 void AliESDEvent::GetStdContent() 
382 {
383   // set pointers for standard content
384   // eventually get by name?
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
408 void 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
425 void 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
460 TObject* AliESDEvent::FindListObject(const char *name){
461   if(fESDObjects)return fESDObjects->FindObject(name);
462   return 0;
463
464
465 void AliESDEvent::ReadFromTree(TTree *tree){
466   
467  
468   // if we find the "ESD" branch on the tree we do have the old structure
469   if(tree->GetBranch("ESD")){
470     printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
471     tree->SetBranchAddress("ESD",&fESDOld);
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
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;
494     // create a new TList from the UserInfo TList... 
495     // copy constructor does not work...
496     fESDObjects = (TList*)(esdEvent->GetList()->Clone());
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 ...
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 {
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
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
541 void 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