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 #include "AliESDMuonTrack.h"
  36 #include "AliESDPmdTrack.h"
  37 #include "AliESDTrdTrack.h"
  38 #include "AliESDVertex.h"
  39 #include "AliESDcascade.h"
  40 #include "AliESDPmdTrack.h"
  41 #include "AliESDTrdTrack.h"
  42 #include "AliESDVertex.h"
  43 #include "AliESDcascade.h"
  44 #include "AliESDkink.h"
  45 #include "AliESDtrack.h"
  46 #include "AliESDHLTtrack.h"
  47 #include "AliESDCaloCluster.h"
  48 #include "AliESDv0.h"
  49 #include "AliESDFMD.h"
  50 #include "AliESDVZERO.h"
  51 #include "AliMultiplicity.h"
  52 #include "AliRawDataErrorLog.h"
  53
  54
  55 ClassImp(AliESDEvent)
  56
  57
  58
  59 // here we define the names, some classes are no TNamed, therefore the classnames
  60 // are the Names
  61   const char* AliESDEvent::fESDListName[kESDListN] = {"AliESDRun",
  62                                                        "AliESDHeader",
  63                                                        "AliESDZDC",
  64                                                        "AliESDFMD",
  65                                                        "AliESDVZERO",
  66                                                        "AliESDTZERO",
  67                                                        "SPDVertex",
  68                                                        "PrimaryVertex",
  69                                                        "AliMultiplicity",
  70                                                        "PHOSTrigger",
  71                                                        "EMCALTrigger",
  72                                                        "Tracks",
  73                                                        "MuonTracks",
  74                                                        "PmdTracks",
  75                                                        "TrdTracks",
  76                                                        "V0s",
  77                                                        "Cascades",
  78                                                        "Kinks",
  79                                                        "CaloClusters",
  80                                                        "AliRawDataErrorLogs"};
  81 //______________________________________________________________________________
  82 AliESDEvent::AliESDEvent():
  83   AliVEvent(),
  84   fESDObjects(new TList()),
  85   fESDRun(0),
  86   fHeader(0),
  87   fESDZDC(0),
  88   fESDFMD(0),
  89   fESDVZERO(0),
  90   fESDTZERO(0),
  91   fSPDVertex(0),
  92   fPrimaryVertex(0),
  93   fSPDMult(0),
  94   fPHOSTrigger(0),
  95   fEMCALTrigger(0),
  96   fTracks(0),
  97   fMuonTracks(0),
  98   fPmdTracks(0),
  99   fTrdTracks(0),
 100   fV0s(0),
 101   fCascades(0),
 102   fKinks(0),
 103   fCaloClusters(0),
 104   fErrorLogs(0),
 105   fESDOld(0),
 106   fConnected(kFALSE),
 107   fEMCALClusters(0),
 108   fFirstEMCALCluster(-1),
 109   fPHOSClusters(0),
 110   fFirstPHOSCluster(-1)
 111 {
 112 }
 113 //______________________________________________________________________________
 114 AliESDEvent::AliESDEvent(const AliESDEvent& esd):
 115   AliVEvent(esd),
 116   fESDObjects(new TList()),
 117   fESDRun(new AliESDRun(*esd.fESDRun)),
 118   fHeader(new AliESDHeader(*esd.fHeader)),
 119   fESDZDC(new AliESDZDC(*esd.fESDZDC)),
 120   fESDFMD(new AliESDFMD(*esd.fESDFMD)),
 121   fESDVZERO(new AliESDVZERO(*esd.fESDVZERO)),
 122   fESDTZERO(new AliESDTZERO(*esd.fESDTZERO)),
 123   fSPDVertex(new AliESDVertex(*esd.fSPDVertex)),
 124   fPrimaryVertex(new AliESDVertex(*esd.fPrimaryVertex)),
 125   fSPDMult(new AliMultiplicity(*esd.fSPDMult)),
 126   fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
 127   fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
 128   fTracks(new TClonesArray(*esd.fTracks)),
 129   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
 130   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
 131   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
 132   fV0s(new TClonesArray(*esd.fV0s)),
 133   fCascades(new TClonesArray(*esd.fCascades)),
 134   fKinks(new TClonesArray(*esd.fKinks)),
 135   fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
 136   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
 137   fESDOld(new AliESD(*esd.fESDOld)),
 138   fConnected(esd.fConnected),
 139   fEMCALClusters(esd.fEMCALClusters),
 140   fFirstEMCALCluster(esd.fFirstEMCALCluster),
 141   fPHOSClusters(esd.fPHOSClusters),
 142   fFirstPHOSCluster(esd.fFirstPHOSCluster)
 143
 144 {
 145   // CKB init in the constructor list and only add here ...
 146   AddObject(fESDRun);
 147   AddObject(fHeader);
 148   AddObject(fESDZDC);
 149   AddObject(fESDFMD);
 150   AddObject(fESDVZERO);
 151   AddObject(fESDTZERO);
 152   AddObject(fSPDVertex);
 153   AddObject(fPrimaryVertex);
 154   AddObject(fSPDMult);
 155   AddObject(fPHOSTrigger);
 156   AddObject(fEMCALTrigger);
 157   AddObject(fTracks);
 158   AddObject(fMuonTracks);
 159   AddObject(fPmdTracks);
 160   AddObject(fTrdTracks);
 161   AddObject(fV0s);
 162   AddObject(fCascades);
 163   AddObject(fKinks);
 164   AddObject(fCaloClusters);
 165   AddObject(fErrorLogs);
 166
 167   GetStdContent();
 168
 169 }
 170
 171 //______________________________________________________________________________
 172 AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
 173
 174   // Assignment operator
 175
 176   if(&source == this) return *this;
 177   AliVEvent::operator=(source);
 178
 179   fESDRun = new AliESDRun(*source.fESDRun);
 180   fHeader = new AliESDHeader(*source.fHeader);
 181   fESDZDC = new AliESDZDC(*source.fESDZDC);
 182   fESDFMD = new AliESDFMD(*source.fESDFMD);
 183   fESDVZERO = new AliESDVZERO(*source.fESDVZERO);
 184   fESDTZERO = new AliESDTZERO(*source.fESDTZERO);
 185   fSPDVertex = new AliESDVertex(*source.fSPDVertex);
 186   fPrimaryVertex = new AliESDVertex(*source.fPrimaryVertex);
 187   fSPDMult = new AliMultiplicity(*source.fSPDMult);
 188   fPHOSTrigger = new AliESDCaloTrigger(*source.fPHOSTrigger);
 189   fEMCALTrigger = new AliESDCaloTrigger(*source.fEMCALTrigger);
 190   fTracks = new TClonesArray(*source.fTracks);
 191   fMuonTracks = new TClonesArray(*source.fMuonTracks);
 192   fPmdTracks = new TClonesArray(*source.fPmdTracks);
 193   fTrdTracks = new TClonesArray(*source.fTrdTracks);
 194   fV0s = new TClonesArray(*source.fV0s);
 195   fCascades = new TClonesArray(*source.fCascades);
 196   fKinks = new TClonesArray(*source.fKinks);
 197   fCaloClusters = new TClonesArray(*source.fCaloClusters);
 198   fErrorLogs = new TClonesArray(*source.fErrorLogs);
 199   fESDOld = new AliESD(*source.fESDOld);
 200   // CKB this way?? or
 201   // or AddObject(  fESDZDC = new AliESDZDC(*source.fESDZDC));
 202
 203   fESDObjects = new TList();
 204   AddObject(fESDRun);
 205   AddObject(fHeader);
 206   AddObject(fESDZDC);
 207   AddObject(fESDFMD);
 208   AddObject(fESDVZERO);
 209   AddObject(fESDTZERO);
 210   AddObject(fSPDVertex);
 211   AddObject(fPrimaryVertex);
 212   AddObject(fSPDMult);
 213   AddObject(fPHOSTrigger);
 214   AddObject(fEMCALTrigger);
 215   AddObject(fTracks);
 216   AddObject(fMuonTracks);
 217   AddObject(fPmdTracks);
 218   AddObject(fTrdTracks);
 219   AddObject(fV0s);
 220   AddObject(fCascades);
 221   AddObject(fKinks);
 222   AddObject(fCaloClusters);
 223   AddObject(fErrorLogs);
 224
 225   fConnected = source.fConnected;
 226   fEMCALClusters = source.fEMCALClusters;
 227   fFirstEMCALCluster = source.fFirstEMCALCluster;
 228   fPHOSClusters = source.fPHOSClusters;
 229   fFirstPHOSCluster = source.fFirstPHOSCluster;
 230
 231
 232
 233   return *this;
 234
 235 }
 236
 237
 238 //______________________________________________________________________________
 239 AliESDEvent::~AliESDEvent()
 240 {
 241   //
 242   // Standard destructor
 243   //
 244
 245   // everthing on the list gets deleted automatically
 246
 247
 248   if(fESDObjects&&!fConnected)
 249     {
 250       delete fESDObjects;
 251       fESDObjects = 0;
 252     }
 253
 254
 255 }
 256
 257 //______________________________________________________________________________
 258 void AliESDEvent::Reset()
 259 {
 260
 261
 262   // Reset the standard contents
 263   ResetStdContent();
 264
 265   if(fESDOld)fESDOld->Reset();
 266   // call reset for user supplied data?
 267 }
 268
 269 void AliESDEvent::ResetStdContent()
 270 {
 271   // Reset the standard contents
 272   if(fESDRun) fESDRun->Reset();
 273   if(fHeader) fHeader->Reset();
 274   if(fESDZDC) fESDZDC->Reset();
 275   if(fESDFMD) fESDFMD->Clear(); // why clear.... need consistend names
 276   // if(fESDVZERO) fESDVZERO->; // NOT IMPLEMENTED
 277   //  if(fESDVZERO) new (fESDVZERO) AliESDVZERO();
 278   if(fESDTZERO) fESDTZERO->Reset();
 279   // CKB no clear/reset implemented
 280   if(fSPDVertex){
 281     fSPDVertex->~AliESDVertex();
 282     new (fSPDVertex) AliESDVertex();
 283     fSPDVertex->SetName(fESDListName[kSPDVertex]);
 284   }
 285   if(fPrimaryVertex){
 286     fPrimaryVertex->~AliESDVertex();
 287     new (fPrimaryVertex) AliESDVertex();
 288     fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
 289   }
 290   if(fSPDMult){
 291     fSPDMult->~AliMultiplicity();
 292     new (fSPDMult) AliMultiplicity();
 293   }
 294   if(fPHOSTrigger)fPHOSTrigger->Reset();
 295   if(fEMCALTrigger)fEMCALTrigger->Reset();
 296   if(fTracks)fTracks->Delete();
 297   if(fMuonTracks)fMuonTracks->Clear();
 298   if(fPmdTracks)fPmdTracks->Clear();
 299   if(fTrdTracks)fTrdTracks->Clear();
 300   if(fV0s)fV0s->Clear();
 301   if(fCascades)fCascades->Clear();
 302   if(fKinks)fKinks->Clear();
 303   if(fCaloClusters)fCaloClusters->Delete();
 304   if(fErrorLogs) fErrorLogs->Delete();
 305
 306   // don't reset fconnected fConnected ;
 307
 308   fEMCALClusters=0;
 309   fFirstEMCALCluster=-1;
 310   fPHOSClusters=0;
 311   fFirstPHOSCluster=-1;
 312 }
 313
 314
 315 Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
 316   //
 317   // Add V0
 318   //
 319   TClonesArray &fv = *fV0s;
 320   Int_t idx=fV0s->GetEntriesFast();
 321   new(fv[idx]) AliESDv0(*v);
 322   return idx;
 323 }
 324
 325 //______________________________________________________________________________
 326 void AliESDEvent::Print(Option_t *) const
 327 {
 328   //
 329   // Print header information of the event
 330   //
 331   printf("ESD run information\n");
 332   printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
 333          GetEventNumberInFile(),
 334          GetBunchCrossNumber(),
 335          GetOrbitNumber(),
 336          GetPeriodNumber(),
 337          GetRunNumber(),
 338          GetTriggerMask(),
 339          GetMagneticField() );
 340   printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
 341            fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(),
 342            fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(),
 343            fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes());
 344     printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
 345            GetDiamondX(),GetDiamondY());
 346     printf("SPD Multiplicity. Number of tracklets %d \n",
 347            fSPDMult->GetNumberOfTracklets());
 348   printf("Number of tracks: \n");
 349   printf("                 charged   %d\n", GetNumberOfTracks());
 350   printf("                 muon      %d\n", GetNumberOfMuonTracks());
 351   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
 352   printf("                 trd       %d\n", GetNumberOfTrdTracks());
 353   printf("                 v0        %d\n", GetNumberOfV0s());
 354   printf("                 cascades  %d\n", GetNumberOfCascades());
 355   printf("                 kinks     %d\n", GetNumberOfKinks());
 356   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
 357   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
 358   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
 359   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
 360   printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
 361
 362   return;
 363 }
 364
 365 void AliESDEvent::SetESDfriend(const AliESDfriend *ev) {
 366   //
 367   // Attaches the complementary info to the ESD
 368   //
 369   if (!ev) return;
 370
 371   // to be sure that we set the tracks also
 372   // in case of old esds
 373   // if(fESDOld)CopyFromOldESD();
 374
 375   Int_t ntrk=ev->GetNumberOfTracks();
 376
 377   for (Int_t i=0; i<ntrk; i++) {
 378     const AliESDfriendTrack *f=ev->GetTrack(i);
 379     GetTrack(i)->SetFriendTrack(f);
 380   }
 381 }
 382
 383 Bool_t  AliESDEvent::RemoveTrack(Int_t rm) {
 384   // ---------------------------------------------------------
 385   // Remove a track and references to it from ESD,
 386   // if this track does not come from a reconstructed decay
 387   // ---------------------------------------------------------
 388   Int_t last=GetNumberOfTracks()-1;
 389   if ((rm<0)||(rm>last)) return kFALSE;
 390
 391   Int_t used=0;
 392
 393   // Check if this track comes from a reconstructed decay
 394   Int_t nv0=GetNumberOfV0s();
 395   for (Int_t n=0; n<nv0; n++) {
 396     AliESDv0 *v0=GetV0(n);
 397
 398     Int_t idx=v0->GetNindex();
 399     if (rm==idx) return kFALSE;
 400     if (idx==last) used++;
 401
 402     idx=v0->GetPindex();
 403     if (rm==idx) return kFALSE;
 404     if (idx==last) used++;
 405   }
 406
 407   Int_t ncs=GetNumberOfCascades();
 408   for (Int_t n=0; n<ncs; n++) {
 409     AliESDcascade *cs=GetCascade(n);
 410
 411     Int_t idx=cs->GetIndex();
 412     if (rm==idx) return kFALSE;
 413     if (idx==last) used++;
 414   }
 415
 416   Int_t nkn=GetNumberOfKinks();
 417   for (Int_t n=0; n<nkn; n++) {
 418     AliESDkink *kn=GetKink(n);
 419
 420     Int_t idx=kn->GetIndex(0);
 421     if (rm==idx) return kFALSE;
 422     if (idx==last) used++;
 423
 424     idx=kn->GetIndex(1);
 425     if (rm==idx) return kFALSE;
 426     if (idx==last) used++;
 427   }
 428
 429
 430   //Replace the removed track with the last track
 431   TClonesArray &a=*fTracks;
 432   delete a.RemoveAt(rm);
 433
 434   if (rm==last) return kTRUE;
 435
 436   AliESDtrack *t=GetTrack(last);
 437   t->SetID(rm);
 438   new (a[rm]) AliESDtrack(*t);
 439   delete a.RemoveAt(last);
 440
 441   if (!used) return kTRUE;
 442
 443
 444   // Remap the indices of the daughters of reconstructed decays
 445   for (Int_t n=0; n<nv0; n++) {
 446     AliESDv0 *v0=GetV0(n);
 447     if (v0->GetIndex(0)==last) {
 448        v0->SetIndex(0,rm);
 449        used--;
 450        if (!used) return kTRUE;
 451     }
 452     if (v0->GetIndex(1)==last) {
 453        v0->SetIndex(1,rm);
 454        used--;
 455        if (!used) return kTRUE;
 456     }
 457   }
 458
 459   for (Int_t n=0; n<ncs; n++) {
 460     AliESDcascade *cs=GetCascade(n);
 461     if (cs->GetIndex()==last) {
 462        cs->SetIndex(rm);
 463        used--;
 464        if (!used) return kTRUE;
 465     }
 466   }
 467
 468   for (Int_t n=0; n<nkn; n++) {
 469     AliESDkink *kn=GetKink(n);
 470     if (kn->GetIndex(0)==last) {
 471        kn->SetIndex(rm,0);
 472        used--;
 473        if (!used) return kTRUE;
 474     }
 475     if (kn->GetIndex(1)==last) {
 476        kn->SetIndex(rm,1);
 477        used--;
 478        if (!used) return kTRUE;
 479     }
 480   }
 481
 482   return kTRUE;
 483 }
 484
 485
 486 Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
 487   //
 488   // Remove the data which are not needed for the physics analysis.
 489   //
 490   // If track's transverse parameter is larger than fDmax
 491   //                       OR
 492   //    track's longitudinal parameter is larger than fZmax
 493   // an attempt to remove this track from ESD is made.
 494   //
 495   // The track gets removed if it does not come
 496   // from a reconstructed decay
 497   //
 498
 499   Float_t dmax=cleanPars[0], zmax=cleanPars[1];
 500
 501   const AliESDVertex *vertex=GetVertex();
 502   Bool_t vtxOK=vertex->GetStatus(), rc=kFALSE;
 503
 504   Int_t nTracks=GetNumberOfTracks();
 505   for (Int_t i=nTracks-1; i>=0; i--) {
 506     AliESDtrack *track=GetTrack(i);
 507     Float_t xy,z; track->GetImpactParameters(xy,z);
 508     if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
 509       if (RemoveTrack(i)) rc=kTRUE;
 510     }
 511   }
 512
 513   return rc;
 514 }
 515
 516 Int_t  AliESDEvent::AddTrack(const AliESDtrack *t) {
 517     // Add track
 518     TClonesArray &ftr = *fTracks;
 519     AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
 520     track->SetID(fTracks->GetEntriesFast()-1);
 521     return  track->GetID();
 522 }
 523
 524  void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t) {
 525     TClonesArray &fmu = *fMuonTracks;
 526     new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
 527 }
 528
 529 void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t) {
 530   TClonesArray &fpmd = *fPmdTracks;
 531   new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
 532 }
 533
 534 void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t) {
 535   TClonesArray &ftrd = *fTrdTracks;
 536   new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
 537 }
 538
 539
 540
 541
 542 Int_t AliESDEvent::AddKink(const AliESDkink *c) {
 543     // Add kink
 544     TClonesArray &fk = *fKinks;
 545     AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
 546     kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
 547     return fKinks->GetEntriesFast()-1;
 548 }
 549
 550
 551 void AliESDEvent::AddCascade(const AliESDcascade *c) {
 552   TClonesArray &fc = *fCascades;
 553   new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
 554 }
 555
 556
 557 Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
 558     // Add calocluster
 559     TClonesArray &fc = *fCaloClusters;
 560     AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
 561     clus->SetID(fCaloClusters->GetEntriesFast()-1);
 562     return fCaloClusters->GetEntriesFast()-1;
 563   }
 564
 565
 566   void  AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) {
 567     TClonesArray &errlogs = *fErrorLogs;
 568     new(errlogs[errlogs.GetEntriesFast()])  AliRawDataErrorLog(*log);
 569   }
 570
 571 void  AliESDEvent::SetVertex(const AliESDVertex *vertex) {
 572   // use already allocated space
 573   if(fSPDVertex){
 574     *fSPDVertex = *vertex;
 575     fSPDVertex->SetName(fESDListName[kSPDVertex]);
 576   }
 577 }
 578
 579 void  AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex) {
 580   if(fPrimaryVertex){
 581     *fPrimaryVertex = *vertex;
 582     fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
 583   }
 584 }
 585
 586 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) {
 587   if(fSPDMult){
 588     *fSPDMult = *mul;
 589   }
 590 }
 591
 592
 593 void AliESDEvent::SetFMDData(AliESDFMD * obj) {
 594   // use already allocated space
 595   if(fESDFMD){
 596     *fESDFMD = *obj;
 597   }
 598 }
 599
 600 void AliESDEvent::SetVZEROData(AliESDVZERO * obj){
 601   // use already allocated space
 602   if(fESDVZERO)
 603     new(fESDVZERO) AliESDVZERO(*obj);
 604 }
 605
 606 void AliESDEvent::GetESDfriend(AliESDfriend *ev) const {
 607   //
 608   // Extracts the complementary info from the ESD
 609   //
 610   if (!ev) return;
 611
 612   Int_t ntrk=GetNumberOfTracks();
 613
 614   for (Int_t i=0; i<ntrk; i++) {
 615     AliESDtrack *t=GetTrack(i);
 616     const AliESDfriendTrack *f=t->GetFriendTrack();
 617     ev->AddTrack(f);
 618
 619     t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
 620
 621   }
 622 }
 623
 624
 625 void AliESDEvent::AddObject(TObject* obj)
 626 {
 627   // Add an object to the list of object.
 628   // Please be aware that in order to increase performance you should
 629   // refrain from using TObjArrays (if possible). Use TClonesArrays, instead.
 630   fESDObjects->SetOwner(kTRUE);
 631   fESDObjects->AddLast(obj);
 632 }
 633
 634
 635 void AliESDEvent::GetStdContent()
 636 {
 637   // set pointers for standard content
 638   // get by name much safer and not a big overhead since not called very often
 639
 640   fESDRun = (AliESDRun*)fESDObjects->FindObject(fESDListName[kESDRun]);
 641   fHeader = (AliESDHeader*)fESDObjects->FindObject(fESDListName[kHeader]);
 642   fESDZDC = (AliESDZDC*)fESDObjects->FindObject(fESDListName[kESDZDC]);
 643   fESDFMD = (AliESDFMD*)fESDObjects->FindObject(fESDListName[kESDFMD]);
 644   fESDVZERO = (AliESDVZERO*)fESDObjects->FindObject(fESDListName[kESDVZERO]);
 645   fESDTZERO = (AliESDTZERO*)fESDObjects->FindObject(fESDListName[kESDTZERO]);
 646   fSPDVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kSPDVertex]);
 647   fPrimaryVertex = (AliESDVertex*)fESDObjects->FindObject(fESDListName[kPrimaryVertex]);
 648   fSPDMult =       (AliMultiplicity*)fESDObjects->FindObject(fESDListName[kSPDMult]);
 649   fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kPHOSTrigger]);
 650   fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fESDListName[kEMCALTrigger]);
 651   fTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTracks]);
 652   fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kMuonTracks]);
 653   fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kPmdTracks]);
 654   fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kTrdTracks]);
 655   fV0s = (TClonesArray*)fESDObjects->FindObject(fESDListName[kV0s]);
 656   fCascades = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCascades]);
 657   fKinks = (TClonesArray*)fESDObjects->FindObject(fESDListName[kKinks]);
 658   fCaloClusters = (TClonesArray*)fESDObjects->FindObject(fESDListName[kCaloClusters]);
 659   fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fESDListName[kErrorLogs]);
 660
 661 }
 662
 663 void AliESDEvent::SetStdNames(){
 664   // Set the names of the standard contents
 665   //
 666   if(fESDObjects->GetEntries()==kESDListN){
 667     for(int i = 0;i < fESDObjects->GetEntries();i++){
 668       TObject *fObj = fESDObjects->At(i);
 669       if(fObj->InheritsFrom("TNamed")){
 670         ((TNamed*)fObj)->SetName(fESDListName[i]);
 671       }
 672       else if(fObj->InheritsFrom("TClonesArray")){
 673         ((TClonesArray*)fObj)->SetName(fESDListName[i]);
 674       }
 675     }
 676   }
 677   else{
 678     printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
 679   }
 680 }
 681
 682 void AliESDEvent::CreateStdContent()
 683 {
 684   // create the standard AOD content and set pointers
 685
 686   // create standard objects and add them to the TList of objects
 687   AddObject(new AliESDRun());
 688   AddObject(new AliESDHeader());
 689   AddObject(new AliESDZDC());
 690   AddObject(new AliESDFMD());
 691   AddObject(new AliESDVZERO());
 692   AddObject(new AliESDTZERO());
 693   AddObject(new AliESDVertex());
 694   AddObject(new AliESDVertex());
 695   AddObject(new AliMultiplicity());
 696   AddObject(new AliESDCaloTrigger());
 697   AddObject(new AliESDCaloTrigger());
 698   AddObject(new TClonesArray("AliESDtrack",0));
 699   AddObject(new TClonesArray("AliESDMuonTrack",0));
 700   AddObject(new TClonesArray("AliESDPmdTrack",0));
 701   AddObject(new TClonesArray("AliESDTrdTrack",0));
 702   AddObject(new TClonesArray("AliESDv0",0));
 703   AddObject(new TClonesArray("AliESDcascade",0));
 704   AddObject(new TClonesArray("AliESDkink",0));
 705   AddObject(new TClonesArray("AliESDCaloCluster",0));
 706   AddObject(new TClonesArray("AliRawDataErrorLog",0));
 707
 708   // check the order of the indices against enum...
 709
 710   // set names
 711   SetStdNames();
 712   // read back pointers
 713   GetStdContent();
 714 }
 715
 716 TObject* AliESDEvent::FindListObject(const char *name){
 717   if(fESDObjects)return fESDObjects->FindObject(name);
 718   return 0;
 719 }
 720
 721 void AliESDEvent::ReadFromTree(TTree *tree){
 722
 723   // load the TTree
 724   tree->LoadTree(0);
 725
 726   // if we find the "ESD" branch on the tree we do have the old structure
 727   if(tree->GetBranch("ESD")){
 728       char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
 729       if (!address) {
 730           printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
 731           tree->SetBranchAddress("ESD",&fESDOld);
 732       } else {
 733           printf("%s %d AliESDEvent::ReadFromTree() Reading old Tree \n",(char*)__FILE__,__LINE__);
 734           printf("%s %d Branch already connected. Using existing branch address. \n",(char*)__FILE__,__LINE__);
 735           fESDOld = (AliESD*) (*address);
 736       }
 737
 738
 739       CreateStdContent(); // create for copy
 740       // when reading back we are not owner of the list
 741       // must not delete it
 742       fESDObjects->SetOwner(kFALSE);
 743       return;
 744   }
 745
 746   fESDOld = 0;
 747
 748
 749   // Try to find AliESDEvent
 750   AliESDEvent *esdEvent = 0;
 751   esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
 752   //esdEvent = (AliESDEvent*)tree->GetUserInfo()->FindObject("AliESDEvent");
 753
 754   if(esdEvent){
 755       // Check if already connected to tree
 756     TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
 757     if (connectedList) {
 758       // If connected use the connected list if objects
 759       fESDObjects->Delete();
 760       fESDObjects = connectedList;
 761       GetStdContent();
 762       fConnected = true;
 763       return;
 764     }
 765     // Connect to tree
 766     if(fESDObjects->GetEntries()!=0){
 767       // this should not happen here put a warning?
 768     }
 769     // prevent a memory leak when reading back the TList
 770     delete fESDObjects;
 771     fESDObjects = 0;
 772     // create a new TList from the UserInfo TList...
 773     // copy constructor does not work...
 774     fESDObjects = (TList*)(esdEvent->GetList()->Clone());
 775     fESDObjects->SetOwner(kFALSE);
 776     if(fESDObjects->GetEntries()<kESDListN){
 777       printf("%s %d AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
 778              (char*)__FILE__,__LINE__,fESDObjects->GetEntries(),kESDListN);
 779     }
 780     // set the branch addresses
 781     TIter next(fESDObjects);
 782     TNamed *el;
 783     while((el=(TNamed*)next())){
 784       TString bname(el->GetName());
 785
 786       if(bname.CompareTo("AliESDfriend")==0)
 787         {
 788           // AliESDfriend does not have a name ...
 789           tree->SetBranchAddress("ESDfriend.",fESDObjects->GetObjectRef(el));
 790         }
 791       else{
 792         tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
 793       }
 794     }
 795     GetStdContent();
 796     // when reading back we are not owner of the list
 797     // must not delete it
 798     fESDObjects->SetOwner(kFALSE);
 799     fESDObjects->SetName("ESDObjectsConnectedToTree");
 800     // we are not owner of the list objects
 801     // must not delete it
 802     tree->GetUserInfo()->Add(fESDObjects);
 803     fConnected = true;
 804   }// no esdEvent
 805   else {
 806     // we can't get the list from the user data, create standard content
 807     // and set it by hand (no ESDfriend at the moment
 808     CreateStdContent();
 809     TIter next(fESDObjects);
 810     TNamed *el;
 811     while((el=(TNamed*)next())){
 812       TString bname(el->GetName());
 813       tree->SetBranchAddress(bname.Data(),fESDObjects->GetObjectRef(el));
 814     }
 815     GetStdContent();
 816     // when reading back we are not owner of the list
 817     // must not delete it
 818     fESDObjects->SetOwner(kFALSE);
 819   }
 820
 821
 822
 823 }
 824
 825
 826 void AliESDEvent::CopyFromOldESD()
 827 {
 828   // Method which copies over everthing from the old esd structure to the
 829   // new
 830
 831   if(fESDOld){
 832     ResetStdContent();
 833      // Run
 834     SetRunNumber(fESDOld->GetRunNumber());
 835     SetPeriodNumber(fESDOld->GetPeriodNumber());
 836     SetMagneticField(fESDRun->GetMagneticField());
 837
 838     // leave out diamond ...
 839     // SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
 840
 841     // header
 842     SetTriggerMask(fESDOld->GetTriggerMask());
 843     SetOrbitNumber(fESDOld->GetOrbitNumber());
 844     SetTimeStamp(fESDOld->GetTimeStamp());
 845     SetEventType(fESDOld->GetEventType());
 846     SetEventNumberInFile(fESDOld->GetEventNumberInFile());
 847     SetBunchCrossNumber(fESDOld->GetBunchCrossNumber());
 848     SetTriggerCluster(fESDOld->GetTriggerCluster());
 849
 850     // ZDC
 851
 852     SetZDC(fESDOld->GetZDCN1Energy(),
 853            fESDOld->GetZDCP1Energy(),
 854            fESDOld->GetZDCEMEnergy(),
 855            fESDOld->GetZDCN2Energy(),
 856            fESDOld->GetZDCP2Energy(),
 857            fESDOld->GetZDCParticipants());
 858
 859     // FMD
 860
 861     if(fESDOld->GetFMDData())SetFMDData(fESDOld->GetFMDData());
 862
 863     // T0
 864
 865     SetT0zVertex(fESDOld->GetT0zVertex());
 866     SetT0(fESDOld->GetT0());
 867     //  leave amps out
 868
 869     // VZERO
 870     if (fESDOld->GetVZEROData()) SetVZEROData(fESDOld->GetVZEROData());
 871
 872     if(fESDOld->GetVertex())SetVertex(fESDOld->GetVertex());
 873
 874     if(fESDOld->GetPrimaryVertex())SetPrimaryVertex(fESDOld->GetPrimaryVertex());
 875
 876     if(fESDOld->GetMultiplicity())SetMultiplicity(fESDOld->GetMultiplicity());
 877
 878     for(int i = 0;i<fESDOld->GetNumberOfTracks();i++){
 879       AddTrack(fESDOld->GetTrack(i));
 880     }
 881
 882     for(int i = 0;i<fESDOld->GetNumberOfMuonTracks();i++){
 883       AddMuonTrack(fESDOld->GetMuonTrack(i));
 884     }
 885
 886     for(int i = 0;i<fESDOld->GetNumberOfPmdTracks();i++){
 887       AddPmdTrack(fESDOld->GetPmdTrack(i));
 888     }
 889
 890     for(int i = 0;i<fESDOld->GetNumberOfTrdTracks();i++){
 891       AddTrdTrack(fESDOld->GetTrdTrack(i));
 892     }
 893
 894     for(int i = 0;i<fESDOld->GetNumberOfV0s();i++){
 895       AddV0(fESDOld->GetV0(i));
 896     }
 897
 898     for(int i = 0;i<fESDOld->GetNumberOfCascades();i++){
 899       AddCascade(fESDOld->GetCascade(i));
 900     }
 901
 902     for(int i = 0;i<fESDOld->GetNumberOfKinks();i++){
 903       AddKink(fESDOld->GetKink(i));
 904     }
 905
 906
 907     for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
 908       AddCaloCluster(fESDOld->GetCaloCluster(i));
 909     }
 910   }// if fesdold
 911 }
 912
 913
 914