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