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