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