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