STEER/AliESDEvent.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //-----------------------------------------------------------------
  19 //           Implementation of the AliESDEvent class
  20 //   This is the class to deal with during the phisical analysis of data.
  21 //   It also ensures the backward compatibility with the old ESD format.
  22 //
  23 // Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
  24 //-----------------------------------------------------------------
  25
  26 #include "TList.h"
  27 #include <TNamed.h>
  28
  29 #include "AliESDEvent.h"
  30 #include "AliESDfriend.h"
  31 #include "AliESDVZERO.h"
  32 #include "AliESDHLTtrack.h"
  33 #include "AliESDFMD.h"
  34 #include "AliESD.h"
  35
  36
  37 ClassImp(AliESDEvent)
  38
  39 //______________________________________________________________________________
  40 AliESDEvent::AliESDEvent():
  41   fESDObjects(new TList()),
  42   fESDRun(0),
  43   fHeader(0),
  44   fESDZDC(0),
  45   fESDFMD(0),
  46   fESDVZERO(0),
  47   fESDTZERO(0),
  48   fSPDVertex(0),
  49   fPrimaryVertex(0),
  50   fSPDMult(0),
  51   fPHOSTrigger(0),
  52   fEMCALTrigger(0),
  53   fTracks(0),
  54   fMuonTracks(0),
  55   fPmdTracks(0),
  56   fTrdTracks(0),
  57   fV0s(0),
  58   fCascades(0),
  59   fKinks(0),
  60   fCaloClusters(0),
  61   fErrorLogs(0),
  62   fESDOld(0),
  63   fEMCALClusters(0),
  64   fFirstEMCALCluster(-1),
  65   fPHOSClusters(0),
  66   fFirstPHOSCluster(-1)
  67 {
  68 }
  69 //______________________________________________________________________________
  70 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
  71   TObject(esd),
  72   fESDObjects(new TList()),
  73   fESDRun(new AliESDRun(*esd.fESDRun)),
  74   fHeader(new AliESDHeader(*esd.fHeader)),
  75   fESDZDC(new AliESDZDC(*esd.fESDZDC)),
  76   fESDFMD(new AliESDFMD(*esd.fESDFMD)),
  77   fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
  78   fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
  79   fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
  80   fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
  81   fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
  82   fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
  83   fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
  84   fTracks(new TClonesArray(*esd.fTracks)),
  85   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
  86   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
  87   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
  88   fV0s(new TClonesArray(*esd.fV0s)),
  89   fCascades(new TClonesArray(*esd.fCascades)),
  90   fKinks(new TClonesArray(*esd.fKinks)),
  91   fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
  92   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
  93   fESDOld(new AliESD(*esd.fESDOld)),
  94   fEMCALClusters(esd.fEMCALClusters),
  95   fFirstEMCALCluster(esd.fFirstEMCALCluster),
  96   fPHOSClusters(esd.fPHOSClusters),
  97   fFirstPHOSCluster(esd.fFirstPHOSCluster)
  98
  99 {
 100   // CKB init in the constructor list and only add here ...
 101   AddObject(fESDRun);
 102   AddObject(fHeader);
 103   AddObject(fESDZDC);
 104   AddObject(fESDFMD);
 105   AddObject(fESDVZERO);
 106   AddObject(fESDTZERO);
 107   AddObject(fSPDVertex);
 108   AddObject(fPrimaryVertex);
 109   AddObject(fSPDMult);
 110   AddObject(fPHOSTrigger);
 111   AddObject(fEMCALTrigger);
 112   AddObject(fTracks);
 113   AddObject(fMuonTracks);
 114   AddObject(fPmdTracks);
 115   AddObject(fTrdTracks);
 116   AddObject(fV0s);
 117   AddObject(fCascades);
 118   AddObject(fKinks);
 119   AddObject(fCaloClusters);
 120   AddObject(fErrorLogs);
 121
 122   GetStdContent();
 123
 124 }
 125
 126 //______________________________________________________________________________
 127 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
 128
 129   // Assignment operator
 130
 131   if(&source == this) return *this;
 132   TObject::operator=(source);
 133
 134   fESDRun = new AliESDRun(*source.fESDRun);
 135   fHeader = new AliESDHeader(*source.fHeader);
 136   fESDZDC = new AliESDZDC(*source.fESDZDC);
 137   fESDFMD = new AliESDFMD(*source.fESDFMD);
 138   fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
 139   fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
 140   fSPDVertex = new AliESDVertex(*source.fSPDVertex);
 141   fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
 142   fSPDMult = new AliMultiplicity(*source.fSPDMult);
 143   fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
 144   fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
 145   fTracks = new TClonesArray(*source.fTracks);
 146   fMuonTracks = new TClonesArray(*source.fMuonTracks);
 147   fPmdTracks = new TClonesArray(*source.fPmdTracks);
 148   fTrdTracks = new TClonesArray(*source.fTrdTracks);
 149   fV0s = new TClonesArray(*source.fV0s);
 150   fCascades = new TClonesArray(*source.fCascades);
 151   fKinks = new TClonesArray(*source.fKinks);
 152   fCaloClusters = new TClonesArray(*source.fCaloClusters);
 153   fErrorLogs = new TClonesArray(*source.fErrorLogs);
 154   fESDOld = new AliESD(*source.fESDOld);
 155   // CKB this way?? or
 156   // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
 157
 158   fESDObjects = new TList();
 159   AddObject(fESDRun);
 160   AddObject(fHeader);
 161   AddObject(fESDZDC);
 162   AddObject(fESDFMD);
 163   AddObject(fESDVZERO);
 164   AddObject(fESDTZERO);
 165   AddObject(fSPDVertex);
 166   AddObject(fPrimaryVertex);
 167   AddObject(fSPDMult);
 168   AddObject(fPHOSTrigger);
 169   AddObject(fEMCALTrigger);
 170   AddObject(fTracks);
 171   AddObject(fMuonTracks);
 172   AddObject(fPmdTracks);
 173   AddObject(fTrdTracks);
 174   AddObject(fV0s);
 175   AddObject(fCascades);
 176   AddObject(fKinks);
 177   AddObject(fCaloClusters);
 178   AddObject(fErrorLogs);
 179
 180
 181   fEMCALClusters = source.fEMCALClusters;
 182   fFirstEMCALCluster = source.fFirstEMCALCluster;
 183   fPHOSClusters = source.fPHOSClusters;
 184   fFirstPHOSCluster = source.fFirstPHOSCluster;
 185
 186
 187
 188   return *this;
 189
 190 }
 191
 192
 193 //______________________________________________________________________________
 194 AliESDEvent::~AliESDEvent()
 195 {
 196   //
 197   // Standard destructor
 198   //
 199
 200   // everthing on the list gets deleted automatically
 201   delete fESDObjects;
 202   fESDObjects = 0;
 203 }
 204
 205 //______________________________________________________________________________
 206 void AliESDEvent::Reset()
 207 {
 208
 209
 210   // Reset the standard contents
 211   ResetStdContent();
 212
 213   if(fESDOld)fESDOld->Reset();
 214   // call reset for user supplied data?
 215 }
 216
 217 void AliESDEvent::ResetStdContent()
 218 {
 219   // Reset the standard contents
 220   if(fESDRun) fESDRun->Reset();
 221   if(fHeader) fHeader->Reset();
 222   if(fESDZDC) fESDZDC->Reset();
 223   if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
 224   // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
 225   //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
 226   if(fESDTZERO) fESDTZERO->Reset();
 227   // CKB no clear/reset implemented
 228   if(fSPDVertex){
 229     new (fSPDVertex) AliESDVertex();
 230     fSPDVertex->SetName("SPDVertex");
 231   }
 232   if(fPrimaryVertex){
 233     new (fPrimaryVertex) AliESDVertex();
 234     fPrimaryVertex->SetName("PrimaryVertex");
 235   }
 236   if(fSPDMult)new (fSPDMult) AliMultiplicity();
 237   if(fPHOSTrigger)fPHOSTrigger->Reset();
 238   if(fEMCALTrigger)fEMCALTrigger->Reset();
 239   if(fTracks)fTracks->Clear();
 240   if(fMuonTracks)fMuonTracks->Clear();
 241   if(fPmdTracks)fPmdTracks->Clear();
 242   if(fTrdTracks)fTrdTracks->Clear();
 243   if(fV0s)fV0s->Clear();
 244   if(fCascades)fCascades->Clear();
 245   if(fKinks)fKinks->Clear();
 246   if(fCaloClusters)fCaloClusters->Clear();
 247   if(fErrorLogs) fErrorLogs->Clear();
 248
 249   fEMCALClusters=0;
 250   fFirstEMCALCluster=-1;
 251   fPHOSClusters=0;
 252   fFirstPHOSCluster=-1;
 253 }
 254
 255
 256 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
 257   //
 258   // Add V0
 259   //
 260   TClonesArray &fv = *fV0s;
 261   Int_t idx=fV0s->GetEntriesFast();
 262   new(fv[idx]) AliESDv0(*v);
 263   return idx;
 264 }
 265
 266 //______________________________________________________________________________
 267 void AliESDEvent::Print(Option_t *) const
 268 {
 269   //
 270   // Print header information of the event
 271   //
 272   printf("ESD run information\n");
 273   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
 274          GetEventNumberInFile(),
 275          GetBunchCrossNumber(),
 276          GetOrbitNumber(),
 277          GetPeriodNumber(),
 278          GetRunNumber(),
 279          GetTriggerMask(),
 280          GetMagneticField() );
 281   printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
 282            fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
 283            fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
 284            fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
 285     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
 286            GetDiamondX(),GetDiamondY());
 287     printf("SPD Multiplicity. Number of tracklets %d \n",
 288            fSPDMult->GetNumberOfTracklets());
 289   printf("Number of tracks: \n");
 290   printf("                 charged   %d\n", GetNumberOfTracks());
 291   printf("                 muon      %d\n", GetNumberOfMuonTracks());
 292   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
 293   printf("                 trd       %d\n", GetNumberOfTrdTracks());
 294   printf("                 v0        %d\n", GetNumberOfV0s());
 295   printf("                 cascades  %d\n", GetNumberOfCascades());
 296   printf("                 kinks     %d\n", GetNumberOfKinks());
 297   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
 298   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
 299   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
 300   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
 301   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
 302 }
 303
 304 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
 305   //
 306   // Attaches the complementary info to the ESD
 307   //
 308   if (!ev) return;
 309
 310   // to be sure that we set the tracks also
 311   // in case of old esds
 312   if(fESDOld)CopyFromOldESD();
 313
 314   Int_t ntrk=ev->GetNumberOfTracks();
 315
 316   for (Int_t i=0; i<ntrk; i++) {
 317     const AliESDfriendTrack *f=ev->GetTrack(i);
 318     GetTrack(i)->SetFriendTrack(f);
 319   }
 320 }
 321
 322 Int_t  AliESDEvent::AddTrack(const AliESDtrack *t) {
 323     // Add track
 324     TClonesArray &ftr = *fTracks;
 325     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
 326     track->SetID(fTracks->GetEntriesFast()-1);
 327     return  track->GetID();
 328 }
 329
 330 Int_t AliESDEvent::AddKink(const AliESDkink *c) {
 331     // Add kink
 332     TClonesArray &fk = *fKinks;
 333     AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
 334     kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
 335     return fKinks->GetEntriesFast()-1;
 336 }
 337
 338 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
 339     // Add calocluster
 340     TClonesArray &fc = *fCaloClusters;
 341     AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
 342     clus->SetID(fCaloClusters->GetEntriesFast()-1);
 343     return fCaloClusters->GetEntriesFast()-1;
 344   }
 345
 346
 347 void AliESDEvent::SetFMDData(AliESDFMD * obj) {
 348   // use already allocated space
 349   if(fESDFMD){
 350     new(fESDFMD) AliESDFMD(*obj);
 351   }
 352 }
 353
 354 void AliESDEvent::SetVZEROData(AliESDVZERO * obj){
 355   // use already allocated space
 356   if(fESDVZERO)
 357     new(fESDVZERO) AliESDVZERO(*obj);
 358 }
 359
 360 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
 361   //
 362   // Extracts the complementary info from the ESD
 363   //
 364   if (!ev) return;
 365
 366   Int_t ntrk=GetNumberOfTracks();
 367
 368   for (Int_t i=0; i<ntrk; i++) {
 369     const AliESDtrack *t=GetTrack(i);
 370     const AliESDfriendTrack *f=t->GetFriendTrack();
 371     ev->AddTrack(f);
 372   }
 373 }
 374
 375
 376 void AliESDEvent::AddObject(TObject* obj)
 377 {
 378   // Add an object to the list of object.
 379   // Please be aware that in order to increase performance you should
 380   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
 381   fESDObjects->SetOwner(kTRUE);
 382   fESDObjects->AddLast(obj);
 383 }
 384
 385
 386 void AliESDEvent::GetStdContent()
 387 {
 388   // set pointers for standard content
 389   // eventually get by name?
 390   fESDRun = (AliESDRun*)fESDObjects->At(kESDRun);
 391   fHeader = (AliESDHeader*)fESDObjects->At(kHeader);
 392   fESDZDC = (AliESDZDC*)fESDObjects->At(kESDZDC);
 393   fESDFMD = (AliESDFMD*)fESDObjects->At(kESDFMD);
 394   fESDVZERO = (AliESDVZERO*)fESDObjects->At(kESDVZERO);
 395   fESDTZERO = (AliESDTZERO*)fESDObjects->At(kESDTZERO);
 396   fSPDVertex = (AliESDVertex*)fESDObjects->At(kSPDVertex);
 397   fPrimaryVertex = (AliESDVertex*)fESDObjects->At(kPrimaryVertex);
 398   fSPDMult =       (AliMultiplicity*)fESDObjects->At(kSPDMult);
 399   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->At(kPHOSTrigger);
 400   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->At(kEMCALTrigger);
 401   fTracks = (TClonesArray*)fESDObjects->At(kTracks);
 402   fMuonTracks = (TClonesArray*)fESDObjects->At(kMuonTracks);
 403   fPmdTracks = (TClonesArray*)fESDObjects->At(kPmdTracks);
 404   fTrdTracks = (TClonesArray*)fESDObjects->At(kTrdTracks);
 405   fV0s = (TClonesArray*)fESDObjects->At(kV0s);
 406   fCascades = (TClonesArray*)fESDObjects->At(kCascades);
 407   fKinks = (TClonesArray*)fESDObjects->At(kKinks);
 408   fCaloClusters = (TClonesArray*)fESDObjects->At(kCaloClusters);
 409   fErrorLogs = (TClonesArray*)fESDObjects->At(kErrorLogs);
 410
 411 }
 412
 413 void AliESDEvent::SetStdNames(){
 414   // Set the names of the standard contents
 415   fSPDVertex->SetName("SPDVertex");
 416   fPrimaryVertex->SetName("PrimaryVertex");
 417   fPHOSTrigger->SetName("PHOSTrigger");
 418   fEMCALTrigger->SetName("EMCALTrigger");
 419   fTracks->SetName("Tracks");
 420   fMuonTracks->SetName("MuonTracks");
 421   fPmdTracks->SetName("PmdTracks");
 422   fTrdTracks->SetName("TrdTracks");
 423   fV0s->SetName("V0s");
 424   fCascades->SetName("Cascades");
 425   fKinks->SetName("Kinks");
 426   fCaloClusters->SetName("CaloClusters");
 427
 428 }
 429
 430 void AliESDEvent::CreateStdContent()
 431 {
 432   // create the standard AOD content and set pointers
 433
 434   // create standard objects and add them to the TList of objects
 435   AddObject(new AliESDRun());
 436   AddObject(new AliESDHeader());
 437   AddObject(new AliESDZDC());
 438   AddObject(new AliESDFMD());
 439   AddObject(new AliESDVZERO());
 440   AddObject(new AliESDTZERO());
 441   AddObject(new AliESDVertex());
 442   AddObject(new AliESDVertex());
 443   AddObject(new AliMultiplicity());
 444   AddObject(new AliESDCaloTrigger());
 445   AddObject(new AliESDCaloTrigger());
 446   AddObject(new TClonesArray("AliESDtrack",0));
 447   AddObject(new TClonesArray("AliESDMuonTrack",0));
 448   AddObject(new TClonesArray("AliESDPmdTrack",0));
 449   AddObject(new TClonesArray("AliESDTrdTrack",0));
 450   AddObject(new TClonesArray("AliESDv0",0));
 451   AddObject(new TClonesArray("AliESDcascade",0));
 452   AddObject(new TClonesArray("AliESDkink",0));
 453   AddObject(new TClonesArray("AliESDCaloCluster",0));
 454   AddObject(new TClonesArray("AliRawDataErrorLog",0));
 455
 456   // check the order of the indices against enum...
 457
 458   // read back pointers
 459   GetStdContent();
 460   // set names
 461   SetStdNames();
 462
 463 }
 464
 465 TObject* AliESDEvent::FindListObject(const char *name){
 466   if(fESDObjects)return fESDObjects->FindObject(name);
 467   return 0;
 468 }
 469
 470 void AliESDEvent::ReadFromTree(TTree *tree){
 471
 472
 473   // if we find the "ESD" branch on the tree we do have the old structure
 474   if(tree->GetBranch("ESD")){
 475       char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
 476       if (!address) {
 477           printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
 478           tree->SetBranchAddress("ESD",&fESDOld);
 479       } else {
 480           printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
 481           printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
 482           fESDOld = (AliESD*) (*address);
 483       }
 484
 485
 486       CreateStdContent(); // create for copy
 487       // when reading back we are not owner of the list
 488       // must not delete it
 489       fESDObjects->SetOwner(kFALSE);
 490       return;
 491   }
 492
 493   fESDOld = 0;
 494
 495
 496   // Try to find AliESDEvent
 497   AliESDEvent *esdEvent = 0;
 498   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
 499   //esdEvent = (AliESDEvent*)tree->GetUserInfo()->FindObject("AliESDEvent");
 500
 501   if(esdEvent){
 502       // Check if already connected to tree
 503 //      TList* connectedList = (TList*) (tree->GetTree()->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
 504       TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
 505       if (connectedList) {
 506           // If connected use the connected list if objects
 507           fESDObjects->Delete();
 508           fESDObjects = connectedList;
 509           GetStdContent();
 510           return;
 511       }
 512       // Connect to tree
 513     if(fESDObjects->GetEntries()!=0){
 514       // this should not happen here put a warning?
 515     }
 516     // prevent a memory leak when reading back the TList
 517     delete fESDObjects;
 518     fESDObjects = 0;
 519     // create a new TList from the UserInfo TList...
 520     // copy constructor does not work...
 521     fESDObjects = (TList*)(esdEvent->GetList()->Clone());
 522     if(fESDObjects->GetEntries()<kESDListN){
 523       printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
 524              (char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
 525     }
 526     // set the branch addresses
 527     TIter next(fESDObjects);
 528     TNamed *el;
 529     while((el=(TNamed*)next())){
 530       TString bname(el->GetName());
 531
 532       if(bname.CompareTo("AliESDfriend")==0)
 533         {
 534           // AliESDfriend does not have a name ...
 535           tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
 536         }
 537       else{
 538         tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
 539       }
 540     }
 541     GetStdContent();
 542     // when reading back we are not owner of the list
 543     // must not delete it
 544     fESDObjects->SetOwner(kFALSE);
 545     // Add list to user info
 546     fESDObjects->SetName("ESDObjectsConnectedToTree");
 547     tree->GetUserInfo()->Add(fESDObjects);
 548   }// no esdEvent
 549   else {
 550     // we can't get the list from the user data, create standard content
 551     // and set it by hand (no ESDfriend at the moment
 552     CreateStdContent();
 553     TIter next(fESDObjects);
 554     TNamed *el;
 555     while((el=(TNamed*)next())){
 556       TString bname(el->GetName());
 557       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
 558     }
 559     GetStdContent();
 560     // when reading back we are not owner of the list
 561     // must not delete it
 562     fESDObjects->SetOwner(kFALSE);
 563   }
 564
 565
 566
 567 }
 568
 569
 570 void AliESDEvent::CopyFromOldESD()
 571 {
 572   // Method which copies over everthing from the old esd structure to the
 573   // new
 574
 575   if(fESDOld){
 576     ResetStdContent();
 577      // Run
 578     SetRunNumber(fESDOld->GetRunNumber());
 579     SetPeriodNumber(fESDOld->GetPeriodNumber());
 580     SetMagneticField(fESDRun->GetMagneticField());
 581
 582     // leave out diamond ...
 583     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
 584
 585     // header
 586     SetTriggerMask(fESDOld->GetTriggerMask());
 587     SetOrbitNumber(fESDOld->GetOrbitNumber());
 588     SetTimeStamp(fESDOld->GetTimeStamp());
 589     SetEventType(fESDOld->GetEventType());
 590     SetEventNumberInFile(fESDOld->GetEventNumberInFile());
 591     SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
 592     SetTriggerCluster(fESDOld->GetTriggerCluster());
 593
 594     // ZDC
 595
 596     SetZDC(fESDOld->GetZDCN1Energy(),
 597            fESDOld->GetZDCP1Energy(),
 598            fESDOld->GetZDCEMEnergy(),
 599            fESDOld->GetZDCN2Energy(),
 600            fESDOld->GetZDCP2Energy(),
 601            fESDOld->GetZDCParticipants());
 602
 603     // FMD
 604
 605     SetFMDData(fESDOld->GetFMDData());
 606
 607     // T0
 608
 609     SetT0zVertex(fESDOld->GetT0zVertex());
 610     SetT0(fESDOld->GetT0());
 611     //  leave amps out
 612
 613     // VZERO
 614     SetVZEROData(fESDOld->GetVZEROData());
 615
 616     SetVertex(fESDOld->GetVertex());
 617
 618     SetPrimaryVertex(fESDOld->GetPrimaryVertex());
 619
 620     SetMultiplicity(fESDOld->GetMultiplicity());
 621
 622     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
 623       AddTrack(fESDOld->GetTrack(i));
 624     }
 625
 626     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
 627       AddMuonTrack(fESDOld->GetMuonTrack(i));
 628     }
 629
 630     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
 631       AddPmdTrack(fESDOld->GetPmdTrack(i));
 632     }
 633
 634     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
 635       AddTrdTrack(fESDOld->GetTrdTrack(i));
 636     }
 637
 638     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
 639       AddV0(fESDOld->GetV0(i));
 640     }
 641
 642     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
 643       AddCascade(fESDOld->GetCascade(i));
 644     }
 645
 646     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
 647       AddKink(fESDOld->GetKink(i));
 648     }
 649
 650
 651     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
 652       AddCaloCluster(fESDOld->GetCaloCluster(i));
 653     }
 654   }// if fesdold
 655 }
 656
 657
 658