0de296ea9b33f2514dae9a41c3c1683231fa6c3d
[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 physics analysis of data.
21 //   It also ensures the backward compatibility with the old ESD format.
22 /*
23    AliESDEvent *ev= new AliESDEvent();
24    ev->ReadFromTree(esdTree);
25    ...
26     for (Int_t i=0; i<nev; i++) {
27       esdTree->GetEntry(i);
28       if(ev->GetAliESDOld())ev->CopyFromOldESD();
29 */
30 //   The AliESDInputHandler does this automatically for you
31 //
32 // Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
33 //-----------------------------------------------------------------
34
35 #include "TList.h"
36 #include "TRefArray.h"
37 #include <TNamed.h>
38
39 #include "AliESDEvent.h"
40 #include "AliESDfriend.h"
41 #include "AliESDVZERO.h"
42 #include "AliESDFMD.h"
43 #include "AliESD.h"
44 #include "AliESDMuonTrack.h"
45 #include "AliESDPmdTrack.h"
46 #include "AliESDTrdTrack.h"
47 #include "AliESDVertex.h"
48 #include "AliESDcascade.h"
49 #include "AliESDPmdTrack.h"
50 #include "AliESDTrdTrack.h"
51 #include "AliESDVertex.h"
52 #include "AliESDcascade.h"
53 #include "AliESDkink.h"
54 #include "AliESDtrack.h"
55 #include "AliESDHLTtrack.h"
56 #include "AliESDCaloCluster.h"
57 #include "AliESDCaloCells.h"
58 #include "AliESDv0.h"
59 #include "AliESDFMD.h"
60 #include "AliESDVZERO.h"
61 #include "AliMultiplicity.h"
62 #include "AliRawDataErrorLog.h"
63 #include "AliLog.h"
64 #include "AliESDACORDE.h"
65 ClassImp(AliESDEvent)
66
67
68
69 // here we define the names, some classes are no TNamed, therefore the classnames 
70 // are the Names
71   const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun",
72                                                        "AliESDHeader",
73                                                        "AliESDZDC",
74                                                        "AliESDFMD",
75                                                        "AliESDVZERO",
76                                                        "AliESDTZERO",
77                                                        "TPCVertex",
78                                                        "SPDVertex",
79                                                        "PrimaryVertex",
80                                                        "AliMultiplicity",
81                                                        "PHOSTrigger",
82                                                        "EMCALTrigger",
83                                                        "Tracks",
84                                                        "MuonTracks",
85                                                        "PmdTracks",
86                                                        "TrdTracks",
87                                                        "V0s",
88                                                        "Cascades",
89                                                        "Kinks",
90                                                        "CaloClusters",
91                                                       "EMCALCells",
92                                                       "PHOSCells",
93                                                        "AliRawDataErrorLogs",
94                                                        "AliESDACORDE"};
95
96 //______________________________________________________________________________
97 AliESDEvent::AliESDEvent():
98   AliVEvent(),
99   fESDObjects(new TList()),
100   fESDRun(0),
101   fHeader(0),
102   fESDZDC(0),
103   fESDFMD(0),
104   fESDVZERO(0),
105   fESDTZERO(0),
106   fTPCVertex(0),
107   fSPDVertex(0),
108   fPrimaryVertex(0),
109   fSPDMult(0),
110   fPHOSTrigger(0),
111   fEMCALTrigger(0),
112   fESDACORDE(0),
113   fTracks(0),
114   fMuonTracks(0),
115   fPmdTracks(0),
116   fTrdTracks(0),
117   fV0s(0),  
118   fCascades(0),
119   fKinks(0),
120   fCaloClusters(0),
121   fEMCALCells(0), fPHOSCells(0),
122   fErrorLogs(0),
123   fESDOld(0),
124   fESDFriendOld(0),
125   fConnected(kFALSE),
126   fEMCALClusters(0), 
127   fFirstEMCALCluster(-1),
128   fPHOSClusters(0), 
129   fFirstPHOSCluster(-1)
130 {
131 }
132 //______________________________________________________________________________
133 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
134   AliVEvent(esd),
135   fESDObjects(new TList()),
136   fESDRun(new AliESDRun(*esd.fESDRun)),
137   fHeader(new AliESDHeader(*esd.fHeader)),
138   fESDZDC(new AliESDZDC(*esd.fESDZDC)),
139   fESDFMD(new AliESDFMD(*esd.fESDFMD)),
140   fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
141   fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
142   fTPCVertex(new AliESDVertex(*esd.fTPCVertex)),
143   fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
144   fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
145   fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
146   fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
147   fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
148   fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)),
149   fTracks(new TClonesArray(*esd.fTracks)),
150   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
151   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
152   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
153   fV0s(new TClonesArray(*esd.fV0s)),  
154   fCascades(new TClonesArray(*esd.fCascades)),
155   fKinks(new TClonesArray(*esd.fKinks)),
156   fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
157   fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)),
158   fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)),
159   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
160   fESDOld(new AliESD(*esd.fESDOld)),
161   fESDFriendOld(new AliESDfriend(*esd.fESDFriendOld)),
162   fConnected(esd.fConnected),
163   fEMCALClusters(esd.fEMCALClusters), 
164   fFirstEMCALCluster(esd.fFirstEMCALCluster),
165   fPHOSClusters(esd.fPHOSClusters), 
166   fFirstPHOSCluster(esd.fFirstPHOSCluster)
167
168 {
169   // CKB init in the constructor list and only add here ...
170   AddObject(fESDRun);
171   AddObject(fHeader);
172   AddObject(fESDZDC);
173   AddObject(fESDFMD);
174   AddObject(fESDVZERO);
175   AddObject(fESDTZERO);
176   AddObject(fTPCVertex);
177   AddObject(fSPDVertex);
178   AddObject(fPrimaryVertex);
179   AddObject(fSPDMult);
180   AddObject(fPHOSTrigger);
181   AddObject(fEMCALTrigger);
182   AddObject(fTracks);
183   AddObject(fMuonTracks);
184   AddObject(fPmdTracks);
185   AddObject(fTrdTracks);
186   AddObject(fV0s);
187   AddObject(fCascades);
188   AddObject(fKinks);
189   AddObject(fCaloClusters);
190   AddObject(fEMCALCells);
191   AddObject(fPHOSCells);
192   AddObject(fErrorLogs);
193   AddObject(fESDACORDE);
194
195   GetStdContent();
196
197 }
198
199 //______________________________________________________________________________
200 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
201
202   // Assignment operator
203
204   if(&source == this) return *this;
205   AliVEvent::operator=(source);
206
207   fESDRun = new AliESDRun(*source.fESDRun);
208   fHeader = new AliESDHeader(*source.fHeader);
209   fESDZDC = new AliESDZDC(*source.fESDZDC);
210   fESDFMD = new AliESDFMD(*source.fESDFMD);
211   fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
212   fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
213   fTPCVertex = new AliESDVertex(*source.fTPCVertex);
214   fSPDVertex = new AliESDVertex(*source.fSPDVertex);
215   fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
216   fSPDMult = new AliMultiplicity(*source.fSPDMult);
217   fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
218   fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
219   fTracks = new TClonesArray(*source.fTracks);
220   fMuonTracks = new TClonesArray(*source.fMuonTracks);
221   fPmdTracks = new TClonesArray(*source.fPmdTracks);
222   fTrdTracks = new TClonesArray(*source.fTrdTracks);
223   fV0s = new TClonesArray(*source.fV0s);
224   fCascades = new TClonesArray(*source.fCascades);
225   fKinks = new TClonesArray(*source.fKinks);
226   fCaloClusters = new TClonesArray(*source.fCaloClusters);
227   fEMCALCells = new AliESDCaloCells(*source.fEMCALCells);
228   fPHOSCells = new AliESDCaloCells(*source.fPHOSCells);
229   fErrorLogs = new TClonesArray(*source.fErrorLogs);
230   fESDACORDE = new AliESDACORDE(*source.fESDACORDE);
231   fESDOld       = new AliESD(*source.fESDOld);
232   fESDFriendOld = new AliESDfriend(*source.fESDFriendOld);
233   // CKB this way?? or 
234   // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
235
236   fESDObjects = new TList();
237   AddObject(fESDRun);
238   AddObject(fHeader);
239   AddObject(fESDZDC);
240   AddObject(fESDFMD);
241   AddObject(fESDVZERO);
242   AddObject(fESDTZERO);
243   AddObject(fTPCVertex);
244   AddObject(fSPDVertex);
245   AddObject(fPrimaryVertex);
246   AddObject(fSPDMult);
247   AddObject(fPHOSTrigger);
248   AddObject(fEMCALTrigger);
249   AddObject(fTracks);
250   AddObject(fMuonTracks);
251   AddObject(fPmdTracks);
252   AddObject(fTrdTracks);
253   AddObject(fV0s);
254   AddObject(fCascades);
255   AddObject(fKinks);
256   AddObject(fCaloClusters);
257   AddObject(fEMCALCells);
258   AddObject(fPHOSCells);
259   AddObject(fErrorLogs);
260   AddObject(fESDACORDE);
261
262   fConnected = source.fConnected;
263   fEMCALClusters = source.fEMCALClusters;
264   fFirstEMCALCluster = source.fFirstEMCALCluster;
265   fPHOSClusters = source.fPHOSClusters;
266   fFirstPHOSCluster = source.fFirstPHOSCluster;
267
268
269
270   return *this;
271
272 }
273
274
275 //______________________________________________________________________________
276 AliESDEvent::~AliESDEvent()
277 {
278   //
279   // Standard destructor
280   //
281
282   // everthing on the list gets deleted automatically
283
284   
285   if(fESDObjects&&!fConnected)
286     {
287       delete fESDObjects;
288       fESDObjects = 0;
289     }
290
291   
292 }
293
294 //______________________________________________________________________________
295 void AliESDEvent::Reset()
296 {
297
298   
299   // Reset the standard contents
300   ResetStdContent(); 
301   if(fESDOld)fESDOld->Reset();
302   //  reset for the friends...
303   if(fESDFriendOld){
304     fESDFriendOld->~AliESDfriend();
305     new (fESDFriendOld) AliESDfriend();
306   }
307   // for new data we have to fetch the Pointer from the list 
308   AliESDfriend *fr = (AliESDfriend*)FindListObject("AliESDfriend");
309   if(fr){
310     // delete the content
311     fr->~AliESDfriend();
312     // make a new valid ESDfriend at the same place
313     new (fr) AliESDfriend();
314   }
315
316   // call reset for user supplied data?
317 }
318
319 void AliESDEvent::ResetStdContent()
320 {
321   // Reset the standard contents
322   if(fESDRun) fESDRun->Reset();
323   if(fHeader) fHeader->Reset();
324   if(fESDZDC) fESDZDC->Reset();
325   if(fESDFMD) {
326       fESDFMD->~AliESDFMD(); 
327       new (fESDFMD) AliESDFMD();
328   }
329   if(fESDVZERO){
330     // reset by callin d'to /c'tor keep the pointer
331     fESDVZERO->~AliESDVZERO();
332     new (fESDVZERO) AliESDVZERO();
333   }  
334   if(fESDACORDE){
335     fESDACORDE->~AliESDACORDE();
336     new (fESDACORDE) AliESDACORDE();    
337   } 
338   if(fESDTZERO) fESDTZERO->Reset(); 
339   // CKB no clear/reset implemented
340   if(fTPCVertex){
341     fTPCVertex->~AliESDVertex();
342     new (fTPCVertex) AliESDVertex();
343     fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
344   }
345   if(fSPDVertex){
346     fSPDVertex->~AliESDVertex();
347     new (fSPDVertex) AliESDVertex();
348     fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
349   }
350   if(fPrimaryVertex){
351     fPrimaryVertex->~AliESDVertex();
352     new (fPrimaryVertex) AliESDVertex();
353     fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
354   }
355   if(fSPDMult){
356     fSPDMult->~AliMultiplicity();
357     new (fSPDMult) AliMultiplicity();
358   }
359   if(fPHOSTrigger)fPHOSTrigger->Reset(); 
360   if(fEMCALTrigger)fEMCALTrigger->Reset(); 
361   if(fTracks)fTracks->Delete();
362   if(fMuonTracks)fMuonTracks->Delete();
363   if(fPmdTracks)fPmdTracks->Delete();
364   if(fTrdTracks)fTrdTracks->Delete();
365   if(fV0s)fV0s->Delete();
366   if(fCascades)fCascades->Delete();
367   if(fKinks)fKinks->Delete();
368   if(fCaloClusters)fCaloClusters->Delete();
369   if(fPHOSCells)fPHOSCells->DeleteContainer();
370   if(fEMCALCells)fEMCALCells->DeleteContainer();
371   if(fErrorLogs) fErrorLogs->Delete();
372
373   // don't reset fconnected fConnected and the list
374
375   fEMCALClusters=0; 
376   fFirstEMCALCluster=-1; 
377   fPHOSClusters=0; 
378   fFirstPHOSCluster=-1; 
379 }
380
381
382 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
383   //
384   // Add V0
385   //
386   TClonesArray &fv = *fV0s;
387   Int_t idx=fV0s->GetEntriesFast();
388   new(fv[idx]) AliESDv0(*v);
389   return idx;
390 }  
391
392 //______________________________________________________________________________
393 void AliESDEvent::Print(Option_t *) const 
394 {
395   //
396   // Print header information of the event
397   //
398   printf("ESD run information\n");
399   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
400          GetEventNumberInFile(),
401          GetBunchCrossNumber(),
402          GetOrbitNumber(),
403          GetPeriodNumber(),
404          GetRunNumber(),
405          GetTriggerMask(),
406          GetMagneticField() );
407   printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
408            fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
409            fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
410            fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
411     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
412            GetDiamondX(),GetDiamondY());
413     printf("SPD Multiplicity. Number of tracklets %d \n",
414            fSPDMult->GetNumberOfTracklets());
415   printf("Number of tracks: \n");
416   printf("                 charged   %d\n", GetNumberOfTracks());
417   printf("                 muon      %d\n", GetNumberOfMuonTracks());
418   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
419   printf("                 trd       %d\n", GetNumberOfTrdTracks());
420   printf("                 v0        %d\n", GetNumberOfV0s());
421   printf("                 cascades  %d\n", GetNumberOfCascades());
422   printf("                 kinks     %d\n", GetNumberOfKinks());
423   if(fPHOSCells)printf("                 PHOSCells %d\n", fPHOSCells->GetNumberOfCells());
424   else printf("                 PHOSCells not in the Event\n");
425   if(fEMCALCells)printf("                 EMCALCells %d\n", fEMCALCells->GetNumberOfCells());
426   else printf("                 EMCALCells not in the Event\n");
427   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
428   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
429   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
430   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
431   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
432
433   return;
434 }
435
436 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const {
437   //
438   // Attaches the complementary info to the ESD
439   //
440   if (!ev) return;
441
442   // to be sure that we set the tracks also
443   // in case of old esds 
444   // if(fESDOld)CopyFromOldESD();
445
446   Int_t ntrk=ev->GetNumberOfTracks();
447  
448   for (Int_t i=0; i<ntrk; i++) {
449     const AliESDfriendTrack *f=ev->GetTrack(i);
450     GetTrack(i)->SetFriendTrack(f);
451   }
452 }
453
454 Bool_t  AliESDEvent::RemoveKink(Int_t rm) const {
455   // ---------------------------------------------------------
456   // Remove a kink candidate and references to it from ESD,
457   // if this candidate does not come from a reconstructed decay
458   // Not yet implemented...
459   // ---------------------------------------------------------
460   Int_t last=GetNumberOfKinks()-1;
461   if ((rm<0)||(rm>last)) return kFALSE;
462
463   return kTRUE;
464 }
465
466 Bool_t  AliESDEvent::RemoveV0(Int_t rm) const {
467   // ---------------------------------------------------------
468   // Remove a V0 candidate and references to it from ESD,
469   // if this candidate does not come from a reconstructed decay
470   // ---------------------------------------------------------
471   Int_t last=GetNumberOfV0s()-1;
472   if ((rm<0)||(rm>last)) return kFALSE;
473
474   AliESDv0 *v0=GetV0(rm);
475   Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
476
477   v0=GetV0(last);
478   Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
479
480   Int_t used=0;
481
482   // Check if this V0 comes from a reconstructed decay
483   Int_t ncs=GetNumberOfCascades();
484   for (Int_t n=0; n<ncs; n++) {
485     AliESDcascade *cs=GetCascade(n);
486
487     Int_t csIdxP=cs->GetPindex();
488     Int_t csIdxN=cs->GetNindex();
489
490     if (idxP==csIdxP)
491        if (idxN==csIdxN) return kFALSE;
492
493     if (csIdxP==lastIdxP)
494        if (csIdxN==lastIdxN) used++;
495   }
496
497   //Replace the removed V0 with the last V0 
498   TClonesArray &a=*fV0s;
499   delete a.RemoveAt(rm);
500
501   if (rm==last) return kTRUE;
502
503   //v0 is pointing to the last V0 candidate... 
504   new (a[rm]) AliESDv0(*v0);
505   delete a.RemoveAt(last);
506
507   if (!used) return kTRUE;
508   
509
510   // Remap the indices of the daughters of reconstructed decays
511   for (Int_t n=0; n<ncs; n++) {
512     AliESDcascade *cs=GetCascade(n);
513
514
515     Int_t csIdxP=cs->GetPindex();
516     Int_t csIdxN=cs->GetNindex();
517
518     if (csIdxP==lastIdxP)
519       if (csIdxN==lastIdxN) {
520          cs->AliESDv0::SetIndex(1,idxP);
521          cs->AliESDv0::SetIndex(0,idxN);
522          used--;
523          if (!used) return kTRUE;
524       }
525   }
526
527   return kTRUE;
528 }
529
530 Bool_t  AliESDEvent::RemoveTrack(Int_t rm) const {
531   // ---------------------------------------------------------
532   // Remove a track and references to it from ESD,
533   // if this track does not come from a reconstructed decay
534   // ---------------------------------------------------------
535   Int_t last=GetNumberOfTracks()-1;
536   if ((rm<0)||(rm>last)) return kFALSE;
537
538   Int_t used=0;
539
540   // Check if this track comes from the reconstructed primary vertices
541   if (fTPCVertex && fTPCVertex->GetStatus()) {
542      UShort_t *primIdx=fTPCVertex->GetIndices();
543      Int_t n=fTPCVertex->GetNIndices();
544      while (n--) {
545        Int_t idx=Int_t(primIdx[n]);
546        if (rm==idx) return kFALSE;
547        if (idx==last) used++; 
548      }
549   }
550   if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
551      UShort_t *primIdx=fPrimaryVertex->GetIndices();
552      Int_t n=fPrimaryVertex->GetNIndices();
553      while (n--) {
554        Int_t idx=Int_t(primIdx[n]);
555        if (rm==idx) return kFALSE;
556        if (idx==last) used++; 
557      }
558   }
559   
560   // Check if this track comes from a reconstructed decay
561   Int_t nv0=GetNumberOfV0s();
562   for (Int_t n=0; n<nv0; n++) {
563     AliESDv0 *v0=GetV0(n);
564
565     Int_t idx=v0->GetNindex();
566     if (rm==idx) return kFALSE;
567     if (idx==last) used++;
568
569     idx=v0->GetPindex();
570     if (rm==idx) return kFALSE;
571     if (idx==last) used++;
572   }
573
574   Int_t ncs=GetNumberOfCascades();
575   for (Int_t n=0; n<ncs; n++) {
576     AliESDcascade *cs=GetCascade(n);
577
578     Int_t idx=cs->GetIndex();
579     if (rm==idx) return kFALSE;
580     if (idx==last) used++;
581   }
582
583   Int_t nkn=GetNumberOfKinks();
584   for (Int_t n=0; n<nkn; n++) {
585     AliESDkink *kn=GetKink(n);
586
587     Int_t idx=kn->GetIndex(0);
588     if (rm==idx) return kFALSE;
589     if (idx==last) used++;
590
591     idx=kn->GetIndex(1);
592     if (rm==idx) return kFALSE;
593     if (idx==last) used++;
594   }
595
596
597   //Replace the removed track with the last track 
598   TClonesArray &a=*fTracks;
599   delete a.RemoveAt(rm);
600
601   if (rm==last) return kTRUE;
602
603   AliESDtrack *t=GetTrack(last);
604   t->SetID(rm);
605   new (a[rm]) AliESDtrack(*t);
606   delete a.RemoveAt(last);
607
608
609   if (!used) return kTRUE;
610   
611
612   // Remap the indices of the tracks used for the primary vertex reconstruction
613   if (fTPCVertex && fTPCVertex->GetStatus()) {
614      UShort_t *primIdx=fTPCVertex->GetIndices();
615      Int_t n=fTPCVertex->GetNIndices();
616      while (n--) {
617        Int_t idx=Int_t(primIdx[n]);
618        if (idx==last) {
619           primIdx[n]=Short_t(rm); 
620           used--;
621           if (!used) return kTRUE;
622        }
623      }
624   }  
625   if (fPrimaryVertex && fPrimaryVertex->GetStatus()) {
626      UShort_t *primIdx=fPrimaryVertex->GetIndices();
627      Int_t n=fPrimaryVertex->GetNIndices();
628      while (n--) {
629        Int_t idx=Int_t(primIdx[n]);
630        if (idx==last) {
631           primIdx[n]=Short_t(rm); 
632           used--;
633           if (!used) return kTRUE;
634        }
635      }
636   }  
637
638   // Remap the indices of the daughters of reconstructed decays
639   for (Int_t n=0; n<nv0; n++) {
640     AliESDv0 *v0=GetV0(n);
641     if (v0->GetIndex(0)==last) {
642        v0->SetIndex(0,rm);
643        used--;
644        if (!used) return kTRUE;
645     }
646     if (v0->GetIndex(1)==last) {
647        v0->SetIndex(1,rm);
648        used--;
649        if (!used) return kTRUE;
650     }
651   }
652
653   for (Int_t n=0; n<ncs; n++) {
654     AliESDcascade *cs=GetCascade(n);
655     if (cs->GetIndex()==last) {
656        cs->SetIndex(rm);
657        used--;
658        if (!used) return kTRUE;
659     }
660   }
661
662   for (Int_t n=0; n<nkn; n++) {
663     AliESDkink *kn=GetKink(n);
664     if (kn->GetIndex(0)==last) {
665        kn->SetIndex(rm,0);
666        used--;
667        if (!used) return kTRUE;
668     }
669     if (kn->GetIndex(1)==last) {
670        kn->SetIndex(rm,1);
671        used--;
672        if (!used) return kTRUE;
673     }
674   }
675
676   return kTRUE;
677 }
678
679
680 Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
681   //
682   // Remove the data which are not needed for the physics analysis.
683   //
684   // 1) Cleaning the V0 candidates
685   //    ---------------------------
686   //    If the cosine of the V0 pointing angle "csp" and 
687   //    the DCA between the daughter tracks "dca" does not satisfy 
688   //    the conditions 
689   //
690   //     csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
691   //
692   //    an attempt to remove this V0 candidate from ESD is made.
693   //
694   //    The V0 candidate gets removed if it does not belong to any 
695   //    recosntructed cascade decay
696   //
697   //    12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
698   //
699   // 2) Cleaning the tracks
700   //    ----------------------
701   //    If track's transverse parameter is larger than cleanPars[2]
702   //                       OR
703   //    track's longitudinal parameter is larger than cleanPars[3]
704   //    an attempt to remove this track from ESD is made.
705   //
706   //    The track gets removed if it does not come 
707   //    from a reconstructed decay
708   //
709   Bool_t rc=kFALSE;
710
711   Float_t dcaMax=cleanPars[0];
712   Float_t cspMin=cleanPars[1];
713
714   Int_t nV0s=GetNumberOfV0s();
715   for (Int_t i=nV0s-1; i>=0; i--) {
716     AliESDv0 *v0=GetV0(i);
717
718     Float_t dca=v0->GetDcaV0Daughters();
719     Float_t csp=v0->GetV0CosineOfPointingAngle();
720     Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
721     if (csp > cspcut) continue;
722     if (RemoveV0(i)) rc=kTRUE;
723   }
724
725
726   Float_t dmax=cleanPars[2], zmax=cleanPars[3];
727
728   const AliESDVertex *vertex=GetPrimaryVertexSPD();
729   Bool_t vtxOK=vertex->GetStatus();
730   
731   Int_t nTracks=GetNumberOfTracks();
732   for (Int_t i=nTracks-1; i>=0; i--) {
733     AliESDtrack *track=GetTrack(i);
734     Float_t xy,z; track->GetImpactParameters(xy,z);
735     if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
736       if (RemoveTrack(i)) rc=kTRUE;
737     }
738   }
739
740   return rc;
741 }
742
743 Int_t  AliESDEvent::AddTrack(const AliESDtrack *t) 
744 {
745     // Add track
746     TClonesArray &ftr = *fTracks;
747     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
748     track->SetID(fTracks->GetEntriesFast()-1);
749     return  track->GetID();    
750 }
751
752  void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t) 
753 {
754     TClonesArray &fmu = *fMuonTracks;
755     new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
756 }
757
758 void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t) 
759 {
760   TClonesArray &fpmd = *fPmdTracks;
761   new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
762 }
763
764 void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t) 
765 {
766   TClonesArray &ftrd = *fTrdTracks;
767   new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
768 }
769
770
771
772
773 Int_t AliESDEvent::AddKink(const AliESDkink *c) 
774 {
775     // Add kink
776     TClonesArray &fk = *fKinks;
777     AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
778     kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
779     return fKinks->GetEntriesFast()-1;
780 }
781
782
783 void AliESDEvent::AddCascade(const AliESDcascade *c) 
784 {
785   TClonesArray &fc = *fCascades;
786   new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
787 }
788
789
790 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) 
791 {
792     // Add calocluster
793     TClonesArray &fc = *fCaloClusters;
794     AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
795     clus->SetID(fCaloClusters->GetEntriesFast()-1);
796     return fCaloClusters->GetEntriesFast()-1;
797   }
798
799
800 void  AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const {
801   TClonesArray &errlogs = *fErrorLogs;
802   new(errlogs[errlogs.GetEntriesFast()])  AliRawDataErrorLog(*log);
803 }
804
805 void  AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex) 
806 {
807   // Set the TPC vertex
808   // use already allocated space
809   if(fTPCVertex){
810     *fTPCVertex = *vertex;
811     fTPCVertex->SetName(fgkESDListName[kTPCVertex]);
812   }
813 }
814
815 void  AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex) 
816 {
817   // Set the SPD vertex
818   // use already allocated space
819   if(fSPDVertex){
820     *fSPDVertex = *vertex;
821     fSPDVertex->SetName(fgkESDListName[kSPDVertex]);
822   }
823 }
824
825 void  AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex) 
826 {
827   // Set the primary vertex
828   // use already allocated space
829   if(fPrimaryVertex){
830     *fPrimaryVertex = *vertex;
831     fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
832   }
833 }
834
835 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) 
836 {
837   // Set the SPD Multiplicity
838   if(fSPDMult){
839     *fSPDMult = *mul;
840   }
841 }
842
843
844 void AliESDEvent::SetFMDData(AliESDFMD * obj) 
845
846   // use already allocated space
847   if(fESDFMD){
848     *fESDFMD = *obj;
849   }
850 }
851
852 void AliESDEvent::SetVZEROData(AliESDVZERO * obj)
853
854   // use already allocated space
855   if(fESDVZERO)
856     *fESDVZERO = *obj;
857 }
858
859 void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
860 {
861   if(fESDACORDE)
862     *fESDACORDE = *obj;
863 }
864
865
866 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const 
867 {
868   //
869   // Extracts the complementary info from the ESD
870   //
871   if (!ev) return;
872
873   Int_t ntrk=GetNumberOfTracks();
874
875   for (Int_t i=0; i<ntrk; i++) {
876     AliESDtrack *t=GetTrack(i);
877     const AliESDfriendTrack *f=t->GetFriendTrack();
878     ev->AddTrack(f);
879
880     t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
881
882   }
883 }
884
885
886 void AliESDEvent::AddObject(TObject* obj) 
887 {
888   // Add an object to the list of object.
889   // Please be aware that in order to increase performance you should
890   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
891   fESDObjects->SetOwner(kTRUE);
892   fESDObjects->AddLast(obj);
893 }
894
895
896 void AliESDEvent::GetStdContent() 
897 {
898   // set pointers for standard content
899   // get by name much safer and not a big overhead since not called very often
900  
901   fESDRun = (AliESDRun*)fESDObjects->FindObject(fgkESDListName[kESDRun]);
902   fHeader = (AliESDHeader*)fESDObjects->FindObject(fgkESDListName[kHeader]);
903   fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fgkESDListName[kESDZDC]);
904   fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fgkESDListName[kESDFMD]);
905   fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fgkESDListName[kESDVZERO]);
906   fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fgkESDListName[kESDTZERO]);
907   fTPCVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kTPCVertex]);
908   fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kSPDVertex]);
909   fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kPrimaryVertex]);
910   fSPDMult =       (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]);
911   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]);
912   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]);
913   fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
914   fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
915   fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
916   fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
917   fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
918   fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
919   fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
920   fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCaloClusters]);
921   fEMCALCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kEMCALCells]);
922   fPHOSCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kPHOSCells]);
923   fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
924   fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]);
925
926 }
927
928 void AliESDEvent::SetStdNames(){
929   // Set the names of the standard contents
930   // 
931   if(fESDObjects->GetEntries()==kESDListN){
932     for(int i = 0;i < fESDObjects->GetEntries();i++){
933       TObject *fObj = fESDObjects->At(i);
934       if(fObj->InheritsFrom("TNamed")){
935         ((TNamed*)fObj)->SetName(fgkESDListName[i]);
936       }
937       else if(fObj->InheritsFrom("TClonesArray")){
938         ((TClonesArray*)fObj)->SetName(fgkESDListName[i]);
939       }
940     }
941   }
942   else{
943     printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
944   }
945
946
947 void AliESDEvent::CreateStdContent() 
948 {
949   // create the standard AOD content and set pointers
950
951   // create standard objects and add them to the TList of objects
952   AddObject(new AliESDRun());
953   AddObject(new AliESDHeader());
954   AddObject(new AliESDZDC());
955   AddObject(new AliESDFMD());
956   AddObject(new AliESDVZERO());
957   AddObject(new AliESDTZERO());
958   AddObject(new AliESDVertex());
959   AddObject(new AliESDVertex());
960   AddObject(new AliESDVertex());
961   AddObject(new AliMultiplicity());
962   AddObject(new AliESDCaloTrigger());
963   AddObject(new AliESDCaloTrigger());
964   AddObject(new TClonesArray("AliESDtrack",0));
965   AddObject(new TClonesArray("AliESDMuonTrack",0));
966   AddObject(new TClonesArray("AliESDPmdTrack",0));
967   AddObject(new TClonesArray("AliESDTrdTrack",0));
968   AddObject(new TClonesArray("AliESDv0",0));
969   AddObject(new TClonesArray("AliESDcascade",0));
970   AddObject(new TClonesArray("AliESDkink",0));
971   AddObject(new TClonesArray("AliESDCaloCluster",0));
972   AddObject(new AliESDCaloCells());
973   AddObject(new AliESDCaloCells());
974   AddObject(new TClonesArray("AliRawDataErrorLog",0));
975   AddObject(new AliESDACORDE()); 
976
977   // check the order of the indices against enum...
978
979   // set names
980   SetStdNames();
981   // read back pointers
982   GetStdContent();
983 }
984
985 TObject* AliESDEvent::FindListObject(const char *name){
986 //
987 // Find object with name "name" in the list of branches
988 //
989   if(fESDObjects){
990     return fESDObjects->FindObject(name);
991   }
992   return 0;
993
994
995 Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
996 {
997   // fills the provided TRefArray with all found phos clusters
998   
999   clusters->Clear();
1000   
1001   AliESDCaloCluster *cl = 0;
1002   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1003     
1004     if ( (cl = GetCaloCluster(i)) ) {
1005       if (cl->IsPHOS()){
1006         clusters->Add(cl);
1007         AliDebug(1,Form("IsPHOS cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1008       }
1009     }
1010   }
1011   return clusters->GetEntriesFast();
1012 }
1013
1014 Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
1015 {
1016   // fills the provided TRefArray with all found emcal clusters
1017
1018   clusters->Clear();
1019
1020   AliESDCaloCluster *cl = 0;
1021   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1022
1023     if ( (cl = GetCaloCluster(i)) ) {
1024       if (cl->IsEMCAL()){
1025         clusters->Add(cl);
1026         AliDebug(1,Form("IsEMCAL cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1027       }
1028     }
1029   }
1030   return clusters->GetEntriesFast();
1031 }
1032
1033 const void AliESDEvent::WriteToTree(TTree* tree) const {
1034   // Book the branches as in TTree::Branch(TCollection*)
1035   // but add a "." at the end of top level branches which are
1036   // not a TClonesArray
1037
1038
1039   TString branchname;
1040   TIter next(fESDObjects);
1041   const Int_t kSplitlevel = 99; // default value in TTree::Branch()
1042   const Int_t kBufsize = 32000; // default value in TTree::Branch()
1043   TObject *obj = 0;
1044
1045   while ((obj = next())) {
1046     branchname.Form("%s", obj->GetName());
1047     if ((kSplitlevel > 1) &&  !obj->InheritsFrom(TClonesArray::Class())) {
1048       branchname += ".";
1049     }
1050     tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),
1051                  kBufsize, kSplitlevel - 1);
1052   }
1053
1054 }
1055
1056
1057 void AliESDEvent::ReadFromTree(TTree *tree){
1058 //
1059 // Connect the ESDEvent to a tree
1060 //
1061   if(!tree){
1062     Printf("%s %d AliESDEvent::ReadFromTree() Zero Pointer to Tree \n",(char*)__FILE__,__LINE__);
1063     return;
1064   }
1065   // load the TTree
1066   if(!tree->GetTree())tree->LoadTree(0);
1067
1068   // if we find the "ESD" branch on the tree we do have the old structure
1069   if(tree->GetBranch("ESD")) {
1070     char ** address  = (char **)(tree->GetBranch("ESD")->GetAddress());
1071     // do we have the friend branch
1072     TBranch * esdFB = tree->GetBranch("ESDfriend.");
1073     char ** addressF = 0;
1074     if(esdFB)addressF = (char **)(esdFB->GetAddress());
1075     if (!address) {
1076       printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
1077       tree->SetBranchAddress("ESD",       &fESDOld);
1078       if(esdFB){
1079         tree->SetBranchAddress("ESDfriend.",&fESDFriendOld);
1080       }
1081     } else {
1082       printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
1083       printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
1084       fESDOld       = (AliESD*)       (*address);
1085       // addressF can still be 0, since branch needs to switched on
1086       if(addressF)fESDFriendOld = (AliESDfriend*) (*addressF);
1087     }
1088                                        
1089     //  have already connected the old ESD structure... ?
1090     // reuse also the pointer of the AlliESDEvent
1091     // otherwise create new ones
1092     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1093   
1094     if(connectedList){
1095       // If connected use the connected list of objects
1096       if(fESDObjects!= connectedList){
1097         // protect when called twice 
1098         fESDObjects->Delete();
1099         fESDObjects = connectedList;
1100       }
1101       GetStdContent(); 
1102
1103       
1104       // The pointer to the friend changes when called twice via InitIO
1105       // since AliESDEvent is deleted
1106       TObject* oldf = FindListObject("AliESDfriend");
1107       TObject* newf = 0;
1108       if(addressF){
1109         newf = (TObject*)*addressF;
1110       }
1111       if(newf!=0&&oldf!=newf){
1112         // remove the old reference
1113         // Should we also delete it? Or is this handled in TTree I/O
1114         // since it is created by the first SetBranchAddress
1115         fESDObjects->Remove(oldf);
1116         // add the new one 
1117         fESDObjects->Add(newf);
1118       }
1119       
1120       fConnected = true;
1121       return;
1122     }
1123     // else...    
1124     CreateStdContent(); // create for copy
1125     // if we have the esdfriend add it, so we always can access it via the userinfo
1126     if(fESDFriendOld)AddObject(fESDFriendOld);
1127     // we are not owner of the list objects 
1128     // must not delete it
1129     fESDObjects->SetOwner(kFALSE);
1130     fESDObjects->SetName("ESDObjectsConnectedToTree");
1131     tree->GetUserInfo()->Add(fESDObjects);
1132     fConnected = true;
1133     return;
1134   }
1135   
1136   delete fESDOld;
1137   fESDOld = 0;
1138   // Try to find AliESDEvent
1139   AliESDEvent *esdEvent = 0;
1140   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
1141   if(esdEvent){   
1142       // Check if already connected to tree
1143     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1144     if (connectedList) {
1145       // If connected use the connected list if objects
1146       fESDObjects->Delete();
1147       fESDObjects = connectedList;
1148       GetStdContent(); 
1149       fConnected = true;
1150       return;
1151     }
1152     // Connect to tree
1153     // prevent a memory leak when reading back the TList
1154     delete fESDObjects;
1155     fESDObjects = 0;
1156     // create a new TList from the UserInfo TList... 
1157     // copy constructor does not work...
1158     fESDObjects = (TList*)(esdEvent->GetList()->Clone());
1159     fESDObjects->SetOwner(kFALSE);
1160     if(fESDObjects->GetEntries()<kESDListN){
1161       printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
1162              (char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
1163     }
1164     // set the branch addresses
1165     TIter next(fESDObjects);
1166     TNamed *el;
1167     while((el=(TNamed*)next())){
1168       TString bname(el->GetName());
1169       if(bname.CompareTo("AliESDfriend")==0)
1170         {
1171           // AliESDfriend does not have a name ...
1172           tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
1173         }
1174       else{
1175         // check if branch exists under this Name
1176         TBranch *br = tree->GetBranch(bname.Data());
1177         if(br){
1178           tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1179         }
1180         else{
1181           br = tree->GetBranch(Form("%s.",bname.Data()));
1182           if(br){
1183             tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1184           }
1185           else{
1186             printf("%s %d AliESDEvent::ReadFromTree() No Branch found with Name %s or %s. \n",
1187                    (char*)__FILE__,__LINE__,bname.Data(),bname.Data());
1188           }
1189
1190         }
1191       }
1192     }
1193     GetStdContent();
1194     // when reading back we are not owner of the list 
1195     // must not delete it
1196     fESDObjects->SetOwner(kFALSE);
1197     fESDObjects->SetName("ESDObjectsConnectedToTree");
1198     // we are not owner of the list objects 
1199     // must not delete it
1200     tree->GetUserInfo()->Add(fESDObjects);
1201     fConnected = true;
1202   }// no esdEvent
1203   else {
1204     // we can't get the list from the user data, create standard content
1205     // and set it by hand (no ESDfriend at the moment
1206     CreateStdContent();
1207     TIter next(fESDObjects);
1208     TNamed *el;
1209     while((el=(TNamed*)next())){
1210       TString bname(el->GetName());    
1211       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1212     }
1213     GetStdContent();
1214     // when reading back we are not owner of the list 
1215     // must not delete it
1216     fESDObjects->SetOwner(kFALSE);
1217   }
1218 }
1219
1220
1221 void AliESDEvent::CopyFromOldESD()
1222 {
1223   // Method which copies over everthing from the old esd structure to the 
1224   // new  
1225   if(fESDOld){
1226     ResetStdContent();
1227      // Run
1228     SetRunNumber(fESDOld->GetRunNumber());
1229     SetPeriodNumber(fESDOld->GetPeriodNumber());
1230     SetMagneticField(fESDOld->GetMagneticField());
1231   
1232     // leave out diamond ...
1233     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
1234
1235     // header
1236     SetTriggerMask(fESDOld->GetTriggerMask());
1237     SetOrbitNumber(fESDOld->GetOrbitNumber());
1238     SetTimeStamp(fESDOld->GetTimeStamp());
1239     SetEventType(fESDOld->GetEventType());
1240     SetEventNumberInFile(fESDOld->GetEventNumberInFile());
1241     SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
1242     SetTriggerCluster(fESDOld->GetTriggerCluster());
1243
1244     // ZDC
1245
1246     SetZDC(fESDOld->GetZDCN1Energy(),
1247            fESDOld->GetZDCP1Energy(),
1248            fESDOld->GetZDCEMEnergy(),
1249            0,
1250            fESDOld->GetZDCN2Energy(),
1251            fESDOld->GetZDCP2Energy(),
1252            fESDOld->GetZDCParticipants());
1253
1254     // FMD
1255     
1256     if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1257
1258     // T0
1259
1260     SetT0zVertex(fESDOld->GetT0zVertex());
1261     SetT0(fESDOld->GetT0());
1262     //  leave amps out
1263
1264     // VZERO
1265     if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1266
1267     if(fESDOld->GetVertex())SetPrimaryVertexSPD(fESDOld->GetVertex());
1268
1269     if(fESDOld->GetPrimaryVertex())SetPrimaryVertex(fESDOld->GetPrimaryVertex());
1270
1271     if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1272
1273     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1274       AddTrack(fESDOld->GetTrack(i));
1275     }
1276
1277     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
1278       AddMuonTrack(fESDOld->GetMuonTrack(i));
1279     }
1280
1281     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
1282       AddPmdTrack(fESDOld->GetPmdTrack(i));
1283     }
1284
1285     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
1286       AddTrdTrack(fESDOld->GetTrdTrack(i));
1287     }
1288
1289     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
1290       AddV0(fESDOld->GetV0(i));
1291     }
1292
1293     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
1294       AddCascade(fESDOld->GetCascade(i));
1295     }
1296
1297     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
1298       AddKink(fESDOld->GetKink(i));
1299     }
1300
1301
1302     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
1303       AddCaloCluster(fESDOld->GetCaloCluster(i));
1304     }
1305
1306   }// if fesdold
1307 }
1308
1309
1310