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