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