New class AliESDEvent, backward compatibility with the old AliESD (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 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   delete fESDObjects;
200   fESDObjects = 0;
201
202   // everthing on the list gets deleted automatically
203
204   /*
205   fHLTConfMapTracks.Delete();
206   fHLTHoughTracks.Delete();
207   fMuonTracks.Delete();  
208   fPmdTracks.Delete();
209   fTrdTracks.Delete();
210   fV0s.Delete();
211   fCascades.Delete();
212   fKinks.Delete();
213   fCaloClusters.Delete();
214   */
215 //   fEMCALTriggerPosition->Delete();
216 //   fEMCALTriggerAmplitudes->Delete();
217 //   fPHOSTriggerPosition->Delete();
218 //   fPHOSTriggerAmplitudes->Delete();
219 //   delete fEMCALTriggerPosition;
220 //   delete fEMCALTriggerAmplitudes;
221 //   delete fPHOSTriggerPosition;
222 //   delete fPHOSTriggerAmplitudes;
223
224 }
225
226 //______________________________________________________________________________
227 void AliESDEvent::Reset()
228 {
229
230   
231   // Reset the standard contents
232   ResetStdContent(); 
233
234   if(fESDOld)fESDOld->Reset();
235
236 }
237
238 void AliESDEvent::ResetStdContent()
239 {
240   // Reset the standard contents
241   if(fESDRun) fESDRun->Reset();
242   if(fHeader) fHeader->Reset();
243   if(fESDZDC) fESDZDC->Reset();
244   if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
245   // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED 
246   //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
247   if(fESDTZERO) fESDTZERO->Reset(); 
248   // CKB no clear/reset implemented
249   if(fSPDVertex){
250     new (fSPDVertex) AliESDVertex();
251     fSPDVertex->SetName("SPDVertex");
252   }
253   if(fPrimaryVertex){
254     new (fPrimaryVertex) AliESDVertex();
255     fPrimaryVertex->SetName("PrimaryVertex");
256   }
257   if(fSPDMult)new (fSPDMult) AliMultiplicity();
258   if(fPHOSTrigger)fPHOSTrigger->Reset(); 
259   if(fEMCALTrigger)fEMCALTrigger->Reset(); 
260   if(fTracks)fTracks->Clear();
261   if(fMuonTracks)fMuonTracks->Clear();
262   if(fPmdTracks)fPmdTracks->Clear();
263   if(fTrdTracks)fTrdTracks->Clear();
264   if(fV0s)fV0s->Clear();
265   if(fCascades)fCascades->Clear();
266   if(fKinks)fKinks->Clear();
267   if(fCaloClusters)fCaloClusters->Clear();
268   if(fErrorLogs) fErrorLogs->Clear();
269
270   fEMCALClusters=0; 
271   fFirstEMCALCluster=-1; 
272   fPHOSClusters=0; 
273   fFirstPHOSCluster=-1; 
274 }
275
276
277 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
278   //
279   // Add V0
280   //
281   TClonesArray &fv = *fV0s;
282   Int_t idx=fV0s->GetEntriesFast();
283   new(fv[idx]) AliESDv0(*v);
284   return idx;
285 }  
286
287 //______________________________________________________________________________
288 void AliESDEvent::Print(Option_t *) const 
289 {
290   //
291   // Print header information of the event
292   //
293   printf("ESD run information\n");
294   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
295          GetEventNumberInFile(),
296          GetBunchCrossNumber(),
297          GetOrbitNumber(),
298          GetPeriodNumber(),
299          GetRunNumber(),
300          GetTriggerMask(),
301          GetMagneticField() );
302   printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
303            fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
304            fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
305            fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
306     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
307            GetDiamondX(),GetDiamondY());
308     printf("SPD Multiplicity. Number of tracklets %d \n",
309            fSPDMult->GetNumberOfTracklets());
310   printf("Number of tracks: \n");
311   printf("                 charged   %d\n", GetNumberOfTracks());
312   printf("                 muon      %d\n", GetNumberOfMuonTracks());
313   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
314   printf("                 trd       %d\n", GetNumberOfTrdTracks());
315   printf("                 v0        %d\n", GetNumberOfV0s());
316   printf("                 cascades  %d\n", GetNumberOfCascades());
317   printf("                 kinks     %d\n", GetNumberOfKinks());
318   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
319   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
320   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
321   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
322   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
323 }
324
325 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
326   //
327   // Attaches the complementary info to the ESD
328   //
329   if (!ev) return;
330
331   Int_t ntrk=ev->GetNumberOfTracks();
332  
333   for (Int_t i=0; i<ntrk; i++) {
334     const AliESDfriendTrack *f=ev->GetTrack(i);
335     GetTrack(i)->SetFriendTrack(f);
336   }
337 }
338
339 Int_t  AliESDEvent::AddTrack(const AliESDtrack *t) {
340     // Add track
341     TClonesArray &ftr = *fTracks;
342     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
343     track->SetID(fTracks->GetEntriesFast()-1);
344     return  track->GetID();    
345 }
346
347 Int_t AliESDEvent::AddKink(const AliESDkink *c) {
348     // Add kink
349     TClonesArray &fk = *fKinks;
350     AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
351     kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
352     return fKinks->GetEntriesFast()-1;
353 }
354
355 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
356     // Add calocluster
357     TClonesArray &fc = *fCaloClusters;
358     AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
359     clus->SetID(fCaloClusters->GetEntriesFast()-1);
360     return fCaloClusters->GetEntriesFast()-1;
361   }
362
363
364 void AliESDEvent::SetFMDData(AliESDFMD * obj) { 
365   // use already allocated space
366   if(fESDFMD){
367     new(fESDFMD) AliESDFMD(*obj); 
368   }
369 }
370
371 void AliESDEvent::SetVZEROData(AliESDVZERO * obj){ 
372   // use already allocated space
373   if(fESDVZERO)
374     new(fESDVZERO) AliESDVZERO(*obj);
375 }
376
377 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
378   //
379   // Extracts the complementary info from the ESD
380   //
381   if (!ev) return;
382
383   Int_t ntrk=GetNumberOfTracks();
384
385   for (Int_t i=0; i<ntrk; i++) {
386     const AliESDtrack *t=GetTrack(i);
387     const AliESDfriendTrack *f=t->GetFriendTrack();
388     ev->AddTrack(f);
389   }
390 }
391
392
393 void AliESDEvent::AddObject(TObject* obj) 
394 {
395   // Add an object to the list of object.
396   // Please be aware that in order to increase performance you should
397   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
398   fESDObjects->SetOwner(kTRUE);
399   fESDObjects->AddLast(obj);
400 }
401
402
403 void AliESDEvent::GetStdContent() 
404 {
405   // set pointers for standard content
406
407   fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
408   fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
409   fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
410   fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
411   fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
412   fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
413   fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
414   fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
415   fSPDMult =       (AliMultiplicity*)fESDObjects->At(kSPDMult);
416   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
417   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
418   fTracks = (TClonesArray*)fESDObjects->At(kTracks);
419   fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
420   fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
421   fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
422   fV0s = (TClonesArray*)fESDObjects->At(kV0s);
423   fCascades = (TClonesArray*)fESDObjects->At(kCascades);
424   fKinks = (TClonesArray*)fESDObjects->At(kKinks);
425   fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
426   fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
427
428 }
429
430 void AliESDEvent::SetStdNames(){
431   // Set the names of the standard contents
432   fSPDVertex->SetName("SPDVertex");
433   fPrimaryVertex->SetName("PrimaryVertex");
434   fPHOSTrigger->SetName("PHOSTrigger");
435   fEMCALTrigger->SetName("EMCALTrigger");
436   fTracks->SetName("Tracks");
437   fMuonTracks->SetName("MuonTracks");
438   fPmdTracks->SetName("PmdTracks");
439   fTrdTracks->SetName("TrdTracks");
440   fV0s->SetName("V0s");
441   fCascades->SetName("Cascades");
442   fKinks->SetName("Kinks");
443   fCaloClusters->SetName("CaloClusters");
444
445
446
447 void AliESDEvent::CreateStdContent() 
448 {
449   // create the standard AOD content and set pointers
450
451   // create standard objects and add them to the TList of objects
452   AddObject(new AliESDRun());
453   AddObject(new AliESDHeader());
454   AddObject(new AliESDZDC());
455   AddObject(new AliESDFMD());
456   AddObject(new AliESDVZERO());
457   AddObject(new AliESDTZERO());
458   AddObject(new AliESDVertex());
459   AddObject(new AliESDVertex());
460   AddObject(new AliMultiplicity());
461   AddObject(new AliESDCaloTrigger());
462   AddObject(new AliESDCaloTrigger());
463   AddObject(new TClonesArray("AliESDtrack",0));
464   AddObject(new TClonesArray("AliESDMuonTrack",0));
465   AddObject(new TClonesArray("AliESDPmdTrack",0));
466   AddObject(new TClonesArray("AliESDTrdTrack",0));
467   AddObject(new TClonesArray("AliESDv0",0));
468   AddObject(new TClonesArray("AliESDcascade",0));
469   AddObject(new TClonesArray("AliESDkink",0));
470   AddObject(new TClonesArray("AliESDCaloCluster",0));
471   AddObject(new TClonesArray("AliRawDataErrorLog",0));
472
473   // check the order of the indices against enum...
474
475   // read back pointers
476   GetStdContent();
477   // set names
478   SetStdNames();
479
480 }
481
482 void AliESDEvent::ReadFromTree(TTree *tree){
483   
484  
485   // if we just replace the TList we produce a memory leak...
486   // so better replace the TList 
487
488   if(fESDObjects->GetEntries()!=0){
489     // this should not happen here put a warning?
490   }
491  
492   // prevent a memory leak when reading back the TList
493   delete fESDObjects;
494   fESDObjects = 0;
495   
496
497
498   // if we find the esd on the tree we do have the old structuru
499   if(tree->GetBranch("ESD")){
500     printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
501     tree->SetBranchAddress("ESD",&fESDOld);
502     fESDObjects = new TList();
503     CreateStdContent(); // create for copy
504     // when reading back we are not owner of the list 
505     // must not delete it
506     fESDObjects->SetOwner(kFALSE);
507     return;
508   }
509
510   fESDOld = 0;
511
512
513   // Try to find AliESDEvent
514   AliESDEvent *esdEvent = 0;
515   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
516
517
518   if(esdEvent){
519     // create a new TList from the UserInfo TList... 
520     // copy constructor does not work...
521     fESDObjects = (TList*)(esdEvent->GetList()->Clone());
522     // fESDObjects = esdEvent->GetList(); 
523     if(fESDObjects->GetEntries()<kESDListN){
524       printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",(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->SetBranchStatus("ESDfriend.*",1); // Use a flag to activate... 
536           tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
537         }
538       else{
539         tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
540       }
541     }
542     GetStdContent();
543     // when reading back we are not owner of the list 
544     // must not delete it
545     fESDObjects->SetOwner(kFALSE);
546   }// no esdEvent
547   else {
548     // Hack.... we can't get the list from the user data try create and set it by hand...
549     fESDObjects = new TList(); 
550     CreateStdContent();
551     TIter next(fESDObjects);
552     TNamed *el;
553     while((el=(TNamed*)next())){
554       TString bname(el->GetName());    
555       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
556     }
557     GetStdContent();
558     // when reading back we are not owner of the list 
559     // must not delete it
560     fESDObjects->SetOwner(kFALSE);
561   }
562
563
564
565 }
566
567
568 void AliESDEvent::CopyFromOldESD()
569 {
570   // Method which copies over everthing from the old esd structure to the 
571   // new  
572
573   if(fESDOld){
574     ResetStdContent();
575      // Run
576     SetRunNumber(fESDOld->GetRunNumber());
577     SetPeriodNumber(fESDOld->GetPeriodNumber());
578     SetMagneticField(fESDRun->GetMagneticField());
579   
580     // leave out diamond ...
581     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
582
583     // header
584     SetTriggerMask(fESDOld->GetTriggerMask());
585     SetOrbitNumber(fESDOld->GetOrbitNumber());
586     SetTimeStamp(fESDOld->GetTimeStamp());
587     SetEventType(fESDOld->GetEventType());
588     SetEventNumberInFile(fESDOld->GetEventNumberInFile());
589     SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
590     SetTriggerCluster(fESDOld->GetTriggerCluster());
591
592     // ZDC
593
594     SetZDC(fESDOld->GetZDCN1Energy(),
595            fESDOld->GetZDCP1Energy(),
596            fESDOld->GetZDCEMEnergy(),
597            fESDOld->GetZDCN2Energy(),
598            fESDOld->GetZDCP2Energy(),
599            fESDOld->GetZDCParticipants());
600
601     // FMD
602     
603     SetFMDData(fESDOld->GetFMDData());
604
605     // T0
606
607     SetT0zVertex(fESDOld->GetT0zVertex());
608     SetT0(fESDOld->GetT0());
609     //  leave amps out
610
611     // VZERO
612     SetVZEROData(fESDOld->GetVZEROData());
613
614     SetVertex(fESDOld->GetVertex());
615
616     SetPrimaryVertex(fESDOld->GetPrimaryVertex());
617
618     SetMultiplicity(fESDOld->GetMultiplicity());
619     
620     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
621       AddTrack(fESDOld->GetTrack(i));
622     }
623
624     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
625       AddMuonTrack(fESDOld->GetMuonTrack(i));
626     }
627
628     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
629       AddPmdTrack(fESDOld->GetPmdTrack(i));
630     }
631
632     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
633       AddTrdTrack(fESDOld->GetTrdTrack(i));
634     }
635
636     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
637       AddV0(fESDOld->GetV0(i));
638     }
639
640     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
641       AddCascade(fESDOld->GetCascade(i));
642     }
643
644     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
645       AddKink(fESDOld->GetKink(i));
646     }
647
648
649     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
650       AddCaloCluster(fESDOld->GetCaloCluster(i));
651     }
652   }// if fesdold
653 }
654
655
656