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