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::SetPrimaryVertexTracks(const AliESDVertex *vertex)
 887 {
 888   // Set the primary vertex reconstructed using he ESD tracks.
 889   // use already allocated space
 890   if(fPrimaryVertex){
 891     *fPrimaryVertex = *vertex;
 892     fPrimaryVertex->SetName(fgkESDListName[kPrimaryVertex]);
 893   }
 894 }
 895
 896 const AliESDVertex * AliESDEvent::GetPrimaryVertex() const
 897 {
 898   //
 899   // Get the "best" available reconstructed primary vertex.
 900   //
 901   if(fPrimaryVertex){
 902     if (fPrimaryVertex->GetStatus()) return fPrimaryVertex;
 903   }
 904   if(fSPDVertex){
 905     if (fSPDVertex->GetStatus()) return fSPDVertex;
 906   }
 907   if(fTPCVertex) return fTPCVertex;
 908
 909   AliWarning("No primary vertex available. Returning the \"default\"...");
 910   return fSPDVertex;
 911 }
 912
 913 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
 914 {
 915   // Set the SPD Multiplicity
 916   if(fSPDMult){
 917     *fSPDMult = *mul;
 918   }
 919 }
 920
 921
 922 void AliESDEvent::SetFMDData(AliESDFMD * obj)
 923 {
 924   // use already allocated space
 925   if(fESDFMD){
 926     *fESDFMD = *obj;
 927   }
 928 }
 929
 930 void AliESDEvent::SetVZEROData(AliESDVZERO * obj)
 931 {
 932   // use already allocated space
 933   if(fESDVZERO)
 934     *fESDVZERO = *obj;
 935 }
 936
 937 void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
 938 {
 939   if(fESDACORDE)
 940     *fESDACORDE = *obj;
 941 }
 942
 943
 944 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
 945 {
 946   //
 947   // Extracts the complementary info from the ESD
 948   //
 949   if (!ev) return;
 950
 951   Int_t ntrk=GetNumberOfTracks();
 952
 953   for (Int_t i=0; i<ntrk; i++) {
 954     AliESDtrack *t=GetTrack(i);
 955     const AliESDfriendTrack *f=t->GetFriendTrack();
 956     ev->AddTrack(f);
 957
 958     t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
 959
 960   }
 961
 962   AliESDfriend *fr = (AliESDfriend*)(const_cast<AliESDEvent*>(this)->FindListObject("AliESDfriend"));
 963   if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
 964 }
 965
 966 void AliESDEvent::AddObject(TObject* obj)
 967 {
 968   // Add an object to the list of object.
 969   // Please be aware that in order to increase performance you should
 970   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
 971   fESDObjects->SetOwner(kTRUE);
 972   fESDObjects->AddLast(obj);
 973 }
 974
 975
 976 void AliESDEvent::GetStdContent()
 977 {
 978   // set pointers for standard content
 979   // get by name much safer and not a big overhead since not called very often
 980
 981   fESDRun = (AliESDRun*)fESDObjects->FindObject(fgkESDListName[kESDRun]);
 982   fHeader = (AliESDHeader*)fESDObjects->FindObject(fgkESDListName[kHeader]);
 983   fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fgkESDListName[kESDZDC]);
 984   fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fgkESDListName[kESDFMD]);
 985   fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fgkESDListName[kESDVZERO]);
 986   fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fgkESDListName[kESDTZERO]);
 987   fTPCVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kTPCVertex]);
 988   fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kSPDVertex]);
 989   fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fgkESDListName[kPrimaryVertex]);
 990   fSPDMult =       (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]);
 991   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]);
 992   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]);
 993   fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
 994   fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
 995   fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
 996   fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
 997   fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
 998   fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
 999   fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
1000   fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCaloClusters]);
1001   fEMCALCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kEMCALCells]);
1002   fPHOSCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kPHOSCells]);
1003   fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
1004   fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]);
1005
1006 }
1007
1008 void AliESDEvent::SetStdNames(){
1009   // Set the names of the standard contents
1010   //
1011   if(fESDObjects->GetEntries()>=kESDListN){
1012     for(int i = 0;i < fESDObjects->GetEntries() && i<kESDListN;i++){
1013       TObject *fObj = fESDObjects->At(i);
1014       if(fObj->InheritsFrom("TNamed")){
1015         ((TNamed*)fObj)->SetName(fgkESDListName[i]);
1016       }
1017       else if(fObj->InheritsFrom("TClonesArray")){
1018         ((TClonesArray*)fObj)->SetName(fgkESDListName[i]);
1019       }
1020     }
1021   }
1022   else{
1023      AliWarning("Std Entries missing");
1024   }
1025 }
1026
1027
1028 void AliESDEvent::CreateStdContent(Bool_t bUseThisList){
1029   fUseOwnList = bUseThisList;
1030   CreateStdContent();
1031 }
1032
1033 void AliESDEvent::CreateStdContent()
1034 {
1035   // create the standard AOD content and set pointers
1036
1037   // create standard objects and add them to the TList of objects
1038   AddObject(new AliESDRun());
1039   AddObject(new AliESDHeader());
1040   AddObject(new AliESDZDC());
1041   AddObject(new AliESDFMD());
1042   AddObject(new AliESDVZERO());
1043   AddObject(new AliESDTZERO());
1044   AddObject(new AliESDVertex());
1045   AddObject(new AliESDVertex());
1046   AddObject(new AliESDVertex());
1047   AddObject(new AliMultiplicity());
1048   AddObject(new AliESDCaloTrigger());
1049   AddObject(new AliESDCaloTrigger());
1050   AddObject(new TClonesArray("AliESDtrack",0));
1051   AddObject(new TClonesArray("AliESDMuonTrack",0));
1052   AddObject(new TClonesArray("AliESDPmdTrack",0));
1053   AddObject(new TClonesArray("AliESDTrdTrack",0));
1054   AddObject(new TClonesArray("AliESDv0",0));
1055   AddObject(new TClonesArray("AliESDcascade",0));
1056   AddObject(new TClonesArray("AliESDkink",0));
1057   AddObject(new TClonesArray("AliESDCaloCluster",0));
1058   AddObject(new AliESDCaloCells());
1059   AddObject(new AliESDCaloCells());
1060   AddObject(new TClonesArray("AliRawDataErrorLog",0));
1061   AddObject(new AliESDACORDE());
1062
1063   // check the order of the indices against enum...
1064
1065   // set names
1066   SetStdNames();
1067   // read back pointers
1068   GetStdContent();
1069 }
1070
1071 TObject* AliESDEvent::FindListObject(const char *name){
1072 //
1073 // Find object with name "name" in the list of branches
1074 //
1075   if(fESDObjects){
1076     return fESDObjects->FindObject(name);
1077   }
1078   return 0;
1079 }
1080
1081 Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
1082 {
1083   // fills the provided TRefArray with all found phos clusters
1084
1085   clusters->Clear();
1086
1087   AliESDCaloCluster *cl = 0;
1088   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1089
1090     if ( (cl = GetCaloCluster(i)) ) {
1091       if (cl->IsPHOS()){
1092         clusters->Add(cl);
1093         AliDebug(1,Form("IsPHOS cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1094       }
1095     }
1096   }
1097   return clusters->GetEntriesFast();
1098 }
1099
1100 Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
1101 {
1102   // fills the provided TRefArray with all found emcal clusters
1103
1104   clusters->Clear();
1105
1106   AliESDCaloCluster *cl = 0;
1107   for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
1108
1109     if ( (cl = GetCaloCluster(i)) ) {
1110       if (cl->IsEMCAL()){
1111         clusters->Add(cl);
1112         AliDebug(1,Form("IsEMCAL cluster %d Size: %d \n",i,clusters->GetEntriesFast()));
1113       }
1114     }
1115   }
1116   return clusters->GetEntriesFast();
1117 }
1118
1119 void AliESDEvent::WriteToTree(TTree* tree) const {
1120   // Book the branches as in TTree::Branch(TCollection*)
1121   // but add a "." at the end of top level branches which are
1122   // not a TClonesArray
1123
1124
1125   TString branchname;
1126   TIter next(fESDObjects);
1127   const Int_t kSplitlevel = 99; // default value in TTree::Branch()
1128   const Int_t kBufsize = 32000; // default value in TTree::Branch()
1129   TObject *obj = 0;
1130
1131   while ((obj = next())) {
1132     branchname.Form("%s", obj->GetName());
1133     if ((kSplitlevel > 1) &&  !obj->InheritsFrom(TClonesArray::Class())) {
1134       if(!branchname.EndsWith("."))branchname += ".";
1135     }
1136     if (!tree->FindBranch(branchname)) {
1137       tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),
1138                    kBufsize, kSplitlevel - 1);
1139     }
1140   }
1141 }
1142
1143
1144 void AliESDEvent::ReadFromTree(TTree *tree, Option_t* /*opt*/){
1145 //
1146 // Connect the ESDEvent to a tree
1147 //
1148   if(!tree){
1149     AliWarning("AliESDEvent::ReadFromTree() Zero Pointer to Tree \n");
1150     return;
1151   }
1152   // load the TTree
1153   if(!tree->GetTree())tree->LoadTree(0);
1154
1155   // if we find the "ESD" branch on the tree we do have the old structure
1156   if(tree->GetBranch("ESD")) {
1157     char ** address  = (char **)(tree->GetBranch("ESD")->GetAddress());
1158     // do we have the friend branch
1159     TBranch * esdFB = tree->GetBranch("ESDfriend.");
1160     char ** addressF = 0;
1161     if(esdFB)addressF = (char **)(esdFB->GetAddress());
1162     if (!address) {
1163       AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1164       tree->SetBranchAddress("ESD",       &fESDOld);
1165       if(esdFB){
1166         tree->SetBranchAddress("ESDfriend.",&fESDFriendOld);
1167       }
1168     } else {
1169       AliInfo("AliESDEvent::ReadFromTree() Reading old Tree");
1170       AliInfo("Branch already connected. Using existing branch address.");
1171       fESDOld       = (AliESD*)       (*address);
1172       // addressF can still be 0, since branch needs to switched on
1173       if(addressF)fESDFriendOld = (AliESDfriend*) (*addressF);
1174     }
1175
1176     //  have already connected the old ESD structure... ?
1177     // reuse also the pointer of the AlliESDEvent
1178     // otherwise create new ones
1179     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1180
1181     if(connectedList){
1182       // If connected use the connected list of objects
1183       if(fESDObjects!= connectedList){
1184         // protect when called twice
1185         fESDObjects->Delete();
1186         fESDObjects = connectedList;
1187       }
1188       GetStdContent();
1189
1190
1191       // The pointer to the friend changes when called twice via InitIO
1192       // since AliESDEvent is deleted
1193       TObject* oldf = FindListObject("AliESDfriend");
1194       TObject* newf = 0;
1195       if(addressF){
1196         newf = (TObject*)*addressF;
1197       }
1198       if(newf!=0&&oldf!=newf){
1199         // remove the old reference
1200         // Should we also delete it? Or is this handled in TTree I/O
1201         // since it is created by the first SetBranchAddress
1202         fESDObjects->Remove(oldf);
1203         // add the new one
1204         fESDObjects->Add(newf);
1205       }
1206
1207       fConnected = true;
1208       return;
1209     }
1210     // else...
1211     CreateStdContent(); // create for copy
1212     // if we have the esdfriend add it, so we always can access it via the userinfo
1213     if(fESDFriendOld)AddObject(fESDFriendOld);
1214     // we are not owner of the list objects
1215     // must not delete it
1216     fESDObjects->SetOwner(kFALSE);
1217     fESDObjects->SetName("ESDObjectsConnectedToTree");
1218     tree->GetUserInfo()->Add(fESDObjects);
1219     fConnected = true;
1220     return;
1221   }
1222
1223
1224     delete fESDOld;
1225     fESDOld = 0;
1226   // Try to find AliESDEvent
1227   AliESDEvent *esdEvent = 0;
1228   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
1229   if(esdEvent){
1230       // Check if already connected to tree
1231     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
1232     if (connectedList) {
1233       // If connected use the connected list if objects
1234       fESDObjects->Delete();
1235       fESDObjects = connectedList;
1236       GetStdContent();
1237       fConnected = true;
1238       return;
1239     }
1240
1241     // Connect to tree
1242     // prevent a memory leak when reading back the TList
1243
1244     if(!fUseOwnList){
1245       delete fESDObjects;
1246       fESDObjects = 0;
1247       // create a new TList from the UserInfo TList...
1248       // copy constructor does not work...
1249       fESDObjects = (TList*)(esdEvent->GetList()->Clone());
1250       fESDObjects->SetOwner(kFALSE);
1251     }
1252     else if ( fESDObjects->GetEntries()==0){
1253       // at least create the std content if we want to read to our list
1254       CreateStdContent();
1255     }
1256
1257     // in principle
1258     // we only need new things in the list if we do no already have it..
1259     // TODO just add new entries
1260
1261     if(fESDObjects->GetEntries()<kESDListN){
1262       AliWarning(Form("AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
1263                       fESDObjects->GetEntries(),kESDListN));
1264     }
1265     // set the branch addresses
1266     TIter next(fESDObjects);
1267     TNamed *el;
1268     while((el=(TNamed*)next())){
1269       TString bname(el->GetName());
1270       if(bname.CompareTo("AliESDfriend")==0)
1271         {
1272           // AliESDfriend does not have a name ...
1273           tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
1274         }
1275       else{
1276         // check if branch exists under this Name
1277         TBranch *br = tree->GetBranch(bname.Data());
1278         if(br){
1279           tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1280         }
1281         else{
1282           br = tree->GetBranch(Form("%s.",bname.Data()));
1283           if(br){
1284             tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1285           }
1286           else{
1287             AliWarning(Form("AliESDEvent::ReadFromTree() No Branch found with Name %s or %s.",bname.Data(),bname.Data()));
1288           }
1289
1290         }
1291       }
1292     }
1293     GetStdContent();
1294     // when reading back we are not owner of the list
1295     // must not delete it
1296     fESDObjects->SetOwner(kFALSE);
1297     fESDObjects->SetName("ESDObjectsConnectedToTree");
1298     // we are not owner of the list objects
1299     // must not delete it
1300     tree->GetUserInfo()->Add(fESDObjects);
1301     fConnected = true;
1302   }// no esdEvent
1303   else {
1304     // we can't get the list from the user data, create standard content
1305     // and set it by hand (no ESDfriend at the moment
1306     CreateStdContent();
1307     TIter next(fESDObjects);
1308     TNamed *el;
1309     while((el=(TNamed*)next())){
1310       TString bname(el->GetName());
1311       TBranch *br = tree->GetBranch(bname.Data());
1312       if(br){
1313         tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
1314       }
1315       else{
1316         br = tree->GetBranch(Form("%s.",bname.Data()));
1317         if(br){
1318           tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
1319         }
1320       }
1321     }
1322     GetStdContent();
1323     // when reading back we are not owner of the list
1324     // must not delete it
1325     fESDObjects->SetOwner(kFALSE);
1326   }
1327 }
1328
1329
1330 void AliESDEvent::CopyFromOldESD()
1331 {
1332   // Method which copies over everthing from the old esd structure to the
1333   // new
1334   if(fESDOld){
1335     ResetStdContent();
1336      // Run
1337     SetRunNumber(fESDOld->GetRunNumber());
1338     SetPeriodNumber(fESDOld->GetPeriodNumber());
1339     SetMagneticField(fESDOld->GetMagneticField());
1340
1341     // leave out diamond ...
1342     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
1343
1344     // header
1345     SetTriggerMask(fESDOld->GetTriggerMask());
1346     SetOrbitNumber(fESDOld->GetOrbitNumber());
1347     SetTimeStamp(fESDOld->GetTimeStamp());
1348     SetEventType(fESDOld->GetEventType());
1349     SetEventNumberInFile(fESDOld->GetEventNumberInFile());
1350     SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
1351     SetTriggerCluster(fESDOld->GetTriggerCluster());
1352
1353     // ZDC
1354
1355     SetZDC(fESDOld->GetZDCN1Energy(),
1356            fESDOld->GetZDCP1Energy(),
1357            fESDOld->GetZDCEMEnergy(),
1358            0,
1359            fESDOld->GetZDCN2Energy(),
1360            fESDOld->GetZDCP2Energy(),
1361            fESDOld->GetZDCParticipants(),
1362            0);
1363
1364     // FMD
1365
1366     if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
1367
1368     // T0
1369
1370     SetT0zVertex(fESDOld->GetT0zVertex());
1371     SetT0(fESDOld->GetT0());
1372     //  leave amps out
1373
1374     // VZERO
1375     if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
1376
1377     if(fESDOld->GetVertex())SetPrimaryVertexSPD(fESDOld->GetVertex());
1378
1379     if(fESDOld->GetPrimaryVertex())SetPrimaryVertexTracks(fESDOld->GetPrimaryVertex());
1380
1381     if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
1382
1383     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
1384       AddTrack(fESDOld->GetTrack(i));
1385     }
1386
1387     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
1388       AddMuonTrack(fESDOld->GetMuonTrack(i));
1389     }
1390
1391     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
1392       AddPmdTrack(fESDOld->GetPmdTrack(i));
1393     }
1394
1395     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
1396       AddTrdTrack(fESDOld->GetTrdTrack(i));
1397     }
1398
1399     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
1400       AddV0(fESDOld->GetV0(i));
1401     }
1402
1403     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
1404       AddCascade(fESDOld->GetCascade(i));
1405     }
1406
1407     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
1408       AddKink(fESDOld->GetKink(i));
1409     }
1410
1411
1412     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
1413       AddCaloCluster(fESDOld->GetCaloCluster(i));
1414     }
1415
1416   }// if fesdold
1417 }
1418
1419
1420