EVE/EveBase/AliEveEventManager.cxx

   1 // $Id$
   2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
   3
   4 /**************************************************************************
   5  * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
   6  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
   7  * full copyright notice.                                                 *
   8  **************************************************************************/
   9
  10 #include "AliEveEventManager.h"
  11 #include "AliEveMacroExecutor.h"
  12 #include <TEveManager.h>
  13
  14 #include <AliRunLoader.h>
  15 #include <AliRun.h>
  16 #include <AliESDEvent.h>
  17 #include <AliESDfriend.h>
  18 #include <AliDAQ.h>
  19 #include <AliRawEventHeaderBase.h>
  20 #include <AliRawReaderRoot.h>
  21 #include <AliRawReaderFile.h>
  22 #include <AliRawReaderDate.h>
  23 #include <AliMagFMaps.h>
  24 #include <AliCDBManager.h>
  25 #include <AliHeader.h>
  26 #include <AliGeomManager.h>
  27
  28 #include <TFile.h>
  29 #include <TTree.h>
  30 #include <TGeoManager.h>
  31 #include <TSystem.h>
  32 #include <TTimeStamp.h>
  33
  34 //==============================================================================
  35 //==============================================================================
  36 // AliEveEventManager
  37 //==============================================================================
  38
  39 //______________________________________________________________________________
  40 //
  41 // Provide interface for loading and navigating standard AliRoot data
  42 // (AliRunLoader) and ESDs.
  43 //
  44 // Missing support for raw-data. For now this is handled individually
  45 // by each sub-detector.
  46 //
  47 // Also provides interface to magnetic-field and geometry. Mostly
  48 // intended as wrappers over standard AliRoot functionality for
  49 // convenient use from visualizateion macros.
  50
  51 ClassImp(AliEveEventManager)
  52
  53 AliEveEventManager* gAliEveEvent = 0;
  54
  55 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
  56 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
  57 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
  58
  59 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
  60 TString  AliEveEventManager::fgRawFileName("raw.root");
  61 TString  AliEveEventManager::fgCdbUri("local://$ALICE_ROOT");
  62
  63 AliMagF* AliEveEventManager::fgMagField = 0;
  64
  65 void AliEveEventManager::InitInternals()
  66 {
  67   // Initialize internal members.
  68
  69   fAutoLoadTimer = new TTimer;
  70   fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
  71
  72   fExecutor = new AliEveMacroExecutor;
  73 }
  74
  75 AliEveEventManager::AliEveEventManager() :
  76   TEveEventManager(),
  77
  78   fPath      ( ), fEventId (-1),
  79   fRunLoader (0),
  80   fESDFile   (0), fESDTree (0), fESD (0),
  81   fESDfriend (0), fESDfriendExists(kFALSE),
  82   fRawReader (0),
  83   fAutoLoad  (kFALSE), fAutoLoadTime (5.),     fAutoLoadTimer(0),
  84   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
  85   fExecutor  (0),
  86   fAutoLoadTimerRunning(kFALSE)
  87 {
  88   // Default constructor.
  89
  90   InitInternals();
  91 }
  92
  93 AliEveEventManager::AliEveEventManager(TString path, Int_t ev) :
  94   TEveEventManager("AliEVE AliEveEventManager"),
  95
  96   fPath   (path), fEventId(-1),
  97   fRunLoader (0),
  98   fESDFile   (0), fESDTree (0), fESD (0),
  99   fESDfriend (0), fESDfriendExists(kFALSE),
 100   fRawReader (0),
 101   fAutoLoad  (kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
 102   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
 103   fExecutor  (0),
 104   fAutoLoadTimerRunning(kFALSE)
 105 {
 106   // Constructor with event-directory URL and event-id.
 107
 108   InitInternals();
 109
 110   Open();
 111   if (ev >= 0)
 112   {
 113     GotoEvent(ev);
 114   }
 115 }
 116
 117 AliEveEventManager::~AliEveEventManager()
 118 {
 119   // Destructor.
 120
 121   if (fIsOpen)
 122   {
 123     Close();
 124   }
 125
 126   // Somewhat unclear what to do here.
 127   // In principle should wipe event data and deregister from
 128   // TEveManager.
 129 }
 130
 131 /******************************************************************************/
 132
 133 void AliEveEventManager::SetESDFileName(const Text_t* esd)
 134 {
 135   // Set file-name for opening ESD, default "AliESDs.root".
 136
 137   if (esd) fgESDFileName = esd;
 138 }
 139
 140 void AliEveEventManager::SetRawFileName(const Text_t* raw)
 141 {
 142   // Set file-name for opening of raw-data, default "raw.root"
 143   if (raw) fgRawFileName = raw;
 144 }
 145
 146 void AliEveEventManager::SetCdbUri(const Text_t* cdb)
 147 {
 148   // Set path to CDB, default "local://$ALICE_ROOT".
 149
 150   if (cdb) fgCdbUri = cdb;
 151 }
 152
 153 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader,
 154                                            Bool_t assertEsd,
 155                                            Bool_t assertRaw)
 156 {
 157   // Set global flags that detrmine which parts of the event-data must
 158   // be present when the event is opened.
 159
 160   fgAssertRunLoader = assertRunloader;
 161   fgAssertESD = assertEsd;
 162   fgAssertRaw = assertRaw;
 163 }
 164
 165 /******************************************************************************/
 166
 167 void AliEveEventManager::Open()
 168 {
 169   // Open event-data from URL specified in fPath.
 170   // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
 171   // Warning is reported if run-loader or ESD is not found.
 172   // Global data-members fgAssertRunLoader and fgAssertESD can be set
 173   // to throw exceptions instead.
 174
 175   static const TEveException kEH("AliEveEventManager::Open ");
 176
 177   if (fExternalCtrl)
 178   {
 179     throw (kEH + "Event-loop is under external control.");
 180   }
 181   if (fIsOpen)
 182   {
 183     throw (kEH + "Event-files already opened.");
 184   }
 185
 186   gSystem->ExpandPathName(fPath);
 187   // The following magick is required for ESDriends to be loaded properly
 188   // from non-current directory.
 189   if (fPath.IsNull() || fPath == ".")
 190   {
 191     fPath = gSystem->WorkingDirectory();
 192   }
 193   else if ( ! fPath.BeginsWith("file:/"))
 194   {
 195     TUrl    url(fPath, kTRUE);
 196     TString protocol(url.GetProtocol());
 197     if (protocol == "file" && fPath[0] != '/')
 198       fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
 199   }
 200
 201   Int_t runNo = -1;
 202
 203   // Open ESD and ESDfriends
 204
 205   TString esdPath(Form("%s/%s", fPath.Data(), fgESDFileName.Data()));
 206   if ((fESDFile = TFile::Open(esdPath)))
 207   {
 208     fESD = new AliESDEvent();
 209     fESDTree = (TTree*) fESDFile->Get("esdTree");
 210     if (fESDTree != 0)
 211     {
 212       // Check if ESDfriends exists and attach the branch.
 213       // We use TFile::Open() instead of gSystem->AccessPathName
 214       // as it seems to work better when attachine alieve to a
 215       // running reconstruction process with auto-save on.
 216       // There was also a problem with TTree::Refresh() - it didn't
 217       // save the friend branch on a separate file, fixed in 5.22.2 -
 218       // so we might want to try the old way again soon.
 219       TString p(Form("%s/AliESDfriends.root", fPath.Data()));
 220       TFile *esdFriendFile = TFile::Open(p);
 221       if (esdFriendFile)
 222       {
 223         if (!esdFriendFile->IsZombie())
 224         {
 225           esdFriendFile->Close();
 226           fESDfriendExists = kTRUE;
 227           fESDTree->SetBranchStatus ("ESDfriend*", 1);
 228         }
 229         delete esdFriendFile;
 230       }
 231
 232       fESD->ReadFromTree(fESDTree);
 233       if (fESDfriendExists)
 234       {
 235         fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
 236         Info(kEH, "found and attached ESD friend.");
 237       }
 238       else
 239       {
 240         Warning(kEH, "ESDfriend not found.");
 241       }
 242
 243       if (fESDTree->GetEntry(0) <= 0)
 244       {
 245         delete fESDFile; fESDFile = 0;
 246         delete fESD; fESD = 0;
 247         Warning(kEH, "failed getting the first entry from esdTree.");
 248       }
 249       else
 250       {
 251         if (runNo < 0)
 252           runNo = fESD->GetESDRun()->GetRunNumber();
 253       }
 254     }
 255     else // esdtree == 0
 256     {
 257       delete fESDFile; fESDFile = 0;
 258       delete fESD; fESD = 0;
 259       Warning(kEH, "failed getting the esdTree.");
 260     }
 261   }
 262   else // esd not readable
 263   {
 264     Warning(kEH, "can not read ESD file '%s'.", esdPath.Data());
 265   }
 266   if (fESDTree == 0)
 267   {
 268     if (fgAssertESD)
 269     {
 270       throw (kEH + "ESD not initialized. Its precence was requested.");
 271     } else {
 272       Warning(kEH, "ESD not initialized.");
 273     }
 274   }
 275
 276   // Open RunLoader from galice.root
 277
 278   TString gaPath(Form("%s/galice.root", fPath.Data()));
 279   // If i use open directly, we get fatal.
 280   // Is AccessPathName check ok for xrootd / alien? Yes, not for http.
 281   if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
 282   {
 283     fRunLoader = AliRunLoader::Open(gaPath);
 284     if (fRunLoader)
 285     {
 286       TString alicePath = fPath + "/";
 287       fRunLoader->SetDirName(alicePath);
 288
 289       if (fRunLoader->LoadgAlice() != 0)
 290         Warning(kEH, "failed loading gAlice via run-loader.");
 291
 292       if (fRunLoader->LoadHeader() == 0)
 293       {
 294         if (runNo < 0)
 295           runNo = fRunLoader->GetHeader()->GetRun();
 296       }
 297       else
 298       {
 299         Warning(kEH, "failed loading run-loader's header.");
 300         delete fRunLoader;
 301         fRunLoader = 0;
 302       }
 303     }
 304     else // run-loader open failed
 305     {
 306       Warning(kEH, "failed opening ALICE run-loader from '%s'.", gaPath.Data());
 307     }
 308   }
 309   else // galice not readable
 310   {
 311     Warning(kEH, "can not read '%s'.", gaPath.Data());
 312   }
 313   if (fRunLoader == 0)
 314   {
 315     if (fgAssertRunLoader)
 316       throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
 317     else
 318       Warning(kEH, "Bootstraping of run-loader failed.");
 319   }
 320
 321   // Open raw-data file
 322
 323   TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
 324   // If i use open directly, raw-reader reports an error but i have
 325   // no way to detect it.
 326   // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
 327   AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
 328   if (fgAssertRaw == kFALSE)
 329   {
 330     AliLog::SetGlobalLogLevel(AliLog::kFatal);
 331   }
 332   if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
 333   {
 334     fRawReader = AliRawReader::Create(rawPath);
 335   }
 336   else
 337   {
 338     fRawReader = AliRawReader::Create(fgRawFileName);
 339   }
 340   if (fgAssertRaw == kFALSE)
 341   {
 342     AliLog::SetGlobalLogLevel(oldLogLevel);
 343   }
 344
 345   if (fRawReader == 0)
 346   {
 347     if (fgAssertRaw)
 348     {
 349       throw (kEH + "raw-data not initialized. Its precence was requested.");
 350     } else {
 351       Warning(kEH, "raw-data not initialized.");
 352     }
 353   }
 354
 355   if (runNo < 0)
 356   {
 357     if (fRawReader)
 358     {
 359       fRawReader->NextEvent();
 360       runNo = fRawReader->GetRunNumber();
 361       Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
 362       fRawReader->RewindEvents();
 363     } else {
 364       throw (kEH + "unknown run number.");
 365     }
 366   }
 367
 368   {
 369     AliCDBManager* cdb = AliCDBManager::Instance();
 370     cdb->SetDefaultStorage(fgCdbUri);
 371     if (cdb->IsDefaultStorageSet() == kFALSE)
 372       throw (kEH + "CDB initialization failed.");
 373     cdb->SetRun(runNo);
 374   }
 375
 376   SetName(Form("Event %d", fEventId));
 377   SetTitle(fPath);
 378   fIsOpen = kTRUE;
 379 }
 380
 381 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd)
 382 {
 383   // Set an event from an external source
 384   // The method is used in the online visualisation
 385
 386   static const TEveException kEH("AliEveEventManager::SetEvent ");
 387
 388   if (fIsOpen)
 389   {
 390     Warning(kEH, "Event-files were open. Closing and switching to external control.");
 391     Close();
 392   }
 393
 394   fRunLoader = runLoader;
 395   fRawReader = rawReader;
 396   fESD       = esd;
 397
 398   fEventId++;
 399   fHasEvent     = kTRUE;
 400   fExternalCtrl = kTRUE;
 401
 402   SetTitle("Online event in memory");
 403   SetName ("Online Event");
 404
 405   ElementChanged();
 406   AfterNewEventLoaded();
 407
 408   if (fAutoLoad) StartAutoLoadTimer();
 409 }
 410
 411 Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
 412 {
 413   // Returns maximum available event id.
 414   // If under external control or event is not opened -1 is returned.
 415   // If raw-data is the only data-source this can not be known
 416   // and 10,000,000 is returned.
 417   // If neither data-source is initialised an exception is thrown.
 418   // If refresh_esd is true and ESD is the primary event-data source
 419   // its header is re-read from disk.
 420
 421   static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
 422
 423   if (fExternalCtrl || fIsOpen == kFALSE)
 424   {
 425     return -1;
 426   }
 427
 428   if (fESDTree)
 429   {
 430     // Refresh crashes with root-5.21.1-alice.
 431     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
 432     // when we move to a newer root.
 433     // if (refreshESD)
 434     //   fESDTree->Refresh();
 435     return fESDTree->GetEntries() - 1;
 436   }
 437   else if (fRunLoader)
 438   {
 439     return fRunLoader->GetNumberOfEvents() - 1;
 440   }
 441   else if (fRawReader)
 442   {
 443     Int_t n = fRawReader->GetNumberOfEvents() - 1;
 444     return n > -1 ? n : 10000000;
 445   }
 446   else
 447   {
 448     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
 449   }
 450 }
 451
 452 void AliEveEventManager::GotoEvent(Int_t event)
 453 {
 454   // Load data for specified event.
 455   // If event is out of range an exception is thrown and old state
 456   // is preserved.
 457   // After successful loading of event, the virtual function
 458   // AfterNewEventLoaded() is called. This executes commands that
 459   // were registered via TEveEventManager::AddNewEventCommand().
 460   //
 461   // If event is negative, it is subtracted from the number of
 462   // available events, thus passing -1 will load the last event.
 463   // This is not supported when raw-data is the only data-source
 464   // as the number of events is not known.
 465
 466   static const TEveException kEH("AliEveEventManager::GotoEvent ");
 467
 468   if (fAutoLoadTimerRunning)
 469   {
 470     throw (kEH + "Event auto-load timer is running.");
 471   }
 472   if (fExternalCtrl)
 473   {
 474     throw (kEH + "Event-loop is under external control.");
 475   }
 476   else if (!fIsOpen)
 477   {
 478     throw (kEH + "Event-files not opened.");
 479   }
 480
 481   fHasEvent = kFALSE;
 482
 483   Int_t maxEvent = 0;
 484   if (fESDTree)
 485   {
 486     // Refresh crashes with root-5.21.1-alice.
 487     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
 488     // when we move to a newer root.
 489     // fESDTree->Refresh();
 490     maxEvent = fESDTree->GetEntries() - 1;
 491     if (event < 0)
 492       event = fESDTree->GetEntries() + event;
 493   }
 494   else if (fRunLoader)
 495   {
 496     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
 497     if (event < 0)
 498       event = fRunLoader->GetNumberOfEvents() + event;
 499   }
 500   else if (fRawReader)
 501   {
 502     maxEvent = fRawReader->GetNumberOfEvents() - 1;
 503     if (maxEvent < 0)
 504     {
 505       maxEvent = 10000000;
 506       if (event < 0) {
 507         Error(kEH, "current raw-data source does not support direct event access.");
 508         return;
 509       }
 510       Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
 511     }
 512     else
 513     {
 514       if (event < 0)
 515         event = fRawReader->GetNumberOfEvents() + event;
 516     }
 517   }
 518   else
 519   {
 520     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
 521   }
 522   if (event < 0 || event > maxEvent)
 523   {
 524     throw (kEH + Form("event %d not present, available range [%d, %d].",
 525                       event, 0, maxEvent));
 526   }
 527
 528   TEveManager::TRedrawDisabler rd(gEve);
 529   gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
 530
 531   // !!! MT this is somewhat brutal; at least optionally, one could be
 532   // a bit gentler, checking for objs owning their external refs and having
 533   // additinal parents.
 534   DestroyElements();
 535
 536   if (fESDTree) {
 537     if (fESDTree->GetEntry(event) <= 0)
 538       throw (kEH + "failed getting required event from ESD.");
 539
 540     if (fESDfriendExists)
 541       fESD->SetESDfriend(fESDfriend);
 542   }
 543
 544   if (fRunLoader) {
 545     if (fRunLoader->GetEvent(event) != 0)
 546       throw (kEH + "failed getting required event.");
 547   }
 548
 549   if (fRawReader)
 550   {
 551     // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
 552     if (fRawReader->GotoEvent(event) == kFALSE)
 553     {
 554       // Use fallback method - iteration with NextEvent().
 555       Int_t rawEv = fEventId;
 556       if (event < rawEv)
 557       {
 558         fRawReader->RewindEvents();
 559         rawEv = -1;
 560       }
 561
 562       while (rawEv < event)
 563       {
 564         if ( ! fRawReader->NextEvent())
 565         {
 566           fRawReader->RewindEvents();
 567           fEventId = -1;
 568           throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
 569         }
 570         ++rawEv;
 571       }
 572       Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
 573     }
 574   }
 575
 576   fHasEvent = kTRUE;
 577   fEventId  = event;
 578   SetName(Form("Event %d", fEventId));
 579   ElementChanged();
 580
 581   AfterNewEventLoaded();
 582 }
 583
 584 void AliEveEventManager::NextEvent()
 585 {
 586   // Loads next event.
 587   // Does magick needed for online display when under external event control.
 588
 589   static const TEveException kEH("AliEveEventManager::NextEvent ");
 590
 591   if (fAutoLoadTimerRunning)
 592   {
 593     throw (kEH + "Event auto-load timer is running.");
 594   }
 595
 596   if (fExternalCtrl)
 597   {
 598     // !!! This should really go somewhere else. It is done in GotoEvent(),
 599     // so here we should do it in SetEvent().
 600     DestroyElements();
 601
 602     gSystem->ExitLoop();
 603   }
 604   else
 605   {
 606     if (fEventId < GetMaxEventId(kTRUE))
 607       GotoEvent(fEventId + 1);
 608     else
 609       GotoEvent(0);
 610   }
 611 }
 612
 613 void AliEveEventManager::PrevEvent()
 614 {
 615   // Loads previous event.
 616
 617   static const TEveException kEH("AliEveEventManager::PrevEvent ");
 618
 619   if (fAutoLoadTimerRunning)
 620   {
 621     throw (kEH + "Event auto-load timer is running.");
 622   }
 623   if (fExternalCtrl)
 624   {
 625     throw (kEH + "Event-loop is under external control.");
 626   }
 627
 628   GotoEvent(fEventId - 1);
 629 }
 630
 631 void AliEveEventManager::Close()
 632 {
 633   // Close the event data-files and delete ESD, ESDfriend, run-loader
 634   // and raw-reader.
 635
 636   static const TEveException kEH("AliEveEventManager::Close ");
 637
 638   if (!fIsOpen)
 639   {
 640     throw (kEH + "Event-files not opened.");
 641   }
 642
 643   if (fAutoLoadTimerRunning)
 644     StopAutoLoadTimer();
 645
 646   if (fESDTree) {
 647     delete fESD;       fESD       = 0;
 648     delete fESDfriend; fESDfriend = 0;
 649     fESDfriendExists = kFALSE;
 650
 651     delete fESDTree;   fESDTree = 0;
 652     delete fESDFile;   fESDFile = 0;
 653   }
 654
 655   if (fRunLoader) {
 656     delete fRunLoader; fRunLoader = 0;
 657   }
 658
 659   if (fRawReader) {
 660     delete fRawReader; fRawReader = 0;
 661   }
 662
 663   fEventId  = -1;
 664   fIsOpen   = kFALSE;
 665   fHasEvent = kFALSE;
 666 }
 667
 668
 669 //------------------------------------------------------------------------------
 670 // Static convenience functions, mainly used from macros.
 671 //------------------------------------------------------------------------------
 672
 673 Bool_t AliEveEventManager::HasRunLoader()
 674 {
 675   // Check if AliRunLoader is initialized.
 676
 677   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRunLoader;
 678 }
 679
 680 Bool_t AliEveEventManager::HasESD()
 681 {
 682   // Check if AliESDEvent is initialized.
 683
 684   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESD;
 685 }
 686
 687 Bool_t AliEveEventManager::HasESDfriend()
 688 {
 689   // Check if AliESDfriend is initialized.
 690
 691   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESDfriend;
 692 }
 693
 694 Bool_t AliEveEventManager::HasRawReader()
 695 {
 696   // Check if raw-reader is initialized.
 697
 698   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRawReader;
 699 }
 700
 701 AliRunLoader* AliEveEventManager::AssertRunLoader()
 702 {
 703   // Make sure AliRunLoader is initialized and return it.
 704   // Throws exception in case run-loader is not available.
 705   // Static utility for macros.
 706
 707   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
 708
 709   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
 710     throw (kEH + "ALICE event not ready.");
 711   if (gAliEveEvent->fRunLoader == 0)
 712     throw (kEH + "AliRunLoader not initialised.");
 713   return gAliEveEvent->fRunLoader;
 714 }
 715
 716 AliESDEvent* AliEveEventManager::AssertESD()
 717 {
 718   // Make sure AliESDEvent is initialized and return it.
 719   // Throws exception in case ESD is not available.
 720   // Static utility for macros.
 721
 722   static const TEveException kEH("AliEveEventManager::AssertESD ");
 723
 724   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
 725     throw (kEH + "ALICE event not ready.");
 726   if (gAliEveEvent->fESD == 0)
 727     throw (kEH + "AliESD not initialised.");
 728   return gAliEveEvent->fESD;
 729 }
 730
 731 AliESDfriend* AliEveEventManager::AssertESDfriend()
 732 {
 733   // Make sure AliESDfriend is initialized and return it.
 734   // Throws exception in case ESDfriend-loader is not available.
 735   // Static utility for macros.
 736
 737   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
 738
 739   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
 740     throw (kEH + "ALICE event not ready.");
 741   if (gAliEveEvent->fESDfriend == 0)
 742     throw (kEH + "AliESDfriend not initialised.");
 743   return gAliEveEvent->fESDfriend;
 744 }
 745
 746 AliRawReader* AliEveEventManager::AssertRawReader()
 747 {
 748   // Make sure raw-reader is initialized and return it.
 749
 750   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
 751
 752   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
 753     throw (kEH + "ALICE event not ready.");
 754   if (gAliEveEvent->fRawReader == 0)
 755     throw (kEH + "RawReader not ready.");
 756
 757   return gAliEveEvent->fRawReader;
 758 }
 759
 760 AliMagF* AliEveEventManager::AssertMagField()
 761 {
 762   // Make sure AliMagF is initialized and returns it.
 763   // Run-loader must be initialized to get the correct magnetic field!
 764   // Throws exception in case magnetic field is not available.
 765   // Static utility for macros.
 766
 767   // !!!! This should be fixed ... get field also in some other way,
 768   // not only via run-loader.
 769
 770   if (fgMagField == 0)
 771   {
 772     if (gAliEveEvent && gAliEveEvent->fRunLoader && gAliEveEvent->fRunLoader->GetAliRun())
 773       fgMagField = gAliEveEvent->fRunLoader->GetAliRun()->Field();
 774     else
 775       fgMagField = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
 776   }
 777   return fgMagField;
 778 }
 779
 780 TGeoManager* AliEveEventManager::AssertGeometry()
 781 {
 782   // Make sure AliGeomManager is initialized and returns the
 783   // corresponding TGeoManger.
 784   // gGeoManager is set to the return value.
 785   // Throws exception if geometry can not be loaded or if it is not
 786   // available and the TGeoManager is locked.
 787   // Static utility for macros.
 788
 789   static const TEveException kEH("AliEveEventManager::AssertGeometry ");
 790
 791   if (AliGeomManager::GetGeometry() == 0)
 792   {
 793     if (TGeoManager::IsLocked())
 794       throw (kEH + "geometry is not loaded but TGeoManager is locked.");
 795
 796     gGeoManager = 0;
 797     AliGeomManager::LoadGeometry();
 798     if ( ! AliGeomManager::GetGeometry())
 799     {
 800       throw (kEH + "can not load geometry.");
 801     }
 802     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
 803     {
 804       ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
 805       // throw (kEH + "could not apply align objs.");
 806     }
 807     AliGeomManager::GetGeometry()->DefaultColors();
 808   }
 809
 810   gGeoManager = AliGeomManager::GetGeometry();
 811   return gGeoManager;
 812 }
 813
 814
 815 //------------------------------------------------------------------------------
 816 // Autoloading of events
 817 //------------------------------------------------------------------------------
 818
 819 void AliEveEventManager::SetAutoLoadTime(Float_t time)
 820 {
 821   // Set the auto-load time in seconds
 822
 823   fAutoLoadTime = time;
 824 }
 825
 826 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
 827 {
 828   // Set the automatic event loading mode
 829
 830   static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
 831
 832   if (fAutoLoad == autoLoad)
 833   {
 834     Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
 835     return;
 836   }
 837
 838   fAutoLoad = autoLoad;
 839   if (fAutoLoad)
 840   {
 841     StartAutoLoadTimer();
 842   }
 843   else
 844   {
 845     StopAutoLoadTimer();
 846   }
 847 }
 848
 849 void AliEveEventManager::StartAutoLoadTimer()
 850 {
 851   // Start the auto-load timer.
 852
 853   fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
 854   fAutoLoadTimer->Reset();
 855   fAutoLoadTimer->TurnOn();
 856   fAutoLoadTimerRunning = kTRUE;
 857 }
 858
 859 void AliEveEventManager::StopAutoLoadTimer()
 860 {
 861   // Stop the auto-load timer.
 862
 863   fAutoLoadTimerRunning = kFALSE;
 864   fAutoLoadTimer->TurnOff();
 865 }
 866
 867 void AliEveEventManager::AutoLoadNextEvent()
 868 {
 869   // Called from auto-load timer, so it has to be public.
 870   // Do NOT call it directly.
 871
 872   static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
 873
 874   if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
 875   {
 876     Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
 877     return;
 878   }
 879
 880   StopAutoLoadTimer();
 881   NextEvent();
 882   if (fAutoLoad && !fExternalCtrl)
 883     StartAutoLoadTimer();
 884 }
 885
 886
 887 //------------------------------------------------------------------------------
 888 // Post event-loading functions
 889 //------------------------------------------------------------------------------
 890
 891 void AliEveEventManager::AfterNewEventLoaded()
 892 {
 893   // Execute registered macros and commands.
 894   // At the end emit NewEventLoaded signal.
 895   //
 896   // Virtual from TEveEventManager.
 897
 898   if (fExecutor)
 899     fExecutor->ExecMacros();
 900
 901   TEveEventManager::AfterNewEventLoaded();
 902
 903   NewEventLoaded();
 904 }
 905
 906 void AliEveEventManager::NewEventLoaded()
 907 {
 908   // Emit NewEventLoaded signal.
 909
 910   Emit("NewEventLoaded()");
 911 }
 912
 913
 914 //------------------------------------------------------------------------------
 915 // Event info dumpers
 916 //------------------------------------------------------------------------------
 917
 918 TString AliEveEventManager::GetEventInfoHorizontal() const
 919 {
 920   // Dumps the event-header contents in vertical formatting.
 921
 922   TString rawInfo, esdInfo;
 923
 924   if (!fRawReader)
 925   {
 926     rawInfo = "No raw-data event info is available!\n";
 927   }
 928   else
 929   {
 930     const UInt_t* attr = fRawReader->GetAttributes();
 931     TTimeStamp ts(fRawReader->GetTimestamp());
 932     rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
 933                  "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
 934                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
 935                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
 936                  fRawReader->GetClassMask(),
 937                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
 938                  attr[0],attr[1],attr[2], ts.AsString("s"));
 939   }
 940
 941   if (!fESD)
 942   {
 943     esdInfo = "No ESD event info is available!";
 944   }
 945   else
 946   {
 947     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
 948     TString firedtrclasses = fESD->GetFiredTriggerClasses();
 949     TTimeStamp ts(fESD->GetTimeStamp());
 950     esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
 951                  "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s",
 952                  fESD->GetRunNumber(),
 953                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
 954                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
 955                  acttrclasses.Data(),
 956                  fESD->GetTriggerMask(),firedtrclasses.Data(),
 957                  fESD->GetEventNumberInFile(), ts.AsString("s"));
 958   }
 959
 960   return rawInfo + esdInfo;
 961 }
 962
 963 TString AliEveEventManager::GetEventInfoVertical() const
 964 {
 965   // Dumps the event-header contents in vertical formatting.
 966
 967   TString rawInfo, esdInfo;
 968
 969   if (!fRawReader)
 970   {
 971     rawInfo = "No raw-data event info is available!\n";
 972   }
 973   else
 974   {
 975     const UInt_t* attr = fRawReader->GetAttributes();
 976     rawInfo.Form("Raw-data event info:\nRun#: %d\nEvent type: %d (%s)\nPeriod: %x\nOrbit: %x   BC: %x\nTrigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x\nTimestamp: %x\n",
 977                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
 978                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
 979                  fRawReader->GetClassMask(),
 980                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
 981                  attr[0],attr[1],attr[2],
 982                  fRawReader->GetTimestamp());
 983   }
 984
 985   if (!fESD)
 986   {
 987     esdInfo = "No ESD event info is available!\n";
 988   }
 989   else
 990   {
 991     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
 992     TString firedtrclasses = fESD->GetFiredTriggerClasses();
 993     esdInfo.Form("ESD event info:\nRun#: %d\nActive trigger classes: %s\nEvent type: %d (%s)\nPeriod: %x\nOrbit: %x   BC: %x\nTrigger: %llx (%s)\nEvent# in file:%d\nTimestamp: %x\n",
 994                  fESD->GetRunNumber(),
 995                  acttrclasses.Data(),
 996                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
 997                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
 998                  fESD->GetTriggerMask(),firedtrclasses.Data(),
 999                  fESD->GetEventNumberInFile(),
1000                  fESD->GetTimeStamp());
1001   }
1002
1003   return rawInfo + "\n" + esdInfo;
1004 }
1005