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   if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
 428   {
 429     fRunLoader = AliRunLoader::Open(gaPath, GetName());
 430     if (fRunLoader)
 431     {
 432       TString alicePath = fPath + "/";
 433       fRunLoader->SetDirName(alicePath);
 434
 435       if (fRunLoader->LoadgAlice() != 0)
 436         Warning(kEH, "failed loading gAlice via run-loader.");
 437
 438       if (fRunLoader->LoadHeader() == 0)
 439       {
 440         if (runNo < 0)
 441           runNo = fRunLoader->GetHeader()->GetRun();
 442       }
 443       else
 444       {
 445         Warning(kEH, "failed loading run-loader's header.");
 446         delete fRunLoader;
 447         fRunLoader = 0;
 448       }
 449     }
 450     else // run-loader open failed
 451     {
 452       Warning(kEH, "failed opening ALICE run-loader from '%s'.", gaPath.Data());
 453     }
 454   }
 455   else // galice not readable
 456   {
 457     Warning(kEH, "can not read '%s'.", gaPath.Data());
 458   }
 459   if (fRunLoader == 0)
 460   {
 461     if (fgAssertRunLoader)
 462       throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
 463     else
 464       Warning(kEH, "Bootstraping of run-loader failed.");
 465   }
 466
 467   // Open raw-data file
 468
 469   TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
 470   // If i use open directly, raw-reader reports an error but i have
 471   // no way to detect it.
 472   // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
 473   AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
 474   if (fgAssertRaw == kFALSE)
 475   {
 476     AliLog::SetGlobalLogLevel(AliLog::kFatal);
 477   }
 478   if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
 479   {
 480     fRawReader = AliRawReader::Create(rawPath);
 481   }
 482   else
 483   {
 484     fRawReader = AliRawReader::Create(fgRawFileName);
 485   }
 486   if (fgAssertRaw == kFALSE)
 487   {
 488     AliLog::SetGlobalLogLevel(oldLogLevel);
 489   }
 490
 491   if (fRawReader == 0)
 492   {
 493     if (fgAssertRaw)
 494     {
 495       throw (kEH + "raw-data not initialized. Its precence was requested.");
 496     } else {
 497       Warning(kEH, "raw-data not initialized.");
 498     }
 499   }
 500
 501   if (runNo < 0)
 502   {
 503     if (fRawReader)
 504     {
 505       fRawReader->NextEvent();
 506       runNo = fRawReader->GetRunNumber();
 507       Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
 508       fRawReader->RewindEvents();
 509     } else {
 510       throw (kEH + "unknown run number.");
 511     }
 512   }
 513
 514   // Initialize OCDB ... only in master event-manager
 515
 516   if (this == fgMaster)
 517   {
 518     AliCDBManager* cdb = AliCDBManager::Instance();
 519     if (cdb->IsDefaultStorageSet() == kTRUE)
 520     {
 521       Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
 522               cdb->GetDefaultStorage()->GetURI().Data());
 523     }
 524     else
 525     {
 526       if (fgCdbUri.IsNull())
 527       {
 528         gEnv->SetValue("Root.Stacktrace", "no");
 529         Fatal("Open()", "OCDB path was not specified.");
 530       }
 531
 532       // Handle some special cases for MC (should be in OCDBManager).
 533       if (fgCdbUri == "mcideal://")
 534         cdb->SetDefaultStorage("MC", "Ideal");
 535       else if (fgCdbUri == "mcresidual://")
 536         cdb->SetDefaultStorage("MC", "Residual");
 537       else if (fgCdbUri == "mcfull://")
 538         cdb->SetDefaultStorage("MC", "Full");
 539       else if (fgCdbUri == "local://") {
 540         fgCdbUri = "local://$ALICE_ROOT/OCDB";
 541         cdb->SetDefaultStorage(fgCdbUri);
 542       } else
 543         cdb->SetDefaultStorage(fgCdbUri);
 544       if (cdb->IsDefaultStorageSet() == kFALSE)
 545         throw kEH + "CDB initialization failed.";
 546     }
 547
 548     if (fgCdbUri.BeginsWith("local://"))
 549     {
 550       TString grp     = "GRP/GRP/Data";
 551       TString grppath = fPath + "/" + grp;
 552       if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
 553       {
 554         if (cdb->GetSpecificStorage(grp))
 555         {
 556           Warning(kEH, "Local GRP exists, but the specific storage is already set.");
 557         }
 558         else
 559         {
 560           Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
 561           TString lpath("local://");
 562           lpath += fPath;
 563           cdb->SetSpecificStorage(grp, lpath);
 564         }
 565       }
 566     }
 567     cdb->SetRun(runNo);
 568   }
 569
 570   fIsOpen = kTRUE;
 571 }
 572
 573 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
 574 {
 575   // Set an event from an external source.
 576   // The method is used in the online visualisation.
 577   // AOD is not supported.
 578
 579   static const TEveException kEH("AliEveEventManager::SetEvent ");
 580
 581   if (fIsOpen)
 582   {
 583     Warning(kEH, "Event-files were open. Closing and switching to external control.");
 584     Close();
 585   }
 586
 587   fRunLoader = runLoader;
 588   fRawReader = rawReader;
 589   fESD       = esd;
 590   fESDfriend = esdf;
 591   fAOD       = 0;
 592
 593   fEventId++;
 594   fHasEvent     = kTRUE;
 595   fExternalCtrl = kTRUE;
 596
 597   SetTitle("Online event in memory");
 598   SetName ("Online Event");
 599   ElementChanged();
 600
 601   AfterNewEventLoaded();
 602
 603   if (fAutoLoad) StartAutoLoadTimer();
 604 }
 605
 606 Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
 607 {
 608   // Returns maximum available event id.
 609   // If under external control or event is not opened -1 is returned.
 610   // If raw-data is the only data-source this can not be known
 611   // and 10,000,000 is returned.
 612   // If neither data-source is initialised an exception is thrown.
 613   // If refresh_esd is true and ESD is the primary event-data source
 614   // its header is re-read from disk.
 615
 616   static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
 617
 618   if (fExternalCtrl || fIsOpen == kFALSE)
 619   {
 620     return -1;
 621   }
 622
 623   if (fESDTree)
 624   {
 625     // Refresh crashes with root-5.21.1-alice.
 626     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
 627     // when we move to a newer root.
 628     // if (refreshESD)
 629     //   fESDTree->Refresh();
 630     return fESDTree->GetEntries() - 1;
 631   }
 632   else if (fAODTree)
 633   {
 634     return fAODTree->GetEntries() - 1;
 635   }
 636   else if (fRunLoader)
 637   {
 638     return fRunLoader->GetNumberOfEvents() - 1;
 639   }
 640   else if (fRawReader)
 641   {
 642     Int_t n = fRawReader->GetNumberOfEvents() - 1;
 643     return n > -1 ? n : 10000000;
 644   }
 645   else
 646   {
 647     throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
 648   }
 649 }
 650
 651 void AliEveEventManager::GotoEvent(Int_t event)
 652 {
 653   // Load data for specified event.
 654   // If event is out of range an exception is thrown and old state
 655   // is preserved.
 656   // After successful loading of event, the virtual function
 657   // AfterNewEventLoaded() is called. This executes commands that
 658   // were registered via TEveEventManager::AddNewEventCommand().
 659   //
 660   // If event is negative, it is subtracted from the number of
 661   // available events, thus passing -1 will load the last event.
 662   // This is not supported when raw-data is the only data-source
 663   // as the number of events is not known.
 664
 665   static const TEveException kEH("AliEveEventManager::GotoEvent ");
 666
 667   if (fAutoLoadTimerRunning)
 668   {
 669     throw (kEH + "Event auto-load timer is running.");
 670   }
 671   if (fExternalCtrl)
 672   {
 673     throw (kEH + "Event-loop is under external control.");
 674   }
 675   else if (!fIsOpen)
 676   {
 677     throw (kEH + "Event-files not opened.");
 678   }
 679
 680   fHasEvent = kFALSE;
 681
 682   Int_t maxEvent = 0;
 683   if (fESDTree)
 684   {
 685     // Refresh crashes with root-5.21.1-alice.
 686     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
 687     // when we move to a newer root.
 688     // fESDTree->Refresh();
 689     maxEvent = fESDTree->GetEntries() - 1;
 690     if (event < 0)
 691       event = fESDTree->GetEntries() + event;
 692   }
 693   else if (fAODTree)
 694   {
 695     maxEvent = fAODTree->GetEntries() - 1;
 696     if (event < 0)
 697       event = fAODTree->GetEntries() + event;
 698   }
 699   else if (fRunLoader)
 700   {
 701     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
 702     if (event < 0)
 703       event = fRunLoader->GetNumberOfEvents() + event;
 704   }
 705   else if (fRawReader)
 706   {
 707     maxEvent = fRawReader->GetNumberOfEvents() - 1;
 708     if (maxEvent < 0)
 709     {
 710       maxEvent = 10000000;
 711       if (event < 0) {
 712         Error(kEH, "current raw-data source does not support direct event access.");
 713         return;
 714       }
 715       Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
 716     }
 717     else
 718     {
 719       if (event < 0)
 720         event = fRawReader->GetNumberOfEvents() + event;
 721     }
 722   }
 723   else
 724   {
 725     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
 726   }
 727   if (event < 0 || event > maxEvent)
 728   {
 729     throw (kEH + Form("event %d not present, available range [%d, %d].",
 730                       event, 0, maxEvent));
 731   }
 732
 733   TString sysInfoHeader;
 734   sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
 735   AliSysInfo::AddStamp(sysInfoHeader + "Start");
 736
 737   TEveManager::TRedrawDisabler rd(gEve);
 738   gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
 739
 740   // !!! MT this is somewhat brutal; at least optionally, one could be
 741   // a bit gentler, checking for objs owning their external refs and having
 742   // additinal parents.
 743   gEve->GetViewers()->DeleteAnnotations();
 744   fTransients->DestroyElements();
 745   for (TEveElement::List_i i = fTransientLists->BeginChildren();
 746        i != fTransientLists->EndChildren(); ++i)
 747   {
 748     (*i)->DestroyElements();
 749   }
 750   DestroyElements();
 751
 752   AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
 753
 754   if (fESDTree) {
 755     if (fESDTree->GetEntry(event) <= 0)
 756       throw (kEH + "failed getting required event from ESD.");
 757
 758     if (fESDfriendExists)
 759       fESD->SetESDfriend(fESDfriend);
 760   }
 761
 762   if (fAODTree) {
 763     if (fAODTree->GetEntry(event) <= 0)
 764       throw (kEH + "failed getting required event from AOD.");
 765   }
 766
 767   if (fRunLoader) {
 768     if (fRunLoader->GetEvent(event) != 0)
 769       throw (kEH + "failed getting required event.");
 770   }
 771
 772   if (fRawReader)
 773   {
 774     // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
 775     if (fRawReader->GotoEvent(event) == kFALSE)
 776     {
 777       // Use fallback method - iteration with NextEvent().
 778       Int_t rawEv = fEventId;
 779       if (event < rawEv)
 780       {
 781         fRawReader->RewindEvents();
 782         rawEv = -1;
 783       }
 784
 785       while (rawEv < event)
 786       {
 787         if ( ! fRawReader->NextEvent())
 788         {
 789           fRawReader->RewindEvents();
 790           fEventId = -1;
 791           throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
 792         }
 793         ++rawEv;
 794       }
 795       Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
 796     }
 797   }
 798
 799   fHasEvent = kTRUE;
 800   fEventId  = event;
 801   if (this == fgMaster)
 802   {
 803     SetName(Form("Event %d", fEventId));
 804     ElementChanged();
 805   }
 806
 807   AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
 808
 809   AfterNewEventLoaded();
 810
 811   AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
 812 }
 813
 814 void AliEveEventManager::NextEvent()
 815 {
 816   // Loads next event.
 817   // Does magick needed for online display when under external event control.
 818
 819   static const TEveException kEH("AliEveEventManager::NextEvent ");
 820
 821   if (fAutoLoadTimerRunning)
 822   {
 823     throw (kEH + "Event auto-load timer is running.");
 824   }
 825
 826   if (fExternalCtrl)
 827   {
 828     // !!! This should really go somewhere else. It is done in GotoEvent(),
 829     // so here we should do it in SetEvent().
 830     DestroyElements();
 831
 832     gSystem->ExitLoop();
 833   }
 834   else
 835   {
 836     Int_t nextevent=0;
 837     if (fPEventSelector->FindNext(nextevent))
 838     {
 839       GotoEvent(nextevent);
 840     }
 841   }
 842 }
 843
 844 void AliEveEventManager::PrevEvent()
 845 {
 846   // Loads previous event.
 847
 848   static const TEveException kEH("AliEveEventManager::PrevEvent ");
 849
 850   if (fAutoLoadTimerRunning)
 851   {
 852     throw (kEH + "Event auto-load timer is running.");
 853   }
 854   if (fExternalCtrl)
 855   {
 856     throw (kEH + "Event-loop is under external control.");
 857   }
 858   Int_t nextevent=0;
 859   if (fPEventSelector->FindPrev(nextevent))
 860   {
 861     GotoEvent(nextevent);
 862   }
 863 }
 864
 865 void AliEveEventManager::Close()
 866 {
 867   // Close the event data-files and delete ESD, ESDfriend, run-loader
 868   // and raw-reader.
 869
 870   static const TEveException kEH("AliEveEventManager::Close ");
 871
 872   if (!fIsOpen)
 873   {
 874     throw (kEH + "Event-files not opened.");
 875   }
 876
 877   if (fAutoLoadTimerRunning)
 878     StopAutoLoadTimer();
 879
 880   if (fESDTree) {
 881     delete fESD;       fESD       = 0;
 882     delete fESDfriend; fESDfriend = 0;
 883     fESDfriendExists = kFALSE;
 884
 885     delete fESDTree;   fESDTree = 0;
 886     delete fESDFile;   fESDFile = 0;
 887   }
 888
 889   if (fAODTree) {
 890     delete fAOD;       fAOD       = 0;
 891
 892     delete fAODTree;   fAODTree = 0;
 893     delete fAODFile;   fAODFile = 0;
 894   }
 895
 896   if (fRunLoader) {
 897     delete fRunLoader; fRunLoader = 0;
 898   }
 899
 900   if (fRawReader) {
 901     delete fRawReader; fRawReader = 0;
 902   }
 903
 904   fEventId  = -1;
 905   fIsOpen   = kFALSE;
 906   fHasEvent = kFALSE;
 907 }
 908
 909
 910 //------------------------------------------------------------------------------
 911 // Static convenience functions, mainly used from macros.
 912 //------------------------------------------------------------------------------
 913
 914 Bool_t AliEveEventManager::HasRunLoader()
 915 {
 916   // Check if AliRunLoader is initialized.
 917
 918   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
 919 }
 920
 921 Bool_t AliEveEventManager::HasESD()
 922 {
 923   // Check if AliESDEvent is initialized.
 924
 925   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
 926 }
 927
 928 Bool_t AliEveEventManager::HasESDfriend()
 929 {
 930   // Check if AliESDfriend is initialized.
 931
 932   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
 933 }
 934
 935 Bool_t AliEveEventManager::HasAOD()
 936 {
 937   // Check if AliESDEvent is initialized.
 938
 939   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
 940 }
 941
 942 Bool_t AliEveEventManager::HasRawReader()
 943 {
 944   // Check if raw-reader is initialized.
 945
 946   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
 947 }
 948
 949 AliRunLoader* AliEveEventManager::AssertRunLoader()
 950 {
 951   // Make sure AliRunLoader is initialized and return it.
 952   // Throws exception in case run-loader is not available.
 953   // Static utility for macros.
 954
 955   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
 956
 957   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
 958     throw (kEH + "ALICE event not ready.");
 959   if (fgCurrent->fRunLoader == 0)
 960     throw (kEH + "AliRunLoader not initialised.");
 961   return fgCurrent->fRunLoader;
 962 }
 963
 964 AliESDEvent* AliEveEventManager::AssertESD()
 965 {
 966   // Make sure AliESDEvent is initialized and return it.
 967   // Throws exception in case ESD is not available.
 968   // Static utility for macros.
 969
 970   static const TEveException kEH("AliEveEventManager::AssertESD ");
 971
 972   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
 973     throw (kEH + "ALICE event not ready.");
 974   if (fgCurrent->fESD == 0)
 975     throw (kEH + "AliESD not initialised.");
 976   return fgCurrent->fESD;
 977 }
 978
 979 AliESDfriend* AliEveEventManager::AssertESDfriend()
 980 {
 981   // Make sure AliESDfriend is initialized and return it.
 982   // Throws exception in case ESDfriend-loader is not available.
 983   // Static utility for macros.
 984
 985   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
 986
 987   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
 988     throw (kEH + "ALICE event not ready.");
 989   if (fgCurrent->fESDfriend == 0)
 990     throw (kEH + "AliESDfriend not initialised.");
 991   return fgCurrent->fESDfriend;
 992 }
 993
 994 AliAODEvent* AliEveEventManager::AssertAOD()
 995 {
 996   // Make sure AliAODEvent is initialized and return it.
 997   // Throws exception in case AOD is not available.
 998   // Static utility for macros.
 999
1000   static const TEveException kEH("AliEveEventManager::AssertAOD ");
1001
1002   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1003     throw (kEH + "ALICE event not ready.");
1004   if (fgCurrent->fAOD == 0)
1005     throw (kEH + "AliAOD not initialised.");
1006   return fgCurrent->fAOD;
1007 }
1008
1009 AliRawReader* AliEveEventManager::AssertRawReader()
1010 {
1011   // Make sure raw-reader is initialized and return it.
1012
1013   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1014
1015   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1016     throw (kEH + "ALICE event not ready.");
1017   if (fgCurrent->fRawReader == 0)
1018     throw (kEH + "RawReader not ready.");
1019
1020   return fgCurrent->fRawReader;
1021 }
1022
1023 //==============================================================================
1024
1025 AliMagF* AliEveEventManager::AssertMagField()
1026 {
1027   // Make sure AliMagF is initialized and returns it.
1028   // Throws exception in case magnetic field is not available.
1029   // Static utility for macros.
1030
1031   static const TEveException kEH("AliEveEventManager::AssertMagField ");
1032
1033   if (fgMagField)
1034     return fgMagField;
1035
1036   if (TGeoGlobalMagField::Instance()->GetField())
1037   {
1038     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1039     if (fgMagField == 0)
1040       throw kEH + "Global field set, but it is not AliMagF.";
1041     return fgMagField;
1042   }
1043
1044   if (!fgGRPLoaded)
1045   {
1046     InitGRP();
1047   }
1048
1049   if (TGeoGlobalMagField::Instance()->GetField())
1050   {
1051     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1052     if (fgMagField == 0)
1053       throw kEH + "Global field set, but it is not AliMagF.";
1054   }
1055   else
1056   {
1057     throw kEH + "Could not initialize magnetic field.";
1058   }
1059
1060   return fgMagField;
1061 }
1062
1063 TGeoManager* AliEveEventManager::AssertGeometry()
1064 {
1065   // Make sure AliGeomManager is initialized and returns the
1066   // corresponding TGeoManger.
1067   // gGeoManager is set to the return value.
1068   // Throws exception if geometry can not be loaded or if it is not
1069   // available and the TGeoManager is locked.
1070   // Static utility for macros.
1071
1072   static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1073
1074   if (AliGeomManager::GetGeometry() == 0)
1075   {
1076     if (TGeoManager::IsLocked())
1077       throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1078
1079     gGeoManager = 0;
1080     AliGeomManager::LoadGeometry();
1081     if ( ! AliGeomManager::GetGeometry())
1082     {
1083       throw (kEH + "can not load geometry.");
1084     }
1085     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1086     {
1087       ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1088       // throw (kEH + "could not apply align objs.");
1089     }
1090     AliGeomManager::GetGeometry()->DefaultColors();
1091   }
1092
1093   gGeoManager = AliGeomManager::GetGeometry();
1094   return gGeoManager;
1095 }
1096
1097 //------------------------------------------------------------------------------
1098
1099 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1100 {
1101   // Create and attach a dependent event-manager.
1102   // It is not added into eve list tree.
1103
1104   static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1105
1106   if (fgMaster == 0)
1107     throw(kEH + "Master event-manager must be instantiated first.");
1108
1109   if (fgMaster->fSubManagers == 0)
1110   {
1111     fgMaster->fSubManagers = new TList;
1112     fgMaster->fSubManagers->SetOwner(kTRUE);
1113   }
1114
1115   AliEveEventManager* new_mgr = 0;
1116   fgCurrent = 0;
1117   try
1118   {
1119     new_mgr = new AliEveEventManager(name, path, fgMaster->fEventId);
1120     fgMaster->fSubManagers->Add(new_mgr);
1121   }
1122   catch (TEveException& exc)
1123   {
1124     ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1125   }
1126   fgCurrent = fgMaster;
1127
1128   return new_mgr;
1129 }
1130
1131 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1132 {
1133   // Get a dependant manager by name.
1134   // This will not change the current manager, use helper class
1135   // AliEveEventManager::CurrentChanger for that.
1136
1137   static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1138
1139   if (fgMaster == 0)
1140     throw(kEH + "Master event-manager must be instantiated first.");
1141
1142   if (fgMaster->fSubManagers == 0)
1143     return 0;
1144
1145   return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1146 }
1147
1148 AliEveEventManager* AliEveEventManager::GetMaster()
1149 {
1150   // Get master event-manager.
1151
1152   return fgMaster;
1153 }
1154
1155 AliEveEventManager* AliEveEventManager::GetCurrent()
1156 {
1157   // Get current event-manager.
1158
1159   return fgCurrent;
1160 }
1161
1162 void AliEveEventManager::RegisterTransient(TEveElement* element)
1163 {
1164   GetCurrent()->fTransients->AddElement(element);
1165 }
1166
1167 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1168 {
1169   GetCurrent()->fTransientLists->AddElement(element);
1170 }
1171
1172 //------------------------------------------------------------------------------
1173 // Autoloading of events
1174 //------------------------------------------------------------------------------
1175
1176 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1177 {
1178   // Set the auto-load time in seconds
1179
1180   fAutoLoadTime = time;
1181 }
1182
1183 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1184 {
1185   // Set the automatic event loading mode
1186
1187   static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1188
1189   if (fAutoLoad == autoLoad)
1190   {
1191     Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1192     return;
1193   }
1194
1195   fAutoLoad = autoLoad;
1196   if (fAutoLoad)
1197   {
1198     StartAutoLoadTimer();
1199   }
1200   else
1201   {
1202     StopAutoLoadTimer();
1203   }
1204 }
1205
1206 void AliEveEventManager::SetTrigSel(Int_t trig)
1207 {
1208   static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1209
1210   if (!fRawReader)
1211     {
1212     Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1213     return;
1214   }
1215   else
1216   {
1217     ULong64_t trigMask = 0;
1218     if (trig >= 0) trigMask = (1ull << trig);
1219     Info(kEH,"Trigger selection: 0x%llx",trigMask);
1220     fRawReader->SelectEvents(-1,trigMask,NULL);
1221   }
1222 }
1223
1224 void AliEveEventManager::StartAutoLoadTimer()
1225 {
1226   // Start the auto-load timer.
1227
1228   fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1229   fAutoLoadTimer->Reset();
1230   fAutoLoadTimer->TurnOn();
1231   fAutoLoadTimerRunning = kTRUE;
1232 }
1233
1234 void AliEveEventManager::StopAutoLoadTimer()
1235 {
1236   // Stop the auto-load timer.
1237
1238   fAutoLoadTimerRunning = kFALSE;
1239   fAutoLoadTimer->TurnOff();
1240 }
1241
1242 void AliEveEventManager::AutoLoadNextEvent()
1243 {
1244   // Called from auto-load timer, so it has to be public.
1245   // Do NOT call it directly.
1246
1247   static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1248
1249   if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1250   {
1251     Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1252     return;
1253   }
1254
1255   StopAutoLoadTimer();
1256   NextEvent();
1257   if (fAutoLoad && !fExternalCtrl)
1258     StartAutoLoadTimer();
1259 }
1260
1261 //------------------------------------------------------------------------------
1262 // Post event-loading functions
1263 //------------------------------------------------------------------------------
1264
1265 void AliEveEventManager::AfterNewEventLoaded()
1266 {
1267   // Execute registered macros and commands.
1268   // At the end emit NewEventLoaded signal.
1269   //
1270   // Virtual from TEveEventManager.
1271
1272   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1273
1274   if (fExecutor)
1275     fExecutor->ExecMacros();
1276
1277   TEveEventManager::AfterNewEventLoaded();
1278
1279   NewEventLoaded();
1280
1281   if (this == fgMaster && fSubManagers != 0)
1282   {
1283     TIter next(fSubManagers);
1284     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1285     {
1286       gEve->SetCurrentEvent(fgCurrent);
1287       try
1288       {
1289         fgCurrent->GotoEvent(fEventId);
1290       }
1291       catch (TEveException& exc)
1292       {
1293         // !!! Should somehow tag / disable / remove it?
1294         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1295               fEventId, fgCurrent->GetName(), exc.Data());
1296       }
1297     }
1298     fgCurrent = fgMaster;
1299     gEve->SetCurrentEvent(fgMaster);
1300   }
1301 }
1302
1303 void AliEveEventManager::NewEventLoaded()
1304 {
1305   // Emit NewEventLoaded signal.
1306
1307   Emit("NewEventLoaded()");
1308 }
1309
1310
1311 //------------------------------------------------------------------------------
1312 // Event info dumpers
1313 //------------------------------------------------------------------------------
1314
1315 TString AliEveEventManager::GetEventInfoHorizontal() const
1316 {
1317   // Dumps the event-header contents in vertical formatting.
1318
1319   TString rawInfo, esdInfo;
1320
1321   if (!fRawReader)
1322   {
1323     rawInfo = "No raw-data event info is available!\n";
1324   }
1325   else
1326   {
1327     const UInt_t* attr = fRawReader->GetAttributes();
1328     TTimeStamp ts(fRawReader->GetTimestamp());
1329     rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1330                  "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
1331                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1332                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1333                  fRawReader->GetClassMask(),
1334                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1335                  attr[0],attr[1],attr[2], ts.AsString("s"));
1336   }
1337
1338   if (!fESD)
1339   {
1340     esdInfo = "No ESD event info is available!";
1341   }
1342   else
1343   {
1344     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1345     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1346     TTimeStamp ts(fESD->GetTimeStamp());
1347     esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1348                  "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
1349                  fESD->GetRunNumber(),
1350                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1351                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1352                  acttrclasses.Data(),
1353                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1354                  fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
1355   }
1356
1357   return rawInfo + esdInfo;
1358 }
1359
1360 TString AliEveEventManager::GetEventInfoVertical() const
1361 {
1362   // Dumps the event-header contents in vertical formatting.
1363
1364   TString rawInfo, esdInfo;
1365
1366   if (!fRawReader)
1367   {
1368     rawInfo = "No raw-data event info is available!\n";
1369   }
1370   else
1371   {
1372     const UInt_t* attr = fRawReader->GetAttributes();
1373     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",
1374                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1375                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1376                  fRawReader->GetClassMask(),
1377                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1378                  attr[0],attr[1],attr[2],
1379                  fRawReader->GetTimestamp());
1380   }
1381
1382   if (!fESD)
1383   {
1384     esdInfo = "No ESD event info is available!\n";
1385   }
1386   else
1387   {
1388     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1389     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1390     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",
1391                  fESD->GetRunNumber(),
1392                  acttrclasses.Data(),
1393                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1394                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1395                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1396                  fESD->GetEventNumberInFile(),
1397                  fESD->GetTimeStamp());
1398   }
1399
1400   return rawInfo + "\n" + esdInfo;
1401 }
1402
1403
1404 //==============================================================================
1405 // Reading of GRP and MagneticField.
1406 // This is a reap-off from reconstruction ... should really be a common
1407 // code to do this somewhere in STEER.
1408 //==============================================================================
1409
1410 Bool_t AliEveEventManager::InitGRP()
1411 {
1412   //------------------------------------
1413   // Initialization of the GRP entry
1414   //------------------------------------
1415
1416   static const TEveException kEH("AliEveEventManager::InitGRP ");
1417
1418   AliGRPManager grpMgr;
1419   if (!grpMgr.ReadGRPEntry()) {
1420     return kFALSE;
1421   }
1422   fgGRPLoaded = kTRUE;
1423   if (!grpMgr.SetMagField()) {
1424     throw kEH + "Setting of field failed!";
1425   }
1426
1427   //*** Get the diamond profiles from OCDB
1428   // Eventually useful.
1429
1430   /*
1431     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1432     if (entry) {
1433     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1434     } else {
1435     ::Error(kEH, "No SPD diamond profile found in OCDB!");
1436     }
1437
1438     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1439     if (entry) {
1440     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1441     } else {
1442     ::Error(kEH, "No diamond profile found in OCDB!");
1443     }
1444
1445     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1446     if (entry) {
1447     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1448     } else {
1449     ::Error(kEH, "No TPC diamond profile found in OCDB!");
1450     }
1451   */
1452
1453   return kTRUE;
1454 }