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