EVE/Alieve/EventAlieve.cxx

   1 // $Header$
   2
   3 #include "EventAlieve.h"
   4 #include <Reve/Reve.h>
   5
   6 #include <AliRunLoader.h>
   7 #include <AliESD.h>
   8 #include <AliESDfriend.h>
   9
  10 #include <TFile.h>
  11 #include <TTree.h>
  12
  13 #include <TROOT.h>
  14 #include <TSystem.h>
  15
  16 using namespace Reve;
  17 using namespace Alieve;
  18
  19 //______________________________________________________________________
  20 // Event
  21 //
  22
  23 ClassImp(Event)
  24
  25 Event* Alieve::gEvent = 0;
  26
  27 Bool_t Alieve::Event::fgUseRunLoader   = kTRUE;
  28 Bool_t Alieve::Event::fgUseESDTree     = kTRUE;
  29 Bool_t Alieve::Event::fgAvoidExcOnOpen = kTRUE;
  30
  31 void Event::Initialize(Bool_t use_runloader, Bool_t use_esd,
  32                        Bool_t avoid_exc_on_open)
  33 {
  34   static const Exc_t eH("Event::Initialize ");
  35
  36   fgUseRunLoader   = use_runloader;
  37   fgUseESDTree     = use_esd;
  38   fgAvoidExcOnOpen = avoid_exc_on_open;
  39
  40   /*
  41   if(fgUseRunLoader == false && fgUseESDTree == false)
  42     throw(eH + "should use at least one data source.");
  43
  44   if(fgUseRunLoader) {
  45     AssertMacro("loadlibs.C");
  46   }
  47   else if(fgUseESDTree) {
  48     gSystem->Load("libESD.so");
  49   }
  50   */
  51 }
  52
  53 /**************************************************************************/
  54
  55 Event::Event() :
  56   EventBase(),
  57
  58   fPath (), fEventId   (0),
  59   fRunLoader (0),
  60   fESDFile       (0), fESDTree       (0), fESD       (0),
  61   /* fESDfriendFile (0), fESDfriendTree (0), */
  62   fESDfriend (0), fESDfriendExists(kFALSE)
  63 {}
  64
  65 Event::Event(TString path, Int_t ev) :
  66   EventBase("AliEVE Event"),
  67
  68   fPath (path), fEventId(ev),
  69   fRunLoader (0),
  70   fESDFile       (0), fESDTree       (0), fESD       (0),
  71   /* fESDfriendFile (0), fESDfriendTree (0), */
  72   fESDfriend (0), fESDfriendExists(kFALSE)
  73 {
  74   Open();
  75 }
  76
  77 /**************************************************************************/
  78
  79 void Event::Open()
  80 {
  81   static const Exc_t eH("Event::Open ");
  82
  83   gSystem->ExpandPathName(fPath);
  84   if(fPath[0] != '/')
  85     fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
  86
  87   if(fgUseRunLoader) {
  88     TString ga_path(Form("%s/galice.root", fPath.Data()));
  89     if(gSystem->AccessPathName(ga_path, kReadPermission)) {
  90       if (fgAvoidExcOnOpen) {
  91         Warning(eH, "RunLoader not initialized.");
  92         goto end_run_loader;
  93       } else {
  94         throw(eH + "can not read '" + ga_path + "'.");
  95       }
  96     }
  97     fRunLoader = AliRunLoader::Open(ga_path);
  98     if(!fRunLoader)
  99       throw(eH + "failed opening ALICE run loader from '" + ga_path + "'.");
 100     {
 101       TString alice_path = fPath + "/";
 102       fRunLoader->SetDirName(alice_path);
 103     }
 104     if(fRunLoader->LoadgAlice() != 0)
 105       throw(eH + "failed loading gAlice.");
 106     if(fRunLoader->LoadHeader() != 0)
 107       throw(eH + "failed loading header.");
 108
 109     if(fRunLoader->GetEvent(fEventId) != 0)
 110       throw(eH + "failed getting required event.");
 111   }
 112 end_run_loader:
 113
 114   if(fgUseESDTree) {
 115     TString p(Form("%s/AliESDs.root", fPath.Data()));
 116     if(gSystem->AccessPathName(p, kReadPermission)) {
 117       if (fgAvoidExcOnOpen) {
 118         Warning(eH, "ESD not initialized.");
 119         goto end_esd_loader;
 120       } else {
 121         throw(eH + "can not read '" + p + "'.");
 122       }
 123     }
 124     fESDFile = new TFile(p);
 125     if(fESDFile->IsZombie()) {
 126       delete fESDFile; fESDFile = 0;
 127       throw(eH + "failed opening ALICE ESD from '" + p + "'.");
 128     }
 129
 130     fESDTree = (TTree*) fESDFile->Get("esdTree");
 131     if(fESDTree == 0)
 132       throw(eH + "failed getting the esdTree.");
 133     fESDTree->SetBranchAddress("ESD", &fESD);
 134     if(fESDTree->GetEntry(fEventId) <= 0)
 135       throw(eH + "failed getting required event from ESD.");
 136
 137     // Check if ESDfriends exists and load it
 138     p = Form("%s/AliESDfriends.root", fPath.Data());
 139     if(gSystem->AccessPathName(p, kReadPermission) == kFALSE) {
 140       //fESDfriendFile = new TFile(p);
 141       //if(fESDfriendFile->IsZombie()) {
 142       //delete fESDfriendFile; fESDfriendFile = 0;
 143       //throw(eH + "failed opening ALICE ESDfriend from '" + p + "'.");
 144       //}
 145
 146       //fESDfriendTree = (TTree*) fESDfriendFile->Get("esdFriendTree");
 147       //if(fESDfriendTree == 0)
 148       //  throw(eH + "failed getting the esdFriendTree.");
 149       //fESDfriendTree->SetBranchAddress("ESDfriend", &fESDfriend);
 150       //if(fESDfriendTree->GetEntry(fEventId) <= 0)
 151       //throw(eH + "failed getting required event from ESDfriend.");
 152
 153       //fESD->SetESDfriend(fESDfriend);
 154
 155       fESDfriendExists = kTRUE;
 156       fESDTree->SetBranchStatus ("ESDfriend*", 1);
 157       fESDTree->SetBranchAddress("ESDfriend.", &fESDfriend);
 158     }
 159   }
 160 end_esd_loader:
 161
 162   SetName(Form("Event %d", fEventId));
 163   SetTitle(fPath);
 164 }
 165
 166 void Event::GotoEvent(Int_t event)
 167 {
 168   static const Exc_t eH("Event::GotoEvent ");
 169
 170   Int_t maxEvent = 0;
 171   if(fRunLoader)
 172     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
 173   else if(fESDTree)
 174     maxEvent = fESDTree->GetEntries() - 1;
 175   else
 176     throw(eH + "neither RunLoader nor ESD loaded.");
 177
 178   if(event < 0 || event > maxEvent)
 179     throw(eH + Form("event %d not present, available range [%d, %d].",
 180                     event, 0, maxEvent));
 181
 182   DestroyElements();
 183   fEventId = event;
 184   SetName(Form("Event %d", fEventId));
 185   UpdateItems();
 186
 187   if(fRunLoader) {
 188     if(fRunLoader->GetEvent(fEventId) != 0)
 189       throw(eH + "failed getting required event.");
 190   }
 191
 192   if(fESDTree) {
 193     delete fESD;       fESD       = 0;
 194     delete fESDfriend; fESDfriend = 0;
 195
 196     if(fESDTree->GetEntry(fEventId) <= 0)
 197       throw(eH + "failed getting required event from ESD.");
 198
 199     //if(fESDfriendTree != 0) {
 200     //  if(fESDfriendTree->GetEntry(fEventId) <= 0)
 201     //  throw(eH + "failed getting required event from ESDfriend.");
 202
 203     if (fESDfriendExists)
 204       fESD->SetESDfriend(fESDfriend);
 205   }
 206 }
 207
 208 void Event::Close()
 209 {
 210   if (fESDTree) {
 211     delete fESD;       fESD       = 0;
 212     delete fESDfriend; fESDfriend = 0;
 213
 214     delete fESDTree; fESDTree = 0;
 215     delete fESDFile; fESDFile = 0;
 216   }
 217 }
 218
 219 /**************************************************************************/
 220 /**************************************************************************/
 221
 222 // Static convenience functions.
 223
 224 AliRunLoader* Event::AssertRunLoader()
 225 {
 226   static const Exc_t eH("Event::AssertRunLoader ");
 227
 228   if(gEvent == 0)
 229     throw(eH + "ALICE event not ready.");
 230   if(gEvent->fRunLoader == 0)
 231     throw(eH + "AliRunLoader not initialised.");
 232   return gEvent->fRunLoader;
 233 }
 234
 235 AliESD* Event::AssertESD()
 236 {
 237   static const Exc_t eH("Event::AssertESD ");
 238
 239   if(gEvent == 0)
 240     throw(eH + "ALICE event not ready.");
 241   if(gEvent->fESD == 0)
 242     throw(eH + "AliESD not initialised.");
 243   return gEvent->fESD;
 244 }
 245
 246 AliESDfriend* Event::AssertESDfriend()
 247 {
 248   static const Exc_t eH("Event::AssertESDfriend ");
 249
 250   if(gEvent == 0)
 251     throw(eH + "ALICE event not ready.");
 252   if(gEvent->fESDfriend == 0)
 253     throw(eH + "AliESDfriend not initialised.");
 254   return gEvent->fESDfriend;
 255 }