EVE/EveBase/AliEveEventManager.cxx

   1 // $Id: AliEveEventManager.cxx 64557 2013-10-16 20:03:08Z hristov $
   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
  14 #include <THashList.h>
  15 #include <TEveElement.h>
  16 #include <TEveManager.h>
  17 #include <TEveViewer.h>
  18
  19 #include <AliLog.h>
  20 #include <AliRunLoader.h>
  21 #include <AliRun.h>
  22 #include <AliESDRun.h>
  23 #include <AliESDEvent.h>
  24 #include <AliESDfriend.h>
  25 #include <AliAODEvent.h>
  26
  27 #include <AliRecoParam.h>
  28 #include <AliCentralTrigger.h>
  29 #include <AliCDBEntry.h>
  30 #include <AliTriggerClass.h>
  31 #include <AliTriggerConfiguration.h>
  32 #include <AliTriggerCluster.h>
  33 #include <AliDetectorRecoParam.h>
  34
  35 #include <AliDAQ.h>
  36 #include <AliRawEventHeaderBase.h>
  37 #include <AliRawReaderRoot.h>
  38 #include <AliRawReaderFile.h>
  39 #include <AliRawReaderDate.h>
  40 #include <AliMagF.h>
  41 #include <AliCDBManager.h>
  42 #include <AliCDBStorage.h>
  43 #include <AliGRPObject.h>
  44 #include <AliHeader.h>
  45 #include <AliGeomManager.h>
  46 #include <AliGRPManager.h>
  47 #include <AliSysInfo.h>
  48
  49 #include <TFile.h>
  50 #include <TTree.h>
  51 #include <TGeoManager.h>
  52 #include <TGeoGlobalMagField.h>
  53 #include <TSystem.h>
  54 #include <TTimeStamp.h>
  55 #include <TPRegexp.h>
  56 #include <TError.h>
  57 #include <TEnv.h>
  58 #include <TString.h>
  59 #include <TMap.h>
  60
  61 #ifdef ZMQ
  62 #include "AliStorageEventManager.h"
  63 #endif
  64
  65 //==============================================================================
  66 //==============================================================================
  67 // AliEveEventManager
  68 //==============================================================================
  69
  70 //______________________________________________________________________________
  71 //
  72 // Provides interface for loading and navigating standard AliRoot data
  73 // (AliRunLoader), ESD, AOD and RAW.
  74 //
  75 // ESDfriend is attached automatically, if the file is found.
  76 //
  77 // AODfriends are not attached automatically as there are several
  78 // possible files involved. To have a specific AODfriend attached, call
  79 // static method
  80 //   AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
  81 // before initializing the event-manager.
  82 //
  83 // Also provides interface to magnetic-field and geometry. Mostly
  84 // intended as wrappers over standard AliRoot functionality for
  85 // convenient use from visualizateion macros.
  86 //
  87 // There can be a single main event-manger, it is stored in private
  88 // data member fgMaster and can be accessed via static member function
  89 // GetMaster().
  90 //
  91 // For event overlaying and embedding one can instantiate additional
  92 // event-managers via static method AddDependentManager(const TString& path).
  93 // This interface is under development.
  94
  95 ClassImp(AliEveEventManager)
  96
  97 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
  98 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
  99 Bool_t AliEveEventManager::fgAssertAOD       = kFALSE;
 100 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
 101
 102 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
 103 AliEveEventManager::EVisibleESDTrees  AliEveEventManager::fgESDvisibleTrees(AliEveEventManager::kOfflineTree);
 104 TString  AliEveEventManager::fgESDfriendsFileName("AliESDfriends.root");
 105 TString  AliEveEventManager::fgAODFileName("AliAOD.root");
 106 TString  AliEveEventManager::fgGAliceFileName("galice.root");
 107 TString  AliEveEventManager::fgRawFileName("raw.root");
 108 TString  AliEveEventManager::fgCdbUri;
 109
 110 TList*   AliEveEventManager::fgAODfriends = 0;
 111
 112 Bool_t   AliEveEventManager::fgRawFromStandardLoc = kFALSE;
 113
 114 Bool_t   AliEveEventManager::fgGRPLoaded    = kFALSE;
 115 AliMagF* AliEveEventManager::fgMagField     = 0;
 116 AliRecoParam* AliEveEventManager::fgRecoParam = 0;
 117 Bool_t   AliEveEventManager::fgUniformField = kFALSE;
 118
 119 AliEveEventManager* AliEveEventManager::fgMaster  = 0;
 120 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
 121
 122 void AliEveEventManager::GetNextEvent()
 123 {
 124 #ifdef ZMQ
 125   AliStorageEventManager *eventManager =
 126     AliStorageEventManager::GetEventManagerInstance();
 127   eventManager->CreateSocket(EVENTS_SERVER_SUB);
 128
 129   fCurrentEvent[0]=0;
 130   fCurrentEvent[1]=0;
 131   fCurrentTree[0]=0;
 132   fCurrentTree[1]=0;
 133   AliESDEvent *tmpEvent = NULL;
 134   TTree *tmpTree = NULL;
 135
 136   while(1)
 137   {
 138     //if(tmpEvent){delete tmpEvent;tmpEvent=0;}
 139     tmpEvent = eventManager->GetEvent(EVENTS_SERVER_SUB,-1,&tmpTree);
 140
 141     if(tmpEvent)
 142     {
 143       if(tmpEvent->GetRunNumber()>=0)
 144       {
 145         fMutex.Lock();
 146         if(fEventInUse == 0){fWritingToEventIndex = 1;}
 147         else if(fEventInUse == 1){fWritingToEventIndex = 0;}
 148         cout<<"Writing to:"<<fWritingToEventIndex<<endl;
 149         if(fCurrentEvent[fWritingToEventIndex])
 150         {
 151           cout<<"DELETING:"<<fCurrentEvent[fWritingToEventIndex]<<endl;
 152           delete fCurrentEvent[fWritingToEventIndex];
 153           fCurrentEvent[fWritingToEventIndex]=0;
 154           delete fCurrentTree[fWritingToEventIndex];
 155         }
 156         fCurrentEvent[fWritingToEventIndex] = tmpEvent;
 157         fCurrentTree[fWritingToEventIndex] = tmpTree;
 158         fIsNewEventAvaliable = true;
 159         fMutex.UnLock();
 160       }
 161     }
 162   }
 163 #endif
 164 }
 165
 166 void AliEveEventManager::InitInternals()
 167 {
 168     // Initialize internal members.
 169
 170     static const TEveException kEH("AliEveEventManager::InitInternals ");
 171
 172     if (fgCurrent != 0)
 173     {
 174         throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
 175     }
 176
 177     if (fgMaster == 0)
 178     {
 179         fgMaster = this;
 180     }
 181
 182     fgCurrent = this;
 183
 184     fAutoLoadTimer = new TTimer;
 185     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
 186     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "Timeout()");
 187
 188     fExecutor = new AliEveMacroExecutor;
 189
 190     fTransients = new TEveElementList("Transients", "Transient per-event elements.");
 191     fTransients->IncDenyDestroy();
 192     gEve->AddToListTree(fTransients, kFALSE);
 193
 194     fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
 195     fTransientLists->IncDenyDestroy();
 196     gEve->AddToListTree(fTransientLists, kFALSE);
 197
 198     fPEventSelector = new AliEveEventSelector(this);
 199
 200     fGlobal = new TMap; fGlobal->SetOwnerKeyValue();
 201 }
 202
 203 AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
 204     TEveEventManager(name, ""),
 205     fEventId(-1),
 206     fRunLoader (0),
 207     fESDFile   (0), fESDTree (0), fHLTESDTree(0), fESD (0),
 208     fESDfriend (0), fESDfriendExists(kFALSE),
 209     fAODFile   (0), fAODTree (0), fAOD (0),
 210     fRawReader (0), fEventInfo(),
 211     fAutoLoad  (kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
 212     fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
 213     fGlobal    (0), fGlobalReplace (kTRUE), fGlobalUpdate (kTRUE),
 214     fExecutor    (0), fTransients(0), fTransientLists(0),
 215     fPEventSelector(0),
 216     fSubManagers (0),
 217     fAutoLoadTimerRunning(kFALSE),
 218     fgSubSock(EVENTS_SERVER_SUB),
 219     fEventInUse(1),
 220     fWritingToEventIndex(0),
 221     fIsNewEventAvaliable(false)
 222 {
 223     // Constructor with event-id.
 224
 225     InitInternals();
 226
 227     Open();
 228     if (ev >= 0)
 229     {
 230         GotoEvent(ev);
 231     }
 232
 233 #ifdef ZMQ
 234     cout<<"ZMQ FOUND. Starting subscriber thread."<<endl;
 235     fGetEventThread = new TThread("fGetEventThread",Dispatch,(void*)this);
 236     fGetEventThread->Run();
 237 #else
 238     cout<<"NO ZMQ FOUND. Online events not avaliable."<<endl;
 239 #endif
 240 }
 241
 242 AliEveEventManager::~AliEveEventManager()
 243 {
 244     // Destructor.
 245     fAutoLoadTimer->Stop();
 246     fAutoLoadTimer->Disconnect("Timeout");
 247
 248     delete fSubManagers;
 249
 250     if (fIsOpen)
 251     {
 252         Close();
 253     }
 254
 255     fTransients->DecDenyDestroy();
 256     fTransients->Destroy();
 257
 258     fTransientLists->DecDenyDestroy();
 259     fTransientLists->Destroy();
 260
 261     //delete fExecutor;
 262 }
 263
 264 /******************************************************************************/
 265
 266 void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
 267 {
 268     fgESDvisibleTrees = shown;
 269     // Set file-name for opening ESD, default "AliESDs.root".
 270     if (esd.IsNull()) return;
 271
 272     fgESDFileName = esd;
 273     if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
 274
 275 }
 276
 277 void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
 278 {
 279     // Set file-name for opening ESD friend, default "AliESDfriends.root".
 280
 281     if (esdf.IsNull()) return;
 282     fgESDfriendsFileName = esdf;
 283
 284     if (esdf.EndsWith(".zip")) fgESDfriendsFileName.Form("%s#AliESDfriends.root",esdf.Data());
 285 }
 286
 287 void AliEveEventManager::SetAODFileName(const TString& aod)
 288 {
 289     // Set file-name for opening AOD, default "AliAOD.root".
 290
 291     if (aod.IsNull()) return;
 292     fgAODFileName = aod;
 293
 294     if (aod.EndsWith(".zip")) fgAODFileName.Form("%s#AliAOD.root",aod.Data());
 295
 296 }
 297
 298 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
 299 {
 300     // Add new AOD friend file-name to be attached when opening AOD.
 301     // This should include '.root', as in 'AliAOD.VertexingHF.root'.
 302
 303     if (fgAODfriends == 0)
 304     {
 305         fgAODfriends = new TList;
 306         fgAODfriends->SetOwner(kTRUE);
 307     }
 308     if (fgAODfriends->FindObject(friendFileName) == 0)
 309     {
 310         fgAODfriends->Add(new TObjString(friendFileName));
 311     }
 312 }
 313
 314 void AliEveEventManager::SetRawFileName(const TString& raw)
 315 {
 316     // Set file-name for opening of raw-data, default "raw.root"
 317     if (raw.IsNull()) return;
 318
 319     fgRawFileName = raw;
 320 }
 321
 322 void AliEveEventManager::SetCdbUri(const TString& cdb)
 323 {
 324     // Set path to CDB, there is no default.
 325     if ( ! cdb.IsNull()) fgCdbUri = cdb;
 326 }
 327
 328 void AliEveEventManager::SetGAliceFileName(const TString& galice)
 329 {
 330     // Set file-name for opening gAlice, default "galice.root".
 331
 332     if ( galice.IsNull()) return;
 333     fgGAliceFileName = galice;
 334
 335     if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
 336 }
 337
 338 void AliEveEventManager::SetFilesPath(const TString& urlPath)
 339 {
 340     TString path = urlPath;
 341     gSystem->ExpandPathName(path);
 342     if (path.IsNull() || path == ".")
 343     {
 344         path = gSystem->WorkingDirectory();
 345     }
 346
 347     TString sep;
 348     if(path.EndsWith(".zip")) // if given a path to root_archive.zip
 349         sep= "#";
 350     else if(!path.EndsWith("/"))
 351         sep = "/";
 352
 353     SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
 354     SetESDfriendFileName(  TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
 355     SetAODFileName(  TString(Form("%s%sAliAOD.root", path.Data(), sep.Data())) );
 356     AddAODfriend(  TString(Form("%s%sAliAOD.VertexingHF.root", path.Data(), sep.Data())) );
 357     SetGAliceFileName( TString(Form("%s%sgalice.root", path.Data(), sep.Data())) );
 358     SetRawFileName(TString(Form("%s%sraw.root", path.Data(), sep.Data())));
 359 }
 360
 361 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
 362                                            Bool_t assertAod, Bool_t assertRaw)
 363 {
 364     // Set global flags that detrmine which parts of the event-data must
 365     // be present when the event is opened.
 366
 367     fgAssertRunLoader = assertRunloader;
 368     fgAssertESD = assertEsd;
 369     fgAssertAOD = assertAod;
 370     fgAssertRaw = assertRaw;
 371 }
 372
 373 void AliEveEventManager::SearchRawForCentralReconstruction()
 374 {
 375     // Enable searching of raw data in standard location. The path passed to
 376     // Open() is expected to point to a centrally reconstructed run, e.g.:
 377     // "alien:///alice/data/2009/LHC09c/000101134/ESDs/pass1/09000101134018.10".
 378
 379     fgRawFromStandardLoc = kTRUE;
 380 }
 381
 382 /******************************************************************************/
 383
 384 void AliEveEventManager::Open()
 385 {
 386     // Open event-data from URL specified in path.
 387     // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
 388     // Warning is reported if run-loader or ESD is not found.
 389     // Global data-members fgAssertRunLoader and fgAssertESD can be set
 390     // to throw exceptions instead.
 391
 392     static const TEveException kEH("AliEveEventManager::Open ");
 393
 394     if (fExternalCtrl)
 395     {
 396         throw (kEH + "Event-loop is under external control.");
 397     }
 398     if (fIsOpen)
 399     {
 400         throw (kEH + "Event-files already opened.");
 401     }
 402
 403     Int_t runNo = -1;
 404
 405     // Open ESD and ESDfriends
 406
 407     if ((fESDFile = TFile::Open(fgESDFileName)))
 408     {
 409         fESD = new AliESDEvent();
 410
 411         switch(fgESDvisibleTrees){
 412         case AliEveEventManager::kOfflineTree :
 413             fESDTree = readESDTree("esdTree", runNo);
 414             break;
 415         case AliEveEventManager::kHLTTree :
 416             fHLTESDTree = readESDTree("HLTesdTree", runNo);
 417             break;
 418         default:
 419             fESDTree    = readESDTree("esdTree", runNo);
 420             fHLTESDTree = readESDTree("HLTesdTree", runNo);
 421         }
 422
 423         if(!fESDTree && !fHLTESDTree){
 424             // both ESD trees are == 0
 425             delete fESDFile; fESDFile = 0;
 426             delete fESD; fESD = 0;
 427         }
 428
 429
 430     }
 431     else // esd file not readable
 432     {
 433         Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
 434     }
 435     if (fESDTree == 0 && fHLTESDTree==0)
 436     {
 437         if (fgAssertESD)
 438         {
 439             throw (kEH + "ESD not initialized. Its precence was requested.");
 440         } else {
 441             Warning(kEH, "ESD not initialized.");
 442         }
 443     }
 444
 445     // Open AOD and registered friends
 446     if ( (fAODFile = TFile::Open(fgAODFileName)) )
 447     {
 448         fAOD = new AliAODEvent();
 449         fAODTree = (TTree*) fAODFile->Get("aodTree");
 450         if (fAODTree != 0)
 451         {
 452             // Check if AODfriends exist and attach them.
 453             TIter       friends(fgAODfriends);
 454             TObjString *name;
 455             while ((name = (TObjString*) friends()) != 0)
 456             {
 457                 TString p(Form("%s/%s", fgAODFileName.Data(), name->GetName()));
 458                 if (fgAODFileName.EndsWith(".zip")) p.Form("%s#%s",fgAODFileName.Data(),name->GetName());
 459                 if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
 460                 {
 461                     fAODTree->AddFriend("aodTree", name->GetName());
 462                 }
 463             }
 464
 465             fAOD->ReadFromTree(fAODTree);
 466
 467             if (fAODTree->GetEntry(0) <= 0)
 468             {
 469                 delete fAODFile; fAODFile = 0;
 470                 delete fAOD;     fAOD     = 0;
 471                 Warning(kEH, "failed getting the first entry from addTree.");
 472             }
 473             else
 474             {
 475                 if (runNo < 0)
 476                     runNo = fAOD->GetRunNumber();
 477             }
 478         }
 479         else // aodtree == 0
 480         {
 481             delete fAODFile; fAODFile = 0;
 482             delete fAOD;     fAOD     = 0;
 483             Warning(kEH, "failed getting the aodTree.");
 484         }
 485     }
 486     else // aod not readable
 487     {
 488         Warning(kEH, "can not read AOD file '%s'.", fgAODFileName.Data());
 489     }
 490     if (fAODTree == 0)
 491     {
 492         if (fgAssertAOD)
 493         {
 494             throw (kEH + "AOD not initialized. Its precence was requested.");
 495         } else {
 496             Warning(kEH, "AOD not initialized.");
 497         }
 498     }
 499
 500     // Open RunLoader from galice.root
 501     TFile *gafile = TFile::Open(fgGAliceFileName);
 502     if (gafile)
 503     {
 504         gafile->Close();
 505         delete gafile;
 506         fRunLoader = AliRunLoader::Open(fgGAliceFileName, GetName());
 507         if (fRunLoader)
 508         {
 509             TString alicePath(gSystem->DirName(fgGAliceFileName));
 510             alicePath.Append("/");
 511             fRunLoader->SetDirName(alicePath);
 512
 513             if (fRunLoader->LoadgAlice() != 0)
 514                 Warning(kEH, "failed loading gAlice via run-loader.");
 515
 516             if (fRunLoader->LoadHeader() == 0)
 517             {
 518                 if (runNo < 0)
 519                     runNo = fRunLoader->GetHeader()->GetRun();
 520             }
 521             else
 522             {
 523                 Warning(kEH, "failed loading run-loader's header.");
 524                 delete fRunLoader;
 525                 fRunLoader = 0;
 526             }
 527         }
 528         else // run-loader open failed
 529         {
 530             Warning(kEH, "failed opening ALICE run-loader from '%s'.", fgGAliceFileName.Data());
 531         }
 532
 533     }
 534     else // galice not readable
 535     {
 536         Warning(kEH, "can not read '%s'.", fgGAliceFileName.Data());
 537     }
 538     if (fRunLoader == 0)
 539     {
 540         if (fgAssertRunLoader)
 541             throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
 542         else
 543             Warning(kEH, "Bootstraping of run-loader failed.");
 544     }
 545
 546     // Open raw-data file
 547
 548     TString rawPath;
 549     if (fgRawFromStandardLoc)
 550     {
 551         if (!fgRawFileName.BeginsWith("alien:"))
 552             throw kEH + "Standard raw search requested, but the directory is not in AliEn.";
 553         if (!fgRawFileName.Contains("/ESDs/"))
 554             throw kEH + "Standard raw search requested, but does not contain 'ESDs' directory.";
 555
 556         TPMERegexp chunk("/([\\d\\.])+/?$");
 557         Int_t nm = chunk.Match(fgRawFileName);
 558         if (nm != 2)
 559             throw kEH + "Standard raw search requested, but the path does not end with chunk-id directory.";
 560
 561         TPMERegexp esdstrip("/ESDs/.*");
 562         rawPath = fgRawFileName;
 563         esdstrip.Substitute(rawPath, "/raw/");
 564         rawPath += chunk[0];
 565         rawPath += ".root";
 566
 567         Info(kEH, "Standard raw search requested, using the following path:\n  %s\n", rawPath.Data());
 568     }
 569     else
 570     {
 571         rawPath = fgRawFileName;
 572     }
 573     // If i use open directly, raw-reader reports an error but i have
 574     // no way to detect it.
 575     // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
 576     AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
 577     if (fgAssertRaw == kFALSE)
 578     {
 579         AliLog::SetGlobalLogLevel(AliLog::kFatal);
 580     }
 581     if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
 582     {
 583         fRawReader = AliRawReader::Create(rawPath);
 584     }
 585     else
 586     {
 587         fRawReader = AliRawReader::Create(fgRawFileName);
 588     }
 589     if (fgAssertRaw == kFALSE)
 590     {
 591         AliLog::SetGlobalLogLevel(oldLogLevel);
 592     }
 593
 594     if (fRawReader == 0)
 595     {
 596         if (fgAssertRaw)
 597         {
 598             throw (kEH + "raw-data not initialized. Its precence was requested.");
 599         }
 600         else
 601         {
 602             Warning(kEH, "raw-data not initialized.");
 603         }
 604     }
 605
 606     if (runNo < 0)
 607     {
 608         if (fRawReader)
 609         {
 610             if ( ! fRawReader->NextEvent())
 611             {
 612                 throw (kEH + "can not go to first event in raw-reader to determine run-id.");
 613             }
 614             runNo = fRawReader->GetRunNumber();
 615             Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
 616             fRawReader->RewindEvents();
 617         }
 618         else
 619         {
 620             fExternalCtrl = kTRUE;
 621              fEventId = 0;
 622             return;
 623         }
 624     }
 625
 626     // Initialize OCDB ... only in master event-manager
 627
 628                 InitOCDB(runNo);
 629
 630
 631     fIsOpen = kTRUE;
 632 }
 633
 634 void AliEveEventManager::InitOCDB(int runNo)
 635 {
 636                 static const TEveException kEH("AliEveEventManager::InitOCDB ");
 637     //if (this == fgMaster)
 638     {
 639         AliCDBManager* cdb = AliCDBManager::Instance();
 640         if (cdb->IsDefaultStorageSet() == kTRUE)
 641         {
 642             Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
 643                     cdb->GetDefaultStorage()->GetURI().Data());
 644         }
 645         else
 646         {
 647             if (fgCdbUri.IsNull())
 648             {
 649                 gEnv->SetValue("Root.Stacktrace", "no");
 650                 Fatal("Open()", "OCDB path was not specified.");
 651             }
 652
 653             // Handle some special cases for MC (should be in OCDBManager).
 654             if (fgCdbUri == "mcideal://")
 655                 cdb->SetDefaultStorage("MC", "Ideal");
 656             else if (fgCdbUri == "mcresidual://")
 657                 cdb->SetDefaultStorage("MC", "Residual");
 658             else if (fgCdbUri == "mcfull://")
 659                 cdb->SetDefaultStorage("MC", "Full");
 660             else if (fgCdbUri == "local://") {
 661                 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
 662                 cdb->SetDefaultStorage(fgCdbUri);
 663             } else
 664                 cdb->SetDefaultStorage(fgCdbUri);
 665
 666             cdb->SetRun(runNo);
 667
 668             if (cdb->IsDefaultStorageSet() == kFALSE)
 669                 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
 670         }
 671
 672         if (fgCdbUri.BeginsWith("local://"))
 673         {
 674             TString curPath = gSystem->WorkingDirectory();
 675             TString grp     = "GRP/GRP/Data";
 676             TString grppath = curPath + "/" + grp;
 677             if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
 678             {
 679                 if (cdb->GetSpecificStorage(grp))
 680                 {
 681                     Warning(kEH, "Local GRP exists, but the specific storage is already set.");
 682                 }
 683                 else
 684                 {
 685                     Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
 686                     TString lpath("local://");
 687                     lpath += curPath;
 688                     cdb->SetSpecificStorage(grp, lpath);
 689                 }
 690             }
 691         }
 692     }
 693 }
 694
 695 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
 696 {
 697     // Set an event from an external source.
 698     // The method is used in the online visualisation.
 699     // AOD is not supported.
 700
 701     static const TEveException kEH("AliEveEventManager::SetEvent ");
 702
 703     if (fIsOpen)
 704     {
 705         Warning(kEH, "Event-files were open. Closing and switching to external control.");
 706         Close();
 707     }
 708
 709                         Info(kEH,"setting it!!! ============================");
 710
 711     fRunLoader = runLoader;
 712     fRawReader = rawReader;
 713     fESD       = esd;
 714     fESDfriend = esdf;
 715     fAOD       = 0;
 716
 717     fEventId++;
 718     fHasEvent     = kTRUE;
 719     fExternalCtrl = kTRUE;
 720
 721     SetTitle("Online event in memory");
 722     SetName ("Online Event");
 723     ElementChanged();
 724
 725     AfterNewEventLoaded();
 726
 727     if (fAutoLoad) StartAutoLoadTimer();
 728
 729 }
 730
 731 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
 732 {
 733     // Returns maximum available event id.
 734     // If under external control or event is not opened -1 is returned.
 735     // If raw-data is the only data-source this can not be known
 736     // and 10,000,000 is returned.
 737     // If neither data-source is initialised an exception is thrown.
 738     // If refresh_esd is true and ESD is the primary event-data source
 739     // its header is re-read from disk.
 740
 741     static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
 742
 743     if (fExternalCtrl || fIsOpen == kFALSE)
 744     {
 745         return -1;
 746     }
 747
 748     if ((fESDTree!=0) || (fHLTESDTree!=0))
 749     {
 750         if (refreshESD)
 751         {
 752             if(fESDTree!=0) fESDTree->Refresh();
 753             if(fHLTESDTree!=0) fHLTESDTree->Refresh();
 754             fPEventSelector->Update();
 755         }
 756
 757         Int_t maxEventId=0;
 758         switch(fgESDvisibleTrees){
 759         default:
 760         case AliEveEventManager::kOfflineTree :
 761             maxEventId = fESDTree->GetEntries() - 1;
 762             break;
 763         case AliEveEventManager::kHLTTree :
 764             maxEventId = fHLTESDTree->GetEntries() - 1;
 765             break;
 766        }
 767
 768         return maxEventId;
 769     }
 770     else if (fAODTree)
 771     {
 772         return fAODTree->GetEntries() - 1;
 773     }
 774     else if (fRunLoader)
 775     {
 776         return fRunLoader->GetNumberOfEvents() - 1;
 777     }
 778     else if (fRawReader)
 779     {
 780         Int_t n = fRawReader->GetNumberOfEvents() - 1;
 781         return n > -1 ? n : 10000000;
 782     }
 783     else
 784     {
 785         throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
 786     }
 787 }
 788
 789 void AliEveEventManager::GotoEvent(Int_t event)
 790 {
 791     // Load data for specified event.
 792     // If event is out of range an exception is thrown and old state
 793     // is preserved.
 794     // After successful loading of event, the virtual function
 795     // AfterNewEventLoaded() is called. This executes commands that
 796     // were registered via TEveEventManager::AddNewEventCommand().
 797     //
 798     // If event is negative, it is subtracted from the number of
 799     // available events, thus passing -1 will load the last event.
 800     // This is not supported when raw-data is the only data-source
 801     // as the number of events is not known.
 802
 803     static const TEveException kEH("AliEveEventManager::GotoEvent ");
 804
 805     if (fAutoLoadTimerRunning)
 806     {
 807         throw (kEH + "Event auto-load timer is running.");
 808     }
 809     if (fExternalCtrl)
 810     {
 811         throw (kEH + "Event-loop is under external control.");
 812     }
 813     else if (!fIsOpen)
 814     {
 815         throw (kEH + "Event-files not opened.");
 816     }
 817
 818     fEventInfo.Reset();
 819
 820     fHasEvent = kFALSE;
 821
 822     Int_t maxEvent = 0;
 823     if ((fESDTree!=0) || (fHLTESDTree!=0))
 824     {
 825         if(fESDTree){
 826             if (event >= fESDTree->GetEntries())
 827                 fESDTree->Refresh();
 828             maxEvent = fESDTree->GetEntries() - 1;
 829             if (event < 0)
 830                 event = fESDTree->GetEntries() + event;
 831         }
 832
 833         if(fHLTESDTree){
 834             if (event >= fHLTESDTree->GetEntries())
 835                 fHLTESDTree->Refresh();
 836             maxEvent = fHLTESDTree->GetEntries() - 1;
 837             if (event < 0)
 838                 event = fHLTESDTree->GetEntries() + event;
 839
 840         }
 841     }
 842     else if (fAODTree)
 843     {
 844         maxEvent = fAODTree->GetEntries() - 1;
 845         if (event < 0)
 846             event = fAODTree->GetEntries() + event;
 847     }
 848     else if (fRunLoader)
 849     {
 850         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
 851         if (event < 0)
 852             event = fRunLoader->GetNumberOfEvents() + event;
 853     }
 854     else if (fRawReader)
 855     {
 856         maxEvent = fRawReader->GetNumberOfEvents() - 1;
 857         if (maxEvent < 0)
 858         {
 859             maxEvent = 10000000;
 860             if (event < 0) {
 861                 Error(kEH, "current raw-data source does not support direct event access.");
 862                 return;
 863             }
 864             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
 865         }
 866         else
 867         {
 868             if (event < 0)
 869                 event = fRawReader->GetNumberOfEvents() + event;
 870         }
 871     }
 872     else
 873     {
 874         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
 875     }
 876     if (event < 0 || event > maxEvent)
 877     {
 878         throw (kEH + Form("event %d not present, available range [%d, %d].",
 879                           event, 0, maxEvent));
 880     }
 881
 882     TString sysInfoHeader;
 883     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
 884     AliSysInfo::AddStamp(sysInfoHeader + "Start");
 885
 886     TEveManager::TRedrawDisabler rd(gEve);
 887     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
 888
 889     // !!! MT this is somewhat brutal; at least optionally, one could be
 890     // a bit gentler, checking for objs owning their external refs and having
 891     // additinal parents.
 892     gEve->GetViewers()->DeleteAnnotations();
 893     fTransients->DestroyElements();
 894     for (TEveElement::List_i i = fTransientLists->BeginChildren();
 895          i != fTransientLists->EndChildren(); ++i)
 896     {
 897         (*i)->DestroyElements();
 898     }
 899     DestroyElements();
 900
 901     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
 902
 903     if (fESDTree) {
 904         if (fESDTree->GetEntry(event) <= 0)
 905             throw (kEH + "failed getting required event from ESD.");
 906
 907         if (fESDfriendExists)
 908             fESD->SetESDfriend(fESDfriend);
 909     }
 910
 911     if (fHLTESDTree) {
 912         if (fHLTESDTree->GetEntry(event) <= 0)
 913             throw (kEH + "failed getting required event from HLT ESD.");
 914
 915         if (fESDfriendExists)
 916             fESD->SetESDfriend(fESDfriend);
 917     }
 918
 919     if (fAODTree) {
 920         if (fAODTree->GetEntry(event) <= 0)
 921             throw (kEH + "failed getting required event from AOD.");
 922     }
 923
 924     if (fRunLoader) {
 925         if (fRunLoader->GetEvent(event) != 0)
 926             throw (kEH + "failed getting required event.");
 927     }
 928
 929     if (fRawReader)
 930     {
 931         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
 932         if (fRawReader->GotoEvent(event) == kFALSE)
 933         {
 934             // Use fallback method - iteration with NextEvent().
 935             Int_t rawEv = fEventId;
 936             if (event < rawEv)
 937             {
 938                 fRawReader->RewindEvents();
 939                 rawEv = -1;
 940             }
 941
 942             while (rawEv < event)
 943             {
 944                 if ( ! fRawReader->NextEvent())
 945                 {
 946                     fRawReader->RewindEvents();
 947                     fEventId = -1;
 948                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
 949                 }
 950                 ++rawEv;
 951             }
 952             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
 953         }
 954     }
 955
 956     fHasEvent = kTRUE;
 957     fEventId  = event;
 958     if (this == fgMaster)
 959     {
 960         SetName(Form("Event %d", fEventId));
 961         ElementChanged();
 962     }
 963
 964     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
 965
 966     AfterNewEventLoaded();
 967
 968     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
 969 }
 970
 971 void AliEveEventManager::Timeout()
 972 {
 973     Emit("Timeout()");
 974 }
 975
 976 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
 977 {
 978         DestroyElements();
 979
 980         InitOCDB(event->GetRunNumber());
 981
 982         printf("======================= setting event to %d\n", fEventId);
 983         SetEvent(0,0,event,0);
 984 }
 985
 986 void AliEveEventManager::NextEvent()
 987 {
 988     // Loads next event.
 989     // Does magick needed for online display when under external event control.
 990
 991     static const TEveException kEH("AliEveEventManager::NextEvent ");
 992
 993     if (fAutoLoadTimerRunning)
 994     {
 995         throw (kEH + "Event auto-load timer is running.");
 996     }
 997
 998     if (fExternalCtrl)
 999     {
1000 #ifdef ZMQ
1001
1002       cout<<fIsNewEventAvaliable<<"\t"<<"\t"<<fWritingToEventIndex<<endl;
1003
1004       if(fIsNewEventAvaliable)
1005       {
1006         cout<<"new event"<<endl;
1007         fMutex.Lock();
1008         if(fWritingToEventIndex == 0) fEventInUse = 0;
1009         else if(fWritingToEventIndex == 1) fEventInUse = 1;
1010         cout<<"Using:"<<fEventInUse<<endl;
1011
1012         if(fCurrentEvent[fEventInUse])
1013         {
1014           if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1015           {
1016             printf("======================= setting event to %d\n", fEventId);
1017
1018             DestroyElements();
1019             InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1020             SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1021           }
1022         }
1023         fIsNewEventAvaliable = false;
1024         fMutex.UnLock();
1025       }
1026       else{cout<<"No new event is avaliable."<<endl;}
1027
1028 #endif
1029     }
1030     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1031     {
1032       Int_t nextevent=0;
1033       if (fPEventSelector->FindNext(nextevent))
1034       {
1035         GotoEvent(nextevent);
1036       }
1037     }
1038     else if (fEventId < GetMaxEventId(kTRUE))
1039     {
1040       GotoEvent(fEventId + 1);
1041     }
1042
1043     gSystem->ProcessEvents();
1044
1045     //if(fGetEventThread){delete fGetEventThread;fGetEventThread=0;}
1046 }
1047
1048 void AliEveEventManager::PrevEvent()
1049 {
1050     // Loads previous event.
1051
1052     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1053
1054     if (fAutoLoadTimerRunning)
1055     {
1056         throw (kEH + "Event auto-load timer is running.");
1057     }
1058     if (fExternalCtrl)
1059     {
1060         throw (kEH + "Event-loop is under external control.");
1061     }
1062
1063     if ((fESDTree!=0) || (fHLTESDTree!=0))
1064     {
1065         Int_t nextevent=0;
1066         if (fPEventSelector->FindPrev(nextevent))
1067         {
1068             GotoEvent(nextevent);
1069         }
1070     }
1071     else if (fEventId > 0)
1072     {
1073         GotoEvent(fEventId - 1);
1074     }
1075 }
1076
1077 void AliEveEventManager::MarkCurrentEvent()
1078 {
1079 #ifdef ZMQ
1080         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1081         struct eventStruct mark;
1082         mark.runNumber = fESD->GetRunNumber();
1083         mark.eventNumber = fESD->GetEventNumberInFile();
1084         requestMessage->messageType = REQUEST_MARK_EVENT;
1085         requestMessage->event = mark;
1086
1087         AliStorageEventManager *eventManager =
1088                 AliStorageEventManager::GetEventManagerInstance();
1089         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1090
1091         /*
1092         std::future<bool> unused = std::async([]()
1093         {
1094                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1095                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1096
1097                 if(response)
1098                 {
1099                 //fStatusLabel->SetText("Event marked");
1100                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1101                 }
1102                 else
1103                 {
1104                 //fStatusLabel->SetText("Couldn't mark this event");
1105                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1106                 }
1107         });
1108         */
1109
1110         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1111         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1112
1113
1114         if(response)
1115         {
1116                 //fStatusLabel->SetText("Event marked");
1117                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1118         }
1119         else
1120         {
1121                 //fStatusLabel->SetText("Couldn't mark this event");
1122                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1123         }
1124         if(requestMessage){delete requestMessage;}
1125 #endif
1126 }
1127
1128 void AliEveEventManager::Close()
1129 {
1130     // Close the event data-files and delete ESD, ESDfriend, run-loader
1131     // and raw-reader.
1132
1133     static const TEveException kEH("AliEveEventManager::Close ");
1134
1135     if (!fIsOpen)
1136     {
1137         throw (kEH + "Event-files not opened.");
1138     }
1139
1140     if (fAutoLoadTimerRunning)
1141         StopAutoLoadTimer();
1142
1143     if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1144         delete fESD;       fESD       = 0;
1145         // delete fESDfriend; // friend tree is deleted with the tree
1146         fESDfriend = 0;
1147         fESDfriendExists = kFALSE;
1148
1149         if(fESDTree) { delete fESDTree;   fESDTree = 0; }
1150         if(fHLTESDTree) { delete fHLTESDTree;   fHLTESDTree = 0; }
1151         delete fESDFile;   fESDFile = 0;
1152     }
1153
1154     if (fAODTree) {
1155         delete fAOD;       fAOD       = 0;
1156
1157         delete fAODTree;   fAODTree = 0;
1158         delete fAODFile;   fAODFile = 0;
1159     }
1160
1161     if (fRunLoader) {
1162         delete fRunLoader; fRunLoader = 0;
1163     }
1164
1165     if (fRawReader) {
1166         delete fRawReader; fRawReader = 0;
1167     }
1168
1169     fEventId  = -1;
1170     fIsOpen   = kFALSE;
1171     fHasEvent = kFALSE;
1172 }
1173
1174
1175 //------------------------------------------------------------------------------
1176 // Static convenience functions, mainly used from macros.
1177 //------------------------------------------------------------------------------
1178
1179 Int_t AliEveEventManager::CurrentEventId()
1180 {
1181     // Return current event-id.
1182
1183     static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1184
1185     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1186         throw (kEH + "ALICE event not ready.");
1187     return fgCurrent->GetEventId();
1188 }
1189
1190 Bool_t AliEveEventManager::HasRunLoader()
1191 {
1192     // Check if AliRunLoader is initialized.
1193
1194     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1195 }
1196
1197 Bool_t AliEveEventManager::HasESD()
1198 {
1199     // Check if AliESDEvent is initialized.
1200
1201     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1202 }
1203
1204 Bool_t AliEveEventManager::HasESDfriend()
1205 {
1206     // Check if AliESDfriend is initialized.
1207
1208     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1209 }
1210
1211 Bool_t AliEveEventManager::HasAOD()
1212 {
1213     // Check if AliESDEvent is initialized.
1214
1215     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1216 }
1217
1218 Bool_t AliEveEventManager::HasRawReader()
1219 {
1220     // Check if raw-reader is initialized.
1221
1222     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1223 }
1224
1225 AliRunLoader* AliEveEventManager::AssertRunLoader()
1226 {
1227     // Make sure AliRunLoader is initialized and return it.
1228     // Throws exception in case run-loader is not available.
1229     // Static utility for macros.
1230
1231     static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
1232
1233     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1234         throw (kEH + "ALICE event not ready.");
1235     if (fgCurrent->fRunLoader == 0)
1236         throw (kEH + "AliRunLoader not initialised.");
1237     return fgCurrent->fRunLoader;
1238 }
1239
1240 AliESDEvent* AliEveEventManager::AssertESD()
1241 {
1242     // Make sure AliESDEvent is initialized and return it.
1243     // Throws exception in case ESD is not available.
1244     // Static utility for macros.
1245
1246     static const TEveException kEH("AliEveEventManager::AssertESD ");
1247
1248     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1249         throw (kEH + "ALICE event not ready.");
1250     if (fgCurrent->fESD == 0)
1251         throw (kEH + "AliESD not initialised.");
1252     return fgCurrent->fESD;
1253 }
1254
1255 AliESDfriend* AliEveEventManager::AssertESDfriend()
1256 {
1257     // Make sure AliESDfriend is initialized and return it.
1258     // Throws exception in case ESDfriend-loader is not available.
1259     // Static utility for macros.
1260
1261     static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1262
1263     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1264         throw (kEH + "ALICE event not ready.");
1265     if (fgCurrent->fESDfriend == 0)
1266         throw (kEH + "AliESDfriend not initialised.");
1267     return fgCurrent->fESDfriend;
1268 }
1269
1270 AliAODEvent* AliEveEventManager::AssertAOD()
1271 {
1272     // Make sure AliAODEvent is initialized and return it.
1273     // Throws exception in case AOD is not available.
1274     // Static utility for macros.
1275
1276     static const TEveException kEH("AliEveEventManager::AssertAOD ");
1277
1278     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1279         throw (kEH + "ALICE event not ready.");
1280     if (fgCurrent->fAOD == 0)
1281         throw (kEH + "AliAOD not initialised.");
1282     return fgCurrent->fAOD;
1283 }
1284
1285 AliRawReader* AliEveEventManager::AssertRawReader()
1286 {
1287     // Make sure raw-reader is initialized and return it.
1288
1289     static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1290
1291     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1292         throw (kEH + "ALICE event not ready.");
1293     if (fgCurrent->fRawReader == 0)
1294         throw (kEH + "RawReader not ready.");
1295
1296     return fgCurrent->fRawReader;
1297 }
1298
1299 //==============================================================================
1300
1301 AliMagF* AliEveEventManager::AssertMagField()
1302 {
1303     // Make sure AliMagF is initialized and returns it.
1304     // Throws exception in case magnetic field is not available.
1305     // Static utility for macros.
1306
1307     static const TEveException kEH("AliEveEventManager::AssertMagField ");
1308
1309     if (fgMagField)
1310         return fgMagField;
1311
1312     if (TGeoGlobalMagField::Instance()->GetField())
1313     {
1314         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1315         if (fgMagField == 0)
1316             throw kEH + "Global field set, but it is not AliMagF.";
1317         return fgMagField;
1318     }
1319
1320     if (!fgGRPLoaded)
1321     {
1322         InitGRP();
1323     }
1324
1325     if (TGeoGlobalMagField::Instance()->GetField())
1326     {
1327         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1328         if (fgMagField == 0)
1329             throw kEH + "Global field set, but it is not AliMagF.";
1330     }
1331     else
1332     {
1333         throw kEH + "Could not initialize magnetic field.";
1334     }
1335
1336     return fgMagField;
1337 }
1338
1339 TGeoManager* AliEveEventManager::AssertGeometry()
1340 {
1341     // Make sure AliGeomManager is initialized and returns the
1342     // corresponding TGeoManger.
1343     // gGeoManager is set to the return value.
1344     // Throws exception if geometry can not be loaded or if it is not
1345     // available and the TGeoManager is locked.
1346     // Static utility for macros.
1347
1348     static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1349
1350     if (AliGeomManager::GetGeometry() == 0)
1351     {
1352         if (TGeoManager::IsLocked())
1353             throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1354
1355         gGeoManager = 0;
1356         AliGeomManager::LoadGeometry();
1357         if ( ! AliGeomManager::GetGeometry())
1358         {
1359             throw (kEH + "can not load geometry.");
1360         }
1361         if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1362         {
1363             ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1364             // throw (kEH + "could not apply align objs.");
1365         }
1366         AliGeomManager::GetGeometry()->DefaultColors();
1367     }
1368
1369     gGeoManager = AliGeomManager::GetGeometry();
1370     return gGeoManager;
1371 }
1372
1373 AliRecoParam* AliEveEventManager::AssertRecoParams()
1374 {
1375     if(!fgRecoParam)
1376         InitRecoParam();
1377
1378     return fgRecoParam;
1379 }
1380
1381 Bool_t AliEveEventManager::InitRecoParam()
1382 {
1383     // This is mostly a reap-off from reconstruction
1384     // The method accesses OCDB and retrieves all
1385     // the available reco-param objects from there.
1386
1387     fgRecoParam = new AliRecoParam;
1388     const Int_t  kNDetectors = 14;
1389
1390     static const TEveException kEH("AliEveEventManager::InitRecoParam");
1391
1392     Bool_t isOK = kTRUE;
1393
1394     if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1395         ::Info(kEH, "Using custom GRP reconstruction parameters");
1396     }
1397     else {
1398         ::Info(kEH, "Loading GRP reconstruction parameter objects");
1399
1400         AliCDBPath path("GRP","Calib","RecoParam");
1401         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1402         if(!entry){
1403             ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
1404             isOK = kFALSE;
1405         }
1406         else {
1407             TObject *recoParamObj = entry->GetObject();
1408             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1409                 // GRP has a normal TobjArray of AliDetectorRecoParam objects
1410                 // Registering them in AliRecoParam
1411                 fgRecoParam->AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
1412             }
1413             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1414                 // GRP has only onse set of reco parameters
1415                 // Registering it in AliRecoParam
1416                 ::Info(kEH, "Single set of GRP reconstruction parameters found");
1417                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1418                 fgRecoParam->AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1419             }
1420             else {
1421                 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1422                 isOK = kFALSE;
1423             }
1424             entry->SetOwner(0);
1425         }
1426     }
1427
1428     const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1429
1430
1431     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1432
1433         if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1434             ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1435             continue;
1436         }
1437
1438         ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1439
1440         AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1441         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1442         if(!entry){
1443             ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
1444             isOK = kFALSE;
1445         }
1446         else {
1447             TObject *recoParamObj = entry->GetObject();
1448             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1449                 // The detector has a normal TobjArray of AliDetectorRecoParam objects
1450                 // Registering them in AliRecoParam
1451                 fgRecoParam->AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
1452             }
1453             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1454                 // The detector has only onse set of reco parameters
1455                 // Registering it in AliRecoParam
1456                 ::Info(kEH, "Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]);
1457                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1458                 fgRecoParam->AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1459             }
1460             else {
1461                 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1462                 isOK = kFALSE;
1463             }
1464             entry->SetOwner(0);
1465
1466         }
1467     }
1468
1469     if(!isOK) {
1470         delete fgRecoParam;
1471         fgRecoParam = 0;
1472     }
1473
1474     return isOK;
1475 }
1476
1477 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1478 {
1479     if(!fESDFile && !fESD) return 0;
1480
1481     static const TEveException kEH("AliEveEventManager::readESDTree ");
1482
1483     TTree* tempTree = 0;
1484
1485     tempTree =(TTree*) fESDFile->Get(treeName);
1486     if (tempTree != 0)
1487     {
1488         TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1489         if (esdFriendFile)
1490         {
1491             if (!esdFriendFile->IsZombie())
1492             {
1493                 esdFriendFile->Close();
1494                 fESDfriendExists = kTRUE;
1495                 tempTree->SetBranchStatus ("ESDfriend*", 1);
1496             }
1497             delete esdFriendFile;
1498         }
1499
1500         fESD->ReadFromTree(tempTree);
1501         if (fESDfriendExists)
1502         {
1503             fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1504             Info(kEH, "found and attached ESD friend.");
1505         }
1506         else
1507         {
1508             Warning(kEH, "ESDfriend not found.");
1509         }
1510
1511         if (tempTree->GetEntry(0) <= 0)
1512         {
1513             Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1514         }
1515         else
1516         {
1517             if (runNo < 0)
1518                 runNo = fESD->GetESDRun()->GetRunNumber();
1519         }
1520     }
1521     else // tree == 0
1522     {
1523         Warning(kEH, "failed getting the tree:%s", treeName);
1524     }
1525
1526     return tempTree;
1527 }
1528
1529
1530 //------------------------------------------------------------------------------
1531
1532 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1533 {
1534     // Create and attach a dependent event-manager.
1535     // It is not added into eve list tree.
1536
1537     static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1538
1539     if (fgMaster == 0)
1540         throw(kEH + "Master event-manager must be instantiated first.");
1541
1542     if (fgMaster->fSubManagers == 0)
1543     {
1544         fgMaster->fSubManagers = new TList;
1545         fgMaster->fSubManagers->SetOwner(kTRUE);
1546     }
1547
1548     AliEveEventManager* new_mgr = 0;
1549     fgCurrent = 0;
1550     try
1551     {
1552         new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1553         new_mgr->SetFilesPath(path);
1554         fgMaster->fSubManagers->Add(new_mgr);
1555     }
1556     catch (TEveException& exc)
1557     {
1558         ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1559     }
1560     fgCurrent = fgMaster;
1561
1562     return new_mgr;
1563 }
1564
1565 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1566 {
1567     // Get a dependant manager by name.
1568     // This will not change the current manager, use helper class
1569     // AliEveEventManager::CurrentChanger for that.
1570
1571     static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1572
1573     if (fgMaster == 0)
1574         throw(kEH + "Master event-manager must be instantiated first.");
1575
1576     if (fgMaster->fSubManagers == 0)
1577         return 0;
1578
1579     return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1580 }
1581
1582 AliEveEventManager* AliEveEventManager::GetMaster()
1583 {
1584     // Get master event-manager.
1585
1586     return fgMaster;
1587 }
1588
1589 AliEveEventManager* AliEveEventManager::GetCurrent()
1590 {
1591     // Get current event-manager.
1592
1593     return fgCurrent;
1594 }
1595
1596 void AliEveEventManager::RegisterTransient(TEveElement* element)
1597 {
1598     GetCurrent()->fTransients->AddElement(element);
1599 }
1600
1601 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1602 {
1603     GetCurrent()->fTransientLists->AddElement(element);
1604 }
1605
1606 //------------------------------------------------------------------------------
1607 // Autoloading of events
1608 //------------------------------------------------------------------------------
1609
1610 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1611 {
1612     // Set the auto-load time in seconds
1613
1614     fAutoLoadTime = time;
1615 }
1616
1617 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1618 {
1619     // Set the automatic event loading mode
1620
1621     static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1622
1623     if (fAutoLoad == autoLoad)
1624     {
1625         Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1626         return;
1627     }
1628
1629     fAutoLoad = autoLoad;
1630     if (fAutoLoad)
1631     {
1632         StartAutoLoadTimer();
1633     }
1634     else
1635     {
1636         StopAutoLoadTimer();
1637     }
1638 }
1639
1640 void AliEveEventManager::SetTrigSel(Int_t trig)
1641 {
1642     static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1643
1644     if (!fRawReader)
1645     {
1646         Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1647         return;
1648     }
1649     else
1650     {
1651         ULong64_t trigMask = 0;
1652         if (trig >= 0) trigMask = (1ull << trig);
1653         Info(kEH,"Trigger selection: 0x%llx",trigMask);
1654         fRawReader->SelectEvents(-1,trigMask,NULL);
1655     }
1656 }
1657
1658 void AliEveEventManager::StartAutoLoadTimer()
1659 {
1660     // Start the auto-load timer.
1661
1662     fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1663     fAutoLoadTimer->Reset();
1664     fAutoLoadTimer->TurnOn();
1665     fAutoLoadTimerRunning = kTRUE;
1666 }
1667
1668 void AliEveEventManager::StopAutoLoadTimer()
1669 {
1670     // Stop the auto-load timer.
1671
1672     fAutoLoadTimerRunning = kFALSE;
1673     fAutoLoadTimer->TurnOff();
1674 }
1675
1676 void AliEveEventManager::AutoLoadNextEvent()
1677 {
1678         // Called from auto-load timer, so it has to be public.
1679         // Do NOT call it directly.
1680
1681         static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1682
1683         Info(kEH, "called!");
1684
1685         if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1686         {
1687                 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1688                 return;
1689         }
1690
1691         StopAutoLoadTimer();
1692         NextEvent();
1693         if (fAutoLoad)
1694                 StartAutoLoadTimer();
1695 }
1696
1697 //------------------------------------------------------------------------------
1698 // Post event-loading functions
1699 //------------------------------------------------------------------------------
1700
1701 void AliEveEventManager::AfterNewEventLoaded()
1702 {
1703   // Execute registered macros and commands.
1704   // At the end emit NewEventLoaded signal.
1705   //
1706   // Virtual from TEveEventManager.
1707
1708   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1709
1710   Info(kEH, "------------------!!!------------");
1711
1712   NewEventDataLoaded();
1713   if (fExecutor) fExecutor->ExecMacros();
1714
1715   TEveEventManager::AfterNewEventLoaded();
1716   NewEventLoaded();
1717
1718   if (this == fgMaster && fSubManagers != 0)
1719   {
1720     TIter next(fSubManagers);
1721     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1722     {
1723       gEve->SetCurrentEvent(fgCurrent);
1724       try
1725       {
1726         fgCurrent->GotoEvent(fEventId);
1727       }
1728       catch (TEveException& exc)
1729       {
1730         // !!! Should somehow tag / disable / remove it?
1731         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1732               fEventId, fgCurrent->GetName(), exc.Data());
1733       }
1734       Info(kEH, "------------------!!! while() gEve->SetCurrentEvent() ------------");
1735     }
1736     fgCurrent = fgMaster;
1737     Info(kEH, "------------------!!! while() gEve->SetCurrentEvent(MASTER) ------------");
1738     gEve->SetCurrentEvent(fgMaster);
1739   }
1740 }
1741
1742 void AliEveEventManager::NewEventDataLoaded()
1743 {
1744     // Emit NewEventDataLoaded signal.
1745
1746     Emit("NewEventDataLoaded()");
1747 }
1748
1749 void AliEveEventManager::NewEventLoaded()
1750 {
1751     // Emit NewEventLoaded signal.
1752
1753     Emit("NewEventLoaded()");
1754 }
1755
1756
1757 //------------------------------------------------------------------------------
1758 // Event info dumpers
1759 //------------------------------------------------------------------------------
1760
1761 const AliEventInfo* AliEveEventManager::GetEventInfo()
1762 {
1763     // Fill the event info object
1764
1765     AliCentralTrigger *aCTP = NULL;
1766     if (fRawReader) {
1767         fEventInfo.SetEventType(fRawReader->GetType());
1768
1769         ULong64_t mask = fRawReader->GetClassMask();
1770         fEventInfo.SetTriggerMask(mask);
1771         UInt_t clmask = fRawReader->GetDetectorPattern()[0];
1772         fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
1773
1774         aCTP = new AliCentralTrigger();
1775         TString configstr("");
1776         if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1777             AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
1778             delete aCTP;
1779             return 0;
1780         }
1781         aCTP->SetClassMask(mask);
1782         aCTP->SetClusterMask(clmask);
1783
1784         if (fRunLoader) {
1785             AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
1786             if (rlCTP) {
1787                 rlCTP->SetClassMask(mask);
1788                 rlCTP->SetClusterMask(clmask);
1789             }
1790         }
1791     }
1792     else {
1793         fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
1794
1795         if (fRunLoader && (!fRunLoader->LoadTrigger())) {
1796             aCTP = fRunLoader->GetTrigger();
1797             fEventInfo.SetTriggerMask(aCTP->GetClassMask());
1798             // get inputs from actp - just get
1799             AliESDHeader* esdheader = fESD->GetHeader();
1800             esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
1801             esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
1802             esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
1803             fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
1804         }
1805         else {
1806             AliWarning("No trigger can be loaded! The trigger information will not be used!");
1807             return 0;
1808         }
1809     }
1810
1811     AliTriggerConfiguration *config = aCTP->GetConfiguration();
1812     if (!config) {
1813         AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
1814         if (fRawReader) delete aCTP;
1815         return 0;
1816     }
1817
1818     TString declTriggerClasses;
1819
1820     // Load trigger aliases and declare the trigger classes included in aliases
1821     AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
1822     if (entry) {
1823         THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
1824         if (lst) {
1825             lst->Sort(kSortDescending); // to avoid problems with substrings
1826             if (fRawReader) fRawReader->LoadTriggerAlias(lst);
1827             // Now declare all the triggers present in the aliases
1828             TIter iter(lst);
1829             TNamed *nmd = 0;
1830             while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
1831                 declTriggerClasses += " ";
1832                 declTriggerClasses += nmd->GetName();
1833             }
1834         }
1835         else {
1836             AliError("Cannot cast the object with trigger aliases to THashList!");
1837         }
1838     }
1839     else {
1840         AliError("No OCDB entry for the trigger aliases!");
1841     }
1842
1843     // Load trigger classes for this run
1844     UChar_t clustmask = 0;
1845     TString trclasses;
1846     ULong64_t trmask = fEventInfo.GetTriggerMask();
1847     const TObjArray& classesArray = config->GetClasses();
1848     Int_t nclasses = classesArray.GetEntriesFast();
1849     for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
1850         AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
1851         if (trclass && trclass->GetMask()>0) {
1852             Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
1853             if (fESD) fESD->SetTriggerClass(trclass->GetName(),trindex);
1854             if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
1855             if (trmask & (1ull << trindex)) {
1856                 trclasses += " ";
1857                 trclasses += trclass->GetName();
1858                 trclasses += " ";
1859                 clustmask |= trclass->GetCluster()->GetClusterMask();
1860             }
1861         }
1862     }
1863     fEventInfo.SetTriggerClasses(trclasses);
1864
1865     if (!aCTP->CheckTriggeredDetectors()) {
1866         if (fRawReader) delete aCTP;
1867         return 0;
1868     }
1869
1870     if (fRawReader) delete aCTP;
1871
1872     // everything went ok, return pointer
1873     return (&fEventInfo);
1874 }
1875
1876
1877 TString AliEveEventManager::GetEventInfoHorizontal() const
1878 {
1879     // Dumps the event-header contents in vertical formatting.
1880
1881     TString rawInfo, esdInfo;
1882
1883     if (!fRawReader)
1884     {
1885         rawInfo = "No raw-data event info is available!\n";
1886     }
1887     else
1888     {
1889         const UInt_t* attr = fRawReader->GetAttributes();
1890         TTimeStamp ts(fRawReader->GetTimestamp());
1891         rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1892                      "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
1893                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1894                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1895                      fRawReader->GetClassMask(),
1896                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1897                      attr[0],attr[1],attr[2], ts.AsString("s"));
1898     }
1899
1900     if (!fESD)
1901     {
1902         esdInfo = "No ESD event info is available!";
1903     }
1904     else
1905     {
1906         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1907         TString firedtrclasses = fESD->GetFiredTriggerClasses();
1908         TTimeStamp ts(fESD->GetTimeStamp());
1909         esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1910                      "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
1911                      fESD->GetRunNumber(),
1912                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1913                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1914                      acttrclasses.Data(),
1915                      fESD->GetTriggerMask(),firedtrclasses.Data(),
1916                      fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
1917     }
1918
1919     return rawInfo + esdInfo;
1920 }
1921
1922 TString AliEveEventManager::GetEventInfoVertical() const
1923 {
1924     // Dumps the event-header contents in vertical formatting.
1925
1926     TString rawInfo, esdInfo;
1927
1928     if (!fRawReader)
1929     {
1930         rawInfo = "No raw-data event info is available!\n";
1931     }
1932     else
1933     {
1934         const UInt_t* attr = fRawReader->GetAttributes();
1935         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",
1936                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1937                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1938                      fRawReader->GetClassMask(),
1939                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1940                      attr[0],attr[1],attr[2],
1941                      fRawReader->GetTimestamp());
1942     }
1943
1944     if (!fESD)
1945     {
1946         esdInfo = "No ESD event info is available!\n";
1947     }
1948     else
1949     {
1950         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1951         TString firedtrclasses = fESD->GetFiredTriggerClasses();
1952         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",
1953                      fESD->GetRunNumber(),
1954                      acttrclasses.Data(),
1955                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1956                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1957                      fESD->GetTriggerMask(),firedtrclasses.Data(),
1958                      fESD->GetEventNumberInFile(),
1959                      fESD->GetTimeStamp());
1960     }
1961
1962     return rawInfo + "\n" + esdInfo;
1963 }
1964
1965
1966 //==============================================================================
1967 // Reading of GRP and MagneticField.
1968 // This is a reap-off from reconstruction ... should really be a common
1969 // code to do this somewhere in STEER.
1970 //==============================================================================
1971
1972 Bool_t AliEveEventManager::InitGRP()
1973 {
1974     //------------------------------------
1975     // Initialization of the GRP entry
1976     //------------------------------------
1977
1978     static const TEveException kEH("AliEveEventManager::InitGRP ");
1979
1980     AliGRPManager grpMgr;
1981     if (!grpMgr.ReadGRPEntry()) {
1982         return kFALSE;
1983     }
1984     fgGRPLoaded = kTRUE;
1985     if (!grpMgr.SetMagField()) {
1986         throw kEH + "Setting of field failed!";
1987     }
1988
1989     //*** Get the diamond profiles from OCDB
1990     // Eventually useful.
1991
1992     /*
1993     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1994     if (entry) {
1995     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1996     } else {
1997     ::Error(kEH, "No SPD diamond profile found in OCDB!");
1998     }
1999
2000     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
2001     if (entry) {
2002     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
2003     } else {
2004     ::Error(kEH, "No diamond profile found in OCDB!");
2005     }
2006
2007     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
2008     if (entry) {
2009     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
2010     } else {
2011     ::Error(kEH, "No TPC diamond profile found in OCDB!");
2012     }
2013   */
2014
2015     return kTRUE;
2016 }
2017
2018 //------------------------------------
2019 // Global variables management
2020 //------------------------------------
2021
2022 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model)
2023 {
2024     // Insert a new visualization-parameter database entry with the default
2025     return InsertGlobal(tag, model, fGlobalReplace, fGlobalUpdate);
2026 }
2027
2028 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model,
2029                                         Bool_t replace, Bool_t update)
2030 {
2031     TPair* pair = (TPair*) fGlobal->FindObject(tag);
2032     if (pair)
2033     {
2034         if (replace)
2035         {
2036             model->IncDenyDestroy();
2037             model->SetRnrChildren(kFALSE);
2038
2039             TEveElement* old_model = dynamic_cast<TEveElement*>(pair->Value());
2040             if(!old_model) AliFatal("old_model == 0, dynamic cast failed\n");
2041             while (old_model->HasChildren())
2042             {
2043                 TEveElement *el = old_model->FirstChild();
2044                 el->SetVizModel(model);
2045                 if (update)
2046                 {
2047                     el->CopyVizParams(model);
2048                     el->PropagateVizParamsToProjecteds();
2049                 }
2050             }
2051             old_model->DecDenyDestroy();
2052
2053             pair->SetValue(dynamic_cast<TObject*>(model));
2054             return kTRUE;
2055         }
2056         else
2057         {
2058             return kFALSE;
2059         }
2060     }
2061     else
2062     {
2063         model->IncDenyDestroy();
2064         model->SetRnrChildren(kFALSE);
2065         fGlobal->Add(new TObjString(tag), dynamic_cast<TObject*>(model));
2066         return kTRUE;
2067     }
2068 }
2069
2070 TEveElement* AliEveEventManager::FindGlobal(const TString& tag)
2071 {
2072     return dynamic_cast<TEveElement*>(fGlobal->GetValue(tag));
2073 }