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