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 "AliEveEventSelector.h"
  12 #include "AliEveMacroExecutor.h"
  13 #include <TEveManager.h>
  14 #include <TEveViewer.h>
  15
  16 #include <AliRunLoader.h>
  17 #include <AliRun.h>
  18 #include <AliESDRun.h>
  19 #include <AliESDEvent.h>
  20 #include <AliESDfriend.h>
  21 #include <AliAODEvent.h>
  22
  23 #include <AliDAQ.h>
  24 #include <AliRawEventHeaderBase.h>
  25 #include <AliRawReaderRoot.h>
  26 #include <AliRawReaderFile.h>
  27 #include <AliRawReaderDate.h>
  28 #include <AliMagF.h>
  29 #include <AliCDBManager.h>
  30 #include <AliCDBStorage.h>
  31 #include <AliGRPObject.h>
  32 #include <AliHeader.h>
  33 #include <AliGeomManager.h>
  34 #include <AliGRPManager.h>
  35 #include <AliSysInfo.h>
  36
  37 #include <TFile.h>
  38 #include <TTree.h>
  39 #include <TGeoManager.h>
  40 #include <TGeoGlobalMagField.h>
  41 #include <TSystem.h>
  42 #include <TTimeStamp.h>
  43 #include <TPRegexp.h>
  44 #include <TError.h>
  45 #include <TEnv.h>
  46
  47 //==============================================================================
  48 //==============================================================================
  49 // AliEveEventManager
  50 //==============================================================================
  51
  52 //______________________________________________________________________________
  53 //
  54 // Provides interface for loading and navigating standard AliRoot data
  55 // (AliRunLoader), ESD, AOD and RAW.
  56 //
  57 // ESDfriend is attached automatically, if the file is found.
  58 //
  59 // AODfriends are not attached automatically as there are several
  60 // possible files involved. To have a specific AODfriend attached, call
  61 // static method
  62 //   AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
  63 // before initializing the event-manager.
  64 //
  65 // Also provides interface to magnetic-field and geometry. Mostly
  66 // intended as wrappers over standard AliRoot functionality for
  67 // convenient use from visualizateion macros.
  68 //
  69 // There can be a single main event-manger, it is stored in private
  70 // data member fgMaster and can be accessed via static member function
  71 // GetMaster().
  72 //
  73 // For event overlaying and embedding one can instantiate additional
  74 // event-managers via static method AddDependentManager(const TString& path).
  75 // This interface is under development.
  76
  77 ClassImp(AliEveEventManager)
  78
  79 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
  80 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
  81 Bool_t AliEveEventManager::fgAssertAOD       = kFALSE;
  82 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
  83
  84 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
  85 TString  AliEveEventManager::fgAODFileName("AliAOD.root");
  86 TString  AliEveEventManager::fgRawFileName("raw.root");
  87 TString  AliEveEventManager::fgCdbUri;
  88
  89 TList*   AliEveEventManager::fgAODfriends = 0;
  90
  91 Bool_t        AliEveEventManager::fgGRPLoaded    = kFALSE;
  92 AliMagF*      AliEveEventManager::fgMagField     = 0;
  93 Bool_t        AliEveEventManager::fgUniformField = kFALSE;
  94
  95 AliEveEventManager* AliEveEventManager::fgMaster  = 0;
  96 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
  97
  98 void AliEveEventManager::InitInternals()
  99 {
 100   // Initialize internal members.
 101
 102   static const TEveException kEH("AliEveEventManager::InitInternals ");
 103
 104   if (fgCurrent != 0)
 105   {
 106     throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
 107   }
 108
 109   if (fgMaster == 0)
 110   {
 111     fgMaster = this;
 112   }
 113
 114   fgCurrent = this;
 115
 116   fAutoLoadTimer = new TTimer;
 117   fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
 118
 119   fExecutor = new AliEveMacroExecutor;
 120
 121   fTransients = new TEveElementList("Transients", "Transient per-event elements.");
 122   fTransients->IncDenyDestroy();
 123   gEve->AddToListTree(fTransients, kFALSE);
 124
 125   fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
 126   fTransientLists->IncDenyDestroy();
 127   gEve->AddToListTree(fTransientLists, kFALSE);
 128
 129   fPEventSelector = new AliEveEventSelector(this);
 130 }
 131
 132 AliEveEventManager::AliEveEventManager(const TString& name) :
 133   TEveEventManager(name),
 134
 135   fPath      ( ), fEventId (-1),
 136   fRunLoader (0),
 137   fESDFile   (0), fESDTree (0), fESD (0),
 138   fESDfriend (0), fESDfriendExists(kFALSE),
 139   fAODFile   (0), fAODTree (0), fAOD (0),
 140   fRawReader (0),
 141   fAutoLoad  (kFALSE), fAutoLoadTime (5.),     fAutoLoadTimer(0),
 142   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
 143   fExecutor    (0), fTransients(0), fTransientLists(0),
 144   fPEventSelector(0),
 145   fSubManagers (0),
 146   fAutoLoadTimerRunning(kFALSE)
 147 {
 148   // Default constructor.
 149
 150   InitInternals();
 151 }
 152
 153 AliEveEventManager::AliEveEventManager(const TString& name, const TString& path, Int_t ev) :
 154   TEveEventManager(name, path),
 155
 156   fPath   (path), fEventId(-1),
 157   fRunLoader (0),
 158   fESDFile   (0), fESDTree (0), fESD (0),
 159   fESDfriend (0), fESDfriendExists(kFALSE),
 160   fAODFile   (0), fAODTree (0), fAOD (0),
 161   fRawReader (0),
 162   fAutoLoad  (kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
 163   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
 164   fExecutor    (0), fTransients(0), fTransientLists(0),
 165   fPEventSelector(0),
 166   fSubManagers (0),
 167   fAutoLoadTimerRunning(kFALSE)
 168 {
 169   // Constructor with event-directory URL and event-id.
 170
 171   InitInternals();
 172
 173   Open();
 174   if (ev >= 0)
 175   {
 176     GotoEvent(ev);
 177   }
 178 }
 179
 180 AliEveEventManager::~AliEveEventManager()
 181 {
 182   // Destructor.
 183
 184   delete fSubManagers;
 185
 186   if (fIsOpen)
 187   {
 188     Close();
 189   }
 190
 191   fTransients->DecDenyDestroy();
 192   fTransients->Destroy();
 193
 194   fTransientLists->DecDenyDestroy();
 195   fTransientLists->Destroy();
 196 }
 197
 198 /******************************************************************************/
 199
 200 void AliEveEventManager::SetESDFileName(const TString& esd)
 201 {
 202   // Set file-name for opening ESD, default "AliESDs.root".
 203
 204   if ( ! esd.IsNull()) fgESDFileName = esd;
 205 }
 206
 207 void AliEveEventManager::SetAODFileName(const TString& aod)
 208 {
 209   // Set file-name for opening AOD, default "AliAOD.root".
 210
 211   if ( ! aod.IsNull()) fgAODFileName = aod;
 212 }
 213
 214 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
 215 {
 216   // Add new AOD friend file-name to be attached when opening AOD.
 217   // This should include '.root', as in 'AliAOD.VertexingHF.root'.
 218
 219   if (fgAODfriends == 0)
 220   {
 221     fgAODfriends = new TList;
 222     fgAODfriends->SetOwner(kTRUE);
 223   }
 224   if (fgAODfriends->FindObject(friendFileName) == 0)
 225   {
 226     fgAODfriends->Add(new TObjString(friendFileName));
 227   }
 228 }
 229
 230 void AliEveEventManager::SetRawFileName(const TString& raw)
 231 {
 232   // Set file-name for opening of raw-data, default "raw.root"
 233   if ( ! raw.IsNull()) fgRawFileName = raw;
 234 }
 235
 236 void AliEveEventManager::SetCdbUri(const TString& cdb)
 237 {
 238   // Set path to CDB, there is no default.
 239
 240   if ( ! cdb.IsNull()) fgCdbUri = cdb;
 241 }
 242
 243 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
 244                                            Bool_t assertAod, Bool_t assertRaw)
 245 {
 246   // Set global flags that detrmine which parts of the event-data must
 247   // be present when the event is opened.
 248
 249   fgAssertRunLoader = assertRunloader;
 250   fgAssertESD = assertEsd;
 251   fgAssertAOD = assertAod;
 252   fgAssertRaw = assertRaw;
 253 }
 254
 255 /******************************************************************************/
 256
 257 void AliEveEventManager::Open()
 258 {
 259   // Open event-data from URL specified in fPath.
 260   // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
 261   // Warning is reported if run-loader or ESD is not found.
 262   // Global data-members fgAssertRunLoader and fgAssertESD can be set
 263   // to throw exceptions instead.
 264
 265   static const TEveException kEH("AliEveEventManager::Open ");
 266
 267   if (fExternalCtrl)
 268   {
 269     throw (kEH + "Event-loop is under external control.");
 270   }
 271   if (fIsOpen)
 272   {
 273     throw (kEH + "Event-files already opened.");
 274   }
 275
 276   gSystem->ExpandPathName(fPath);
 277   // The following magick is required for ESDfriends to be loaded properly
 278   // from non-current directory.
 279   if (fPath.IsNull() || fPath == ".")
 280   {
 281     fPath = gSystem->WorkingDirectory();
 282   }
 283   else if ( ! fPath.BeginsWith("file:/"))
 284   {
 285     TUrl    url(fPath, kTRUE);
 286     TString protocol(url.GetProtocol());
 287     if (protocol == "file" && fPath[0] != '/')
 288       fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
 289   }
 290
 291   Int_t runNo = -1;
 292
 293   // Open ESD and ESDfriends
 294
 295   TString esdPath(Form("%s/%s", fPath.Data(), fgESDFileName.Data()));
 296   if ((fESDFile = TFile::Open(esdPath)))
 297   {
 298     fESD = new AliESDEvent();
 299     fESDTree = (TTree*) fESDFile->Get("esdTree");
 300     if (fESDTree != 0)
 301     {
 302       // Check if ESDfriends exists and attach the branch.
 303       // We use TFile::Open() instead of gSystem->AccessPathName
 304       // as it seems to work better when attachine alieve to a
 305       // running reconstruction process with auto-save on.
 306       // There was also a problem with TTree::Refresh() - it didn't
 307       // save the friend branch on a separate file, fixed in 5.22.2 -
 308       // so we might want to try the old way again soon.
 309       TString p(Form("%s/AliESDfriends.root", fPath.Data()));
 310       TFile *esdFriendFile = TFile::Open(p);
 311       if (esdFriendFile)
 312       {
 313         if (!esdFriendFile->IsZombie())
 314         {
 315           esdFriendFile->Close();
 316           fESDfriendExists = kTRUE;
 317           fESDTree->SetBranchStatus ("ESDfriend*", 1);
 318         }
 319         delete esdFriendFile;
 320       }
 321
 322       fESD->ReadFromTree(fESDTree);
 323       if (fESDfriendExists)
 324       {
 325         fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
 326         Info(kEH, "found and attached ESD friend.");
 327       }
 328       else
 329       {
 330         Warning(kEH, "ESDfriend not found.");
 331       }
 332
 333       if (fESDTree->GetEntry(0) <= 0)
 334       {
 335         delete fESDFile; fESDFile = 0;
 336         delete fESD; fESD = 0;
 337         Warning(kEH, "failed getting the first entry from esdTree.");
 338       }
 339       else
 340       {
 341         if (runNo < 0)
 342           runNo = fESD->GetESDRun()->GetRunNumber();
 343       }
 344     }
 345     else // esdtree == 0
 346     {
 347       delete fESDFile; fESDFile = 0;
 348       delete fESD; fESD = 0;
 349       Warning(kEH, "failed getting the esdTree.");
 350     }
 351   }
 352   else // esd not readable
 353   {
 354     Warning(kEH, "can not read ESD file '%s'.", esdPath.Data());
 355   }
 356   if (fESDTree == 0)
 357   {
 358     if (fgAssertESD)
 359     {
 360       throw (kEH + "ESD not initialized. Its precence was requested.");
 361     } else {
 362       Warning(kEH, "ESD not initialized.");
 363     }
 364   }
 365
 366   // Open AOD and registered friends
 367
 368   TString aodPath(Form("%s/%s", fPath.Data(), fgAODFileName.Data()));
 369   if ((fAODFile = TFile::Open(aodPath)))
 370   {
 371     fAOD = new AliAODEvent();
 372     fAODTree = (TTree*) fAODFile->Get("aodTree");
 373     if (fAODTree != 0)
 374     {
 375       // Check if AODfriends exist and attach them.
 376       TIter       friends(fgAODfriends);
 377       TObjString *name;
 378       while ((name = (TObjString*) friends()) != 0)
 379       {
 380         TString p(Form("%s/%s", fPath.Data(), name->GetName()));
 381         if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
 382         {
 383           fAODTree->AddFriend("aodTree", name->GetName());
 384         }
 385       }
 386
 387       fAOD->ReadFromTree(fAODTree);
 388
 389       if (fAODTree->GetEntry(0) <= 0)
 390       {
 391         delete fAODFile; fAODFile = 0;
 392         delete fAOD;     fAOD     = 0;
 393         Warning(kEH, "failed getting the first entry from addTree.");
 394       }
 395       else
 396       {
 397         if (runNo < 0)
 398           runNo = fAOD->GetRunNumber();
 399       }
 400     }
 401     else // aodtree == 0
 402     {
 403       delete fAODFile; fAODFile = 0;
 404       delete fAOD;     fAOD     = 0;
 405       Warning(kEH, "failed getting the aodTree.");
 406     }
 407   }
 408   else // aod not readable
 409   {
 410     Warning(kEH, "can not read AOD file '%s'.", aodPath.Data());
 411   }
 412   if (fAODTree == 0)
 413   {
 414     if (fgAssertAOD)
 415     {
 416       throw (kEH + "AOD not initialized. Its precence was requested.");
 417     } else {
 418       Warning(kEH, "AOD not initialized.");
 419     }
 420   }
 421
 422   // Open RunLoader from galice.root
 423
 424   TString gaPath(Form("%s/galice.root", fPath.Data()));
 425   // If i use open directly, we get fatal.
 426   // Is AccessPathName check ok for xrootd / alien? Yes, not for http.
 427   // Seems not to work for alien anymore.
 428   // Fixed in ROOT on 27.10.2009, rev 30888.
 429   // To revert after we move to root-5.26.
 430   TFile *gafile = TFile::Open(gaPath);
 431   if (gafile)
 432   {
 433     gafile->Close();
 434     delete gafile;
 435   // if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
 436   // {
 437     fRunLoader = AliRunLoader::Open(gaPath, GetName());
 438     if (fRunLoader)
 439     {
 440       TString alicePath = fPath + "/";
 441       fRunLoader->SetDirName(alicePath);
 442
 443       if (fRunLoader->LoadgAlice() != 0)
 444         Warning(kEH, "failed loading gAlice via run-loader.");
 445
 446       if (fRunLoader->LoadHeader() == 0)
 447       {
 448         if (runNo < 0)
 449           runNo = fRunLoader->GetHeader()->GetRun();
 450       }
 451       else
 452       {
 453         Warning(kEH, "failed loading run-loader's header.");
 454         delete fRunLoader;
 455         fRunLoader = 0;
 456       }
 457     }
 458     else // run-loader open failed
 459     {
 460       Warning(kEH, "failed opening ALICE run-loader from '%s'.", gaPath.Data());
 461     }
 462   }
 463   else // galice not readable
 464   {
 465     Warning(kEH, "can not read '%s'.", gaPath.Data());
 466   }
 467   if (fRunLoader == 0)
 468   {
 469     if (fgAssertRunLoader)
 470       throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
 471     else
 472       Warning(kEH, "Bootstraping of run-loader failed.");
 473   }
 474
 475   // Open raw-data file
 476
 477   TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
 478   // If i use open directly, raw-reader reports an error but i have
 479   // no way to detect it.
 480   // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
 481   AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
 482   if (fgAssertRaw == kFALSE)
 483   {
 484     AliLog::SetGlobalLogLevel(AliLog::kFatal);
 485   }
 486   if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
 487   {
 488     fRawReader = AliRawReader::Create(rawPath);
 489   }
 490   else
 491   {
 492     fRawReader = AliRawReader::Create(fgRawFileName);
 493   }
 494   if (fgAssertRaw == kFALSE)
 495   {
 496     AliLog::SetGlobalLogLevel(oldLogLevel);
 497   }
 498
 499   if (fRawReader == 0)
 500   {
 501     if (fgAssertRaw)
 502     {
 503       throw (kEH + "raw-data not initialized. Its precence was requested.");
 504     } else {
 505       Warning(kEH, "raw-data not initialized.");
 506     }
 507   }
 508
 509   if (runNo < 0)
 510   {
 511     if (fRawReader)
 512     {
 513       fRawReader->NextEvent();
 514       runNo = fRawReader->GetRunNumber();
 515       Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
 516       fRawReader->RewindEvents();
 517     } else {
 518       throw (kEH + "unknown run number.");
 519     }
 520   }
 521
 522   // Initialize OCDB ... only in master event-manager
 523
 524   if (this == fgMaster)
 525   {
 526     AliCDBManager* cdb = AliCDBManager::Instance();
 527     if (cdb->IsDefaultStorageSet() == kTRUE)
 528     {
 529       Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
 530               cdb->GetDefaultStorage()->GetURI().Data());
 531     }
 532     else
 533     {
 534       if (fgCdbUri.IsNull())
 535       {
 536         gEnv->SetValue("Root.Stacktrace", "no");
 537         Fatal("Open()", "OCDB path was not specified.");
 538       }
 539
 540       // Handle some special cases for MC (should be in OCDBManager).
 541       if (fgCdbUri == "mcideal://")
 542         cdb->SetDefaultStorage("MC", "Ideal");
 543       else if (fgCdbUri == "mcresidual://")
 544         cdb->SetDefaultStorage("MC", "Residual");
 545       else if (fgCdbUri == "mcfull://")
 546         cdb->SetDefaultStorage("MC", "Full");
 547       else if (fgCdbUri == "local://") {
 548         fgCdbUri = "local://$ALICE_ROOT/OCDB";
 549         cdb->SetDefaultStorage(fgCdbUri);
 550       } else
 551         cdb->SetDefaultStorage(fgCdbUri);
 552
 553       cdb->SetRun(runNo);
 554
 555       if (cdb->IsDefaultStorageSet() == kFALSE)
 556         throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
 557     }
 558
 559     if (fgCdbUri.BeginsWith("local://"))
 560     {
 561       TString grp     = "GRP/GRP/Data";
 562       TString grppath = fPath + "/" + grp;
 563       if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
 564       {
 565         if (cdb->GetSpecificStorage(grp))
 566         {
 567           Warning(kEH, "Local GRP exists, but the specific storage is already set.");
 568         }
 569         else
 570         {
 571           Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
 572           TString lpath("local://");
 573           lpath += fPath;
 574           cdb->SetSpecificStorage(grp, lpath);
 575         }
 576       }
 577     }
 578   }
 579
 580   fIsOpen = kTRUE;
 581 }
 582
 583 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
 584 {
 585   // Set an event from an external source.
 586   // The method is used in the online visualisation.
 587   // AOD is not supported.
 588
 589   static const TEveException kEH("AliEveEventManager::SetEvent ");
 590
 591   if (fIsOpen)
 592   {
 593     Warning(kEH, "Event-files were open. Closing and switching to external control.");
 594     Close();
 595   }
 596
 597   fRunLoader = runLoader;
 598   fRawReader = rawReader;
 599   fESD       = esd;
 600   fESDfriend = esdf;
 601   fAOD       = 0;
 602
 603   fEventId++;
 604   fHasEvent     = kTRUE;
 605   fExternalCtrl = kTRUE;
 606
 607   SetTitle("Online event in memory");
 608   SetName ("Online Event");
 609   ElementChanged();
 610
 611   AfterNewEventLoaded();
 612
 613   if (fAutoLoad) StartAutoLoadTimer();
 614 }
 615
 616 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
 617 {
 618   // Returns maximum available event id.
 619   // If under external control or event is not opened -1 is returned.
 620   // If raw-data is the only data-source this can not be known
 621   // and 10,000,000 is returned.
 622   // If neither data-source is initialised an exception is thrown.
 623   // If refresh_esd is true and ESD is the primary event-data source
 624   // its header is re-read from disk.
 625
 626   static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
 627
 628   if (fExternalCtrl || fIsOpen == kFALSE)
 629   {
 630     return -1;
 631   }
 632
 633   if (fESDTree)
 634   {
 635     if (refreshESD)
 636     {
 637        fESDTree->Refresh();
 638        fPEventSelector->Update();
 639     }
 640     return fESDTree->GetEntries() - 1;
 641   }
 642   else if (fAODTree)
 643   {
 644     return fAODTree->GetEntries() - 1;
 645   }
 646   else if (fRunLoader)
 647   {
 648     return fRunLoader->GetNumberOfEvents() - 1;
 649   }
 650   else if (fRawReader)
 651   {
 652     Int_t n = fRawReader->GetNumberOfEvents() - 1;
 653     return n > -1 ? n : 10000000;
 654   }
 655   else
 656   {
 657     throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
 658   }
 659 }
 660
 661 void AliEveEventManager::GotoEvent(Int_t event)
 662 {
 663   // Load data for specified event.
 664   // If event is out of range an exception is thrown and old state
 665   // is preserved.
 666   // After successful loading of event, the virtual function
 667   // AfterNewEventLoaded() is called. This executes commands that
 668   // were registered via TEveEventManager::AddNewEventCommand().
 669   //
 670   // If event is negative, it is subtracted from the number of
 671   // available events, thus passing -1 will load the last event.
 672   // This is not supported when raw-data is the only data-source
 673   // as the number of events is not known.
 674
 675   static const TEveException kEH("AliEveEventManager::GotoEvent ");
 676
 677   if (fAutoLoadTimerRunning)
 678   {
 679     throw (kEH + "Event auto-load timer is running.");
 680   }
 681   if (fExternalCtrl)
 682   {
 683     throw (kEH + "Event-loop is under external control.");
 684   }
 685   else if (!fIsOpen)
 686   {
 687     throw (kEH + "Event-files not opened.");
 688   }
 689
 690   fHasEvent = kFALSE;
 691
 692   Int_t maxEvent = 0;
 693   if (fESDTree)
 694   {
 695     // Refresh crashes with root-5.21.1-alice.
 696     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
 697     // when we move to a newer root.
 698     // fESDTree->Refresh();
 699     maxEvent = fESDTree->GetEntries() - 1;
 700     if (event < 0)
 701       event = fESDTree->GetEntries() + event;
 702   }
 703   else if (fAODTree)
 704   {
 705     maxEvent = fAODTree->GetEntries() - 1;
 706     if (event < 0)
 707       event = fAODTree->GetEntries() + event;
 708   }
 709   else if (fRunLoader)
 710   {
 711     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
 712     if (event < 0)
 713       event = fRunLoader->GetNumberOfEvents() + event;
 714   }
 715   else if (fRawReader)
 716   {
 717     maxEvent = fRawReader->GetNumberOfEvents() - 1;
 718     if (maxEvent < 0)
 719     {
 720       maxEvent = 10000000;
 721       if (event < 0) {
 722         Error(kEH, "current raw-data source does not support direct event access.");
 723         return;
 724       }
 725       Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
 726     }
 727     else
 728     {
 729       if (event < 0)
 730         event = fRawReader->GetNumberOfEvents() + event;
 731     }
 732   }
 733   else
 734   {
 735     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
 736   }
 737   if (event < 0 || event > maxEvent)
 738   {
 739     throw (kEH + Form("event %d not present, available range [%d, %d].",
 740                       event, 0, maxEvent));
 741   }
 742
 743   TString sysInfoHeader;
 744   sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
 745   AliSysInfo::AddStamp(sysInfoHeader + "Start");
 746
 747   TEveManager::TRedrawDisabler rd(gEve);
 748   gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
 749
 750   // !!! MT this is somewhat brutal; at least optionally, one could be
 751   // a bit gentler, checking for objs owning their external refs and having
 752   // additinal parents.
 753   gEve->GetViewers()->DeleteAnnotations();
 754   fTransients->DestroyElements();
 755   for (TEveElement::List_i i = fTransientLists->BeginChildren();
 756        i != fTransientLists->EndChildren(); ++i)
 757   {
 758     (*i)->DestroyElements();
 759   }
 760   DestroyElements();
 761
 762   AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
 763
 764   if (fESDTree) {
 765     if (fESDTree->GetEntry(event) <= 0)
 766       throw (kEH + "failed getting required event from ESD.");
 767
 768     if (fESDfriendExists)
 769       fESD->SetESDfriend(fESDfriend);
 770   }
 771
 772   if (fAODTree) {
 773     if (fAODTree->GetEntry(event) <= 0)
 774       throw (kEH + "failed getting required event from AOD.");
 775   }
 776
 777   if (fRunLoader) {
 778     if (fRunLoader->GetEvent(event) != 0)
 779       throw (kEH + "failed getting required event.");
 780   }
 781
 782   if (fRawReader)
 783   {
 784     // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
 785     if (fRawReader->GotoEvent(event) == kFALSE)
 786     {
 787       // Use fallback method - iteration with NextEvent().
 788       Int_t rawEv = fEventId;
 789       if (event < rawEv)
 790       {
 791         fRawReader->RewindEvents();
 792         rawEv = -1;
 793       }
 794
 795       while (rawEv < event)
 796       {
 797         if ( ! fRawReader->NextEvent())
 798         {
 799           fRawReader->RewindEvents();
 800           fEventId = -1;
 801           throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
 802         }
 803         ++rawEv;
 804       }
 805       Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
 806     }
 807   }
 808
 809   fHasEvent = kTRUE;
 810   fEventId  = event;
 811   if (this == fgMaster)
 812   {
 813     SetName(Form("Event %d", fEventId));
 814     ElementChanged();
 815   }
 816
 817   AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
 818
 819   AfterNewEventLoaded();
 820
 821   AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
 822 }
 823
 824 void AliEveEventManager::NextEvent()
 825 {
 826   // Loads next event.
 827   // Does magick needed for online display when under external event control.
 828
 829   static const TEveException kEH("AliEveEventManager::NextEvent ");
 830
 831   if (fAutoLoadTimerRunning)
 832   {
 833     throw (kEH + "Event auto-load timer is running.");
 834   }
 835
 836   if (fExternalCtrl)
 837   {
 838     // !!! This should really go somewhere else. It is done in GotoEvent(),
 839     // so here we should do it in SetEvent().
 840     DestroyElements();
 841
 842     gSystem->ExitLoop();
 843   }
 844   else if (fESDTree)
 845   {
 846     Int_t nextevent=0;
 847     if (fPEventSelector->FindNext(nextevent))
 848     {
 849       GotoEvent(nextevent);
 850     }
 851   }
 852   else if (fEventId < GetMaxEventId(kTRUE))
 853   {
 854     GotoEvent(fEventId + 1);
 855   }
 856 }
 857
 858 void AliEveEventManager::PrevEvent()
 859 {
 860   // Loads previous event.
 861
 862   static const TEveException kEH("AliEveEventManager::PrevEvent ");
 863
 864   if (fAutoLoadTimerRunning)
 865   {
 866     throw (kEH + "Event auto-load timer is running.");
 867   }
 868   if (fExternalCtrl)
 869   {
 870     throw (kEH + "Event-loop is under external control.");
 871   }
 872
 873   if (fESDTree)
 874   {
 875     Int_t nextevent=0;
 876     if (fPEventSelector->FindPrev(nextevent))
 877     {
 878       GotoEvent(nextevent);
 879     }
 880   }
 881   else if (fEventId > 0)
 882   {
 883     GotoEvent(fEventId - 1);
 884   }
 885 }
 886
 887 void AliEveEventManager::Close()
 888 {
 889   // Close the event data-files and delete ESD, ESDfriend, run-loader
 890   // and raw-reader.
 891
 892   static const TEveException kEH("AliEveEventManager::Close ");
 893
 894   if (!fIsOpen)
 895   {
 896     throw (kEH + "Event-files not opened.");
 897   }
 898
 899   if (fAutoLoadTimerRunning)
 900     StopAutoLoadTimer();
 901
 902   if (fESDTree) {
 903     delete fESD;       fESD       = 0;
 904     // delete fESDfriend; // friend tree is deleted with the tree
 905     fESDfriend = 0;
 906     fESDfriendExists = kFALSE;
 907
 908     delete fESDTree;   fESDTree = 0;
 909     delete fESDFile;   fESDFile = 0;
 910   }
 911
 912   if (fAODTree) {
 913     delete fAOD;       fAOD       = 0;
 914
 915     delete fAODTree;   fAODTree = 0;
 916     delete fAODFile;   fAODFile = 0;
 917   }
 918
 919   if (fRunLoader) {
 920     delete fRunLoader; fRunLoader = 0;
 921   }
 922
 923   if (fRawReader) {
 924     delete fRawReader; fRawReader = 0;
 925   }
 926
 927   fEventId  = -1;
 928   fIsOpen   = kFALSE;
 929   fHasEvent = kFALSE;
 930 }
 931
 932
 933 //------------------------------------------------------------------------------
 934 // Static convenience functions, mainly used from macros.
 935 //------------------------------------------------------------------------------
 936
 937 Bool_t AliEveEventManager::HasRunLoader()
 938 {
 939   // Check if AliRunLoader is initialized.
 940
 941   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
 942 }
 943
 944 Bool_t AliEveEventManager::HasESD()
 945 {
 946   // Check if AliESDEvent is initialized.
 947
 948   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
 949 }
 950
 951 Bool_t AliEveEventManager::HasESDfriend()
 952 {
 953   // Check if AliESDfriend is initialized.
 954
 955   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
 956 }
 957
 958 Bool_t AliEveEventManager::HasAOD()
 959 {
 960   // Check if AliESDEvent is initialized.
 961
 962   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
 963 }
 964
 965 Bool_t AliEveEventManager::HasRawReader()
 966 {
 967   // Check if raw-reader is initialized.
 968
 969   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
 970 }
 971
 972 AliRunLoader* AliEveEventManager::AssertRunLoader()
 973 {
 974   // Make sure AliRunLoader is initialized and return it.
 975   // Throws exception in case run-loader is not available.
 976   // Static utility for macros.
 977
 978   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
 979
 980   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
 981     throw (kEH + "ALICE event not ready.");
 982   if (fgCurrent->fRunLoader == 0)
 983     throw (kEH + "AliRunLoader not initialised.");
 984   return fgCurrent->fRunLoader;
 985 }
 986
 987 AliESDEvent* AliEveEventManager::AssertESD()
 988 {
 989   // Make sure AliESDEvent is initialized and return it.
 990   // Throws exception in case ESD is not available.
 991   // Static utility for macros.
 992
 993   static const TEveException kEH("AliEveEventManager::AssertESD ");
 994
 995   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
 996     throw (kEH + "ALICE event not ready.");
 997   if (fgCurrent->fESD == 0)
 998     throw (kEH + "AliESD not initialised.");
 999   return fgCurrent->fESD;
1000 }
1001
1002 AliESDfriend* AliEveEventManager::AssertESDfriend()
1003 {
1004   // Make sure AliESDfriend is initialized and return it.
1005   // Throws exception in case ESDfriend-loader is not available.
1006   // Static utility for macros.
1007
1008   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1009
1010   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1011     throw (kEH + "ALICE event not ready.");
1012   if (fgCurrent->fESDfriend == 0)
1013     throw (kEH + "AliESDfriend not initialised.");
1014   return fgCurrent->fESDfriend;
1015 }
1016
1017 AliAODEvent* AliEveEventManager::AssertAOD()
1018 {
1019   // Make sure AliAODEvent is initialized and return it.
1020   // Throws exception in case AOD is not available.
1021   // Static utility for macros.
1022
1023   static const TEveException kEH("AliEveEventManager::AssertAOD ");
1024
1025   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1026     throw (kEH + "ALICE event not ready.");
1027   if (fgCurrent->fAOD == 0)
1028     throw (kEH + "AliAOD not initialised.");
1029   return fgCurrent->fAOD;
1030 }
1031
1032 AliRawReader* AliEveEventManager::AssertRawReader()
1033 {
1034   // Make sure raw-reader is initialized and return it.
1035
1036   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1037
1038   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1039     throw (kEH + "ALICE event not ready.");
1040   if (fgCurrent->fRawReader == 0)
1041     throw (kEH + "RawReader not ready.");
1042
1043   return fgCurrent->fRawReader;
1044 }
1045
1046 //==============================================================================
1047
1048 AliMagF* AliEveEventManager::AssertMagField()
1049 {
1050   // Make sure AliMagF is initialized and returns it.
1051   // Throws exception in case magnetic field is not available.
1052   // Static utility for macros.
1053
1054   static const TEveException kEH("AliEveEventManager::AssertMagField ");
1055
1056   if (fgMagField)
1057     return fgMagField;
1058
1059   if (TGeoGlobalMagField::Instance()->GetField())
1060   {
1061     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1062     if (fgMagField == 0)
1063       throw kEH + "Global field set, but it is not AliMagF.";
1064     return fgMagField;
1065   }
1066
1067   if (!fgGRPLoaded)
1068   {
1069     InitGRP();
1070   }
1071
1072   if (TGeoGlobalMagField::Instance()->GetField())
1073   {
1074     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1075     if (fgMagField == 0)
1076       throw kEH + "Global field set, but it is not AliMagF.";
1077   }
1078   else
1079   {
1080     throw kEH + "Could not initialize magnetic field.";
1081   }
1082
1083   return fgMagField;
1084 }
1085
1086 TGeoManager* AliEveEventManager::AssertGeometry()
1087 {
1088   // Make sure AliGeomManager is initialized and returns the
1089   // corresponding TGeoManger.
1090   // gGeoManager is set to the return value.
1091   // Throws exception if geometry can not be loaded or if it is not
1092   // available and the TGeoManager is locked.
1093   // Static utility for macros.
1094
1095   static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1096
1097   if (AliGeomManager::GetGeometry() == 0)
1098   {
1099     if (TGeoManager::IsLocked())
1100       throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1101
1102     gGeoManager = 0;
1103     AliGeomManager::LoadGeometry();
1104     if ( ! AliGeomManager::GetGeometry())
1105     {
1106       throw (kEH + "can not load geometry.");
1107     }
1108     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1109     {
1110       ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1111       // throw (kEH + "could not apply align objs.");
1112     }
1113     AliGeomManager::GetGeometry()->DefaultColors();
1114   }
1115
1116   gGeoManager = AliGeomManager::GetGeometry();
1117   return gGeoManager;
1118 }
1119
1120 //------------------------------------------------------------------------------
1121
1122 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1123 {
1124   // Create and attach a dependent event-manager.
1125   // It is not added into eve list tree.
1126
1127   static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1128
1129   if (fgMaster == 0)
1130     throw(kEH + "Master event-manager must be instantiated first.");
1131
1132   if (fgMaster->fSubManagers == 0)
1133   {
1134     fgMaster->fSubManagers = new TList;
1135     fgMaster->fSubManagers->SetOwner(kTRUE);
1136   }
1137
1138   AliEveEventManager* new_mgr = 0;
1139   fgCurrent = 0;
1140   try
1141   {
1142     new_mgr = new AliEveEventManager(name, path, fgMaster->fEventId);
1143     fgMaster->fSubManagers->Add(new_mgr);
1144   }
1145   catch (TEveException& exc)
1146   {
1147     ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1148   }
1149   fgCurrent = fgMaster;
1150
1151   return new_mgr;
1152 }
1153
1154 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1155 {
1156   // Get a dependant manager by name.
1157   // This will not change the current manager, use helper class
1158   // AliEveEventManager::CurrentChanger for that.
1159
1160   static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1161
1162   if (fgMaster == 0)
1163     throw(kEH + "Master event-manager must be instantiated first.");
1164
1165   if (fgMaster->fSubManagers == 0)
1166     return 0;
1167
1168   return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1169 }
1170
1171 AliEveEventManager* AliEveEventManager::GetMaster()
1172 {
1173   // Get master event-manager.
1174
1175   return fgMaster;
1176 }
1177
1178 AliEveEventManager* AliEveEventManager::GetCurrent()
1179 {
1180   // Get current event-manager.
1181
1182   return fgCurrent;
1183 }
1184
1185 void AliEveEventManager::RegisterTransient(TEveElement* element)
1186 {
1187   GetCurrent()->fTransients->AddElement(element);
1188 }
1189
1190 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1191 {
1192   GetCurrent()->fTransientLists->AddElement(element);
1193 }
1194
1195 //------------------------------------------------------------------------------
1196 // Autoloading of events
1197 //------------------------------------------------------------------------------
1198
1199 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1200 {
1201   // Set the auto-load time in seconds
1202
1203   fAutoLoadTime = time;
1204 }
1205
1206 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1207 {
1208   // Set the automatic event loading mode
1209
1210   static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1211
1212   if (fAutoLoad == autoLoad)
1213   {
1214     Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1215     return;
1216   }
1217
1218   fAutoLoad = autoLoad;
1219   if (fAutoLoad)
1220   {
1221     StartAutoLoadTimer();
1222   }
1223   else
1224   {
1225     StopAutoLoadTimer();
1226   }
1227 }
1228
1229 void AliEveEventManager::SetTrigSel(Int_t trig)
1230 {
1231   static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1232
1233   if (!fRawReader)
1234     {
1235     Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1236     return;
1237   }
1238   else
1239   {
1240     ULong64_t trigMask = 0;
1241     if (trig >= 0) trigMask = (1ull << trig);
1242     Info(kEH,"Trigger selection: 0x%llx",trigMask);
1243     fRawReader->SelectEvents(-1,trigMask,NULL);
1244   }
1245 }
1246
1247 void AliEveEventManager::StartAutoLoadTimer()
1248 {
1249   // Start the auto-load timer.
1250
1251   fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1252   fAutoLoadTimer->Reset();
1253   fAutoLoadTimer->TurnOn();
1254   fAutoLoadTimerRunning = kTRUE;
1255 }
1256
1257 void AliEveEventManager::StopAutoLoadTimer()
1258 {
1259   // Stop the auto-load timer.
1260
1261   fAutoLoadTimerRunning = kFALSE;
1262   fAutoLoadTimer->TurnOff();
1263 }
1264
1265 void AliEveEventManager::AutoLoadNextEvent()
1266 {
1267   // Called from auto-load timer, so it has to be public.
1268   // Do NOT call it directly.
1269
1270   static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1271
1272   if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1273   {
1274     Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1275     return;
1276   }
1277
1278   StopAutoLoadTimer();
1279   NextEvent();
1280   if (fAutoLoad && !fExternalCtrl)
1281     StartAutoLoadTimer();
1282 }
1283
1284 //------------------------------------------------------------------------------
1285 // Post event-loading functions
1286 //------------------------------------------------------------------------------
1287
1288 void AliEveEventManager::AfterNewEventLoaded()
1289 {
1290   // Execute registered macros and commands.
1291   // At the end emit NewEventLoaded signal.
1292   //
1293   // Virtual from TEveEventManager.
1294
1295   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1296
1297   if (fExecutor)
1298     fExecutor->ExecMacros();
1299
1300   TEveEventManager::AfterNewEventLoaded();
1301
1302   NewEventLoaded();
1303
1304   if (this == fgMaster && fSubManagers != 0)
1305   {
1306     TIter next(fSubManagers);
1307     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1308     {
1309       gEve->SetCurrentEvent(fgCurrent);
1310       try
1311       {
1312         fgCurrent->GotoEvent(fEventId);
1313       }
1314       catch (TEveException& exc)
1315       {
1316         // !!! Should somehow tag / disable / remove it?
1317         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1318               fEventId, fgCurrent->GetName(), exc.Data());
1319       }
1320     }
1321     fgCurrent = fgMaster;
1322     gEve->SetCurrentEvent(fgMaster);
1323   }
1324 }
1325
1326 void AliEveEventManager::NewEventLoaded()
1327 {
1328   // Emit NewEventLoaded signal.
1329
1330   Emit("NewEventLoaded()");
1331 }
1332
1333
1334 //------------------------------------------------------------------------------
1335 // Event info dumpers
1336 //------------------------------------------------------------------------------
1337
1338 TString AliEveEventManager::GetEventInfoHorizontal() const
1339 {
1340   // Dumps the event-header contents in vertical formatting.
1341
1342   TString rawInfo, esdInfo;
1343
1344   if (!fRawReader)
1345   {
1346     rawInfo = "No raw-data event info is available!\n";
1347   }
1348   else
1349   {
1350     const UInt_t* attr = fRawReader->GetAttributes();
1351     TTimeStamp ts(fRawReader->GetTimestamp());
1352     rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1353                  "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
1354                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1355                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1356                  fRawReader->GetClassMask(),
1357                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1358                  attr[0],attr[1],attr[2], ts.AsString("s"));
1359   }
1360
1361   if (!fESD)
1362   {
1363     esdInfo = "No ESD event info is available!";
1364   }
1365   else
1366   {
1367     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1368     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1369     TTimeStamp ts(fESD->GetTimeStamp());
1370     esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1371                  "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
1372                  fESD->GetRunNumber(),
1373                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1374                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1375                  acttrclasses.Data(),
1376                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1377                  fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
1378   }
1379
1380   return rawInfo + esdInfo;
1381 }
1382
1383 TString AliEveEventManager::GetEventInfoVertical() const
1384 {
1385   // Dumps the event-header contents in vertical formatting.
1386
1387   TString rawInfo, esdInfo;
1388
1389   if (!fRawReader)
1390   {
1391     rawInfo = "No raw-data event info is available!\n";
1392   }
1393   else
1394   {
1395     const UInt_t* attr = fRawReader->GetAttributes();
1396     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",
1397                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1398                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1399                  fRawReader->GetClassMask(),
1400                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1401                  attr[0],attr[1],attr[2],
1402                  fRawReader->GetTimestamp());
1403   }
1404
1405   if (!fESD)
1406   {
1407     esdInfo = "No ESD event info is available!\n";
1408   }
1409   else
1410   {
1411     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1412     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1413     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",
1414                  fESD->GetRunNumber(),
1415                  acttrclasses.Data(),
1416                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1417                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1418                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1419                  fESD->GetEventNumberInFile(),
1420                  fESD->GetTimeStamp());
1421   }
1422
1423   return rawInfo + "\n" + esdInfo;
1424 }
1425
1426
1427 //==============================================================================
1428 // Reading of GRP and MagneticField.
1429 // This is a reap-off from reconstruction ... should really be a common
1430 // code to do this somewhere in STEER.
1431 //==============================================================================
1432
1433 Bool_t AliEveEventManager::InitGRP()
1434 {
1435   //------------------------------------
1436   // Initialization of the GRP entry
1437   //------------------------------------
1438
1439   static const TEveException kEH("AliEveEventManager::InitGRP ");
1440
1441   AliGRPManager grpMgr;
1442   if (!grpMgr.ReadGRPEntry()) {
1443     return kFALSE;
1444   }
1445   fgGRPLoaded = kTRUE;
1446   if (!grpMgr.SetMagField()) {
1447     throw kEH + "Setting of field failed!";
1448   }
1449
1450   //*** Get the diamond profiles from OCDB
1451   // Eventually useful.
1452
1453   /*
1454     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1455     if (entry) {
1456     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1457     } else {
1458     ::Error(kEH, "No SPD diamond profile found in OCDB!");
1459     }
1460
1461     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1462     if (entry) {
1463     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1464     } else {
1465     ::Error(kEH, "No diamond profile found in OCDB!");
1466     }
1467
1468     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1469     if (entry) {
1470     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1471     } else {
1472     ::Error(kEH, "No TPC diamond profile found in OCDB!");
1473     }
1474   */
1475
1476   return kTRUE;
1477 }