EVE/Alieve/EventAlieve.cxx

   1 // $Header$
   2
   3 #include "EventAlieve.h"
   4 #include <Reve/Reve.h>
   5 #include <Reve/RGTopFrame.h>
   6
   7 #include <AliRunLoader.h>
   8 #include <AliRun.h>
   9 #include <AliESD.h>
  10 #include <AliESDfriend.h>
  11 #include <AliMagFMaps.h>
  12 #include <AliCDBManager.h>
  13 #include <AliHeader.h>
  14 #include <AliGeomManager.h>
  15
  16 #include <TFile.h>
  17 #include <TTree.h>
  18 #include <TObjString.h>
  19 #include <TError.h>
  20
  21 #include <TROOT.h>
  22 #include <TSystem.h>
  23 #include <TCint.h>
  24
  25 using namespace Reve;
  26 using namespace Alieve;
  27
  28 //______________________________________________________________________
  29 // Event
  30 //
  31 // Provide interface for loading and navigating standard AliRoot data
  32 // (AliRunLoader) and ESDs.
  33 //
  34 // Missing support for raw-data. For now this is handled individually
  35 // by each sub-detector.
  36 //
  37
  38 ClassImp(Event)
  39
  40 Event* Alieve::gEvent = 0;
  41
  42 Bool_t Alieve::Event::fgUseRunLoader   = kTRUE;
  43 Bool_t Alieve::Event::fgUseESDTree     = kTRUE;
  44 Bool_t Alieve::Event::fgAvoidExcOnOpen = kTRUE;
  45
  46 TString  Alieve::Event::fgCdbUri("local://$ALICE_ROOT");
  47
  48 AliMagF* Alieve::Event::fgMagField = 0;
  49
  50
  51 void Event::Initialize(Bool_t use_runloader, Bool_t use_esd,
  52                        Bool_t avoid_exc_on_open)
  53 {
  54   static const Exc_t eH("Event::Initialize ");
  55
  56   fgUseRunLoader   = use_runloader;
  57   fgUseESDTree     = use_esd;
  58   fgAvoidExcOnOpen = avoid_exc_on_open;
  59
  60   /*
  61   if(fgUseRunLoader == false && fgUseESDTree == false)
  62     throw(eH + "should use at least one data source.");
  63
  64   if(fgUseRunLoader) {
  65     AssertMacro("loadlibs.C");
  66   }
  67   else if(fgUseESDTree) {
  68     gSystem->Load("libESD.so");
  69   }
  70   */
  71 }
  72
  73 /**************************************************************************/
  74
  75 Event::Event() :
  76   EventBase(),
  77
  78   fPath (), fEventId   (0),
  79   fRunLoader (0),
  80   fESDFile   (0), fESDTree (0), fESD (0),
  81   fESDfriend (0), fESDfriendExists(kFALSE),
  82   fNewEventCommands()
  83 {}
  84
  85 Event::Event(TString path, Int_t ev) :
  86   EventBase("AliEVE Event"),
  87
  88   fPath (path), fEventId(-1),
  89   fRunLoader (0),
  90   fESDFile   (0), fESDTree (0), fESD (0),
  91   fESDfriend (0), fESDfriendExists(kFALSE),
  92   fNewEventCommands()
  93 {
  94   Open();
  95   if (ev >= 0) GotoEvent(ev);
  96 }
  97
  98 /**************************************************************************/
  99
 100 void Event::Open()
 101 {
 102   static const Exc_t eH("Event::Open ");
 103
 104   gSystem->ExpandPathName(fPath);
 105   if(fPath[0] != '/')
 106     fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
 107
 108   Int_t runNo = -1;
 109
 110   if(fgUseRunLoader)
 111   {
 112     TString ga_path(Form("%s/galice.root", fPath.Data()));
 113     if(gSystem->AccessPathName(ga_path, kReadPermission))
 114     {
 115       if (fgAvoidExcOnOpen) {
 116         Warning(eH, "RunLoader not initialized.");
 117         goto end_run_loader;
 118       } else {
 119         throw(eH + "can not read '" + ga_path + "'.");
 120       }
 121     }
 122     fRunLoader = AliRunLoader::Open(ga_path);
 123     if(!fRunLoader)
 124       throw(eH + "failed opening ALICE run loader from '" + ga_path + "'.");
 125     {
 126       TString alice_path = fPath + "/";
 127       fRunLoader->SetDirName(alice_path);
 128     }
 129     if(fRunLoader->LoadgAlice() != 0)
 130       throw(eH + "failed loading gAlice.");
 131     if(fRunLoader->LoadHeader() != 0)
 132       throw(eH + "failed loading header.");
 133     runNo = fRunLoader->GetHeader()->GetRun();
 134   }
 135 end_run_loader:
 136
 137   if(fgUseESDTree)
 138   {
 139     TString p(Form("%s/AliESDs.root", fPath.Data()));
 140     if(gSystem->AccessPathName(p, kReadPermission))
 141     {
 142       if (fgAvoidExcOnOpen) {
 143         Warning(eH, "ESD not initialized.");
 144         goto end_esd_loader;
 145       } else {
 146         throw(eH + "can not read '" + p + "'.");
 147       }
 148     }
 149     fESDFile = new TFile(p);
 150     if(fESDFile->IsZombie()) {
 151       delete fESDFile; fESDFile = 0;
 152       throw(eH + "failed opening ALICE ESD from '" + p + "'.");
 153     }
 154
 155     fESD = new AliESD();
 156     fESDTree = (TTree*) fESDFile->Get("esdTree");
 157     if(fESDTree == 0)
 158       throw(eH + "failed getting the esdTree.");
 159     fESD->ReadFromTree(fESDTree);
 160     runNo = fESD->GetESDRun()->GetRunNumber();
 161
 162     // Check if ESDfriends exists and attach the branch
 163     p = Form("%s/AliESDfriends.root", fPath.Data());
 164     if(gSystem->AccessPathName(p, kReadPermission) == kFALSE)
 165     {
 166       fESDfriendExists = kTRUE;
 167       fESDTree->SetBranchStatus ("ESDfriend*", 1);
 168       fESDTree->SetBranchAddress("ESDfriend.", &fESDfriend);
 169     }
 170   }
 171
 172   if (runNo < 0)
 173     throw(eH + "invalid run number.");
 174
 175   {
 176     AliCDBManager* cdb = AliCDBManager::Instance();
 177     cdb->SetDefaultStorage(fgCdbUri);
 178     if (cdb->IsDefaultStorageSet() == kFALSE)
 179       throw(eH + "CDB initialization failed.");
 180     cdb->SetRun(runNo);
 181   }
 182
 183 end_esd_loader:
 184   SetName(Form("Event %d", fEventId));
 185   SetTitle(fPath);
 186 }
 187
 188 void Event::GotoEvent(Int_t event)
 189 {
 190   static const Exc_t eH("Event::GotoEvent ");
 191
 192   Int_t maxEvent = 0;
 193   if(fRunLoader)
 194     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
 195   else if(fESDTree)
 196     maxEvent = fESDTree->GetEntries() - 1;
 197   else
 198     throw(eH + "neither RunLoader nor ESD loaded.");
 199
 200   if(event < 0 || event > maxEvent)
 201     throw(eH + Form("event %d not present, available range [%d, %d].",
 202                     event, 0, maxEvent));
 203
 204   RGTopFrame::RedrawDisabler rd(gReve);
 205   gReve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
 206
 207   DestroyElements();
 208   fEventId = event;
 209   SetName(Form("Event %d", fEventId));
 210   UpdateItems();
 211
 212   if(fRunLoader) {
 213     if(fRunLoader->GetEvent(fEventId) != 0)
 214       throw(eH + "failed getting required event.");
 215   }
 216
 217   if(fESDTree) {
 218     if(fESDTree->GetEntry(fEventId) <= 0)
 219       throw(eH + "failed getting required event from ESD.");
 220
 221     if (fESDfriendExists)
 222       fESD->SetESDfriend(fESDfriend);
 223   }
 224
 225   AfterNewEventLoaded();
 226 }
 227
 228 void Event::Close()
 229 {
 230   if (fESDTree) {
 231     delete fESD;       fESD       = 0;
 232     delete fESDfriend; fESDfriend = 0;
 233
 234     delete fESDTree; fESDTree = 0;
 235     delete fESDFile; fESDFile = 0;
 236   }
 237 }
 238
 239 /**************************************************************************/
 240
 241 void Event::AfterNewEventLoaded()
 242 {
 243   TIter next(&fNewEventCommands);
 244   TObject* o;
 245   while ((o = next())) {
 246     TObjString* s = dynamic_cast<TObjString*>(o);
 247     if (s)
 248       gInterpreter->ProcessLine(s->String());
 249   }
 250 }
 251
 252 void Event::AddNewEventCommand(const Text_t* cmd)
 253 {
 254   fNewEventCommands.Add(new TObjString(cmd));
 255 }
 256
 257 /**************************************************************************/
 258 /**************************************************************************/
 259
 260 // Static convenience functions.
 261
 262 AliRunLoader* Event::AssertRunLoader()
 263 {
 264   static const Exc_t eH("Event::AssertRunLoader ");
 265
 266   if(gEvent == 0)
 267     throw(eH + "ALICE event not ready.");
 268   if(gEvent->fRunLoader == 0)
 269     throw(eH + "AliRunLoader not initialised.");
 270   return gEvent->fRunLoader;
 271 }
 272
 273 AliESD* Event::AssertESD()
 274 {
 275   static const Exc_t eH("Event::AssertESD ");
 276
 277   if(gEvent == 0)
 278     throw(eH + "ALICE event not ready.");
 279   if(gEvent->fESD == 0)
 280     throw(eH + "AliESD not initialised.");
 281   return gEvent->fESD;
 282 }
 283
 284 AliESDfriend* Event::AssertESDfriend()
 285 {
 286   static const Exc_t eH("Event::AssertESDfriend ");
 287
 288   if(gEvent == 0)
 289     throw(eH + "ALICE event not ready.");
 290   if(gEvent->fESDfriend == 0)
 291     throw(eH + "AliESDfriend not initialised.");
 292   return gEvent->fESDfriend;
 293 }
 294
 295 AliMagF* Event::AssertMagField()
 296 {
 297   if (fgMagField == 0)
 298   {
 299     if (gEvent && gEvent->fRunLoader && gEvent->fRunLoader->GetAliRun())
 300       fgMagField = gEvent->fRunLoader->GetAliRun()->Field();
 301     else
 302       fgMagField = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
 303   }
 304   return fgMagField;
 305 }
 306
 307 TGeoManager* Event::AssertGeometry()
 308 {
 309   static const Exc_t eH("Event::AssertGeometry ");
 310
 311   if (AliGeomManager::GetGeometry() == 0)
 312   {
 313     AliGeomManager::LoadGeometry();
 314     if ( ! AliGeomManager::GetGeometry())
 315     {
 316       throw(eH + "can not load geometry.");
 317     }
 318     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
 319     {
 320       ::Warning(eH, "mismatch of alignable volumes. Proceeding.");
 321       // throw(eH + "could not apply align objs.");
 322     }
 323   }
 324
 325   return AliGeomManager::GetGeometry();
 326 }