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(dynamic_cast<TClonesArray*>(its)->GetClass());
 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 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            0);
1346
1347     // FMD
1348
1349     if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1350
1351     // T0
1352
1353     SetT0zVertex(fESDOld->GetT0zVertex());
1354     SetT0(fESDOld->GetT0());
1355     //  leave amps out
1356
1357     // VZERO
1358     if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1359
1360     if(fESDOld->GetVertex())SetPrimaryVertexSPD(fESDOld->GetVertex());
1361
1362     if(fESDOld->GetPrimaryVertex())SetPrimaryVertex(fESDOld->GetPrimaryVertex());
1363
1364     if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1365
1366     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1367       AddTrack(fESDOld->GetTrack(i));
1368     }
1369
1370     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
1371       AddMuonTrack(fESDOld->GetMuonTrack(i));
1372     }
1373
1374     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
1375       AddPmdTrack(fESDOld->GetPmdTrack(i));
1376     }
1377
1378     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
1379       AddTrdTrack(fESDOld->GetTrdTrack(i));
1380     }
1381
1382     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
1383       AddV0(fESDOld->GetV0(i));
1384     }
1385
1386     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
1387       AddCascade(fESDOld->GetCascade(i));
1388     }
1389
1390     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
1391       AddKink(fESDOld->GetKink(i));
1392     }
1393
1394
1395     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
1396       AddCaloCluster(fESDOld->GetCaloCluster(i));
1397     }
1398
1399   }// if fesdold
1400 }
1401
1402
1403