100d814c6d0cb7bbb2db17729e23e833c370046c
[u/mrichter/AliRoot.git] / 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   if(fOnlineMode)
786     {
787       if(runNo != fCurrentRun)
788         { 
789           cout<<"Loading OCDB for new run:"<<runNo<<" in online mode."<<endl;
790           TEnv settings;
791           settings.ReadFile(AliOnlineReconstructionUtil::GetPathToServerConf(), kEnvUser);
792           fCurrentRun = runNo;
793           cout<<"config read"<<endl;
794
795           // Retrieve GRP entry for given run from aldaqdb.
796           TString dbHost = settings.GetValue("logbook.host", DEFAULT_LOGBOOK_HOST);
797           Int_t   dbPort =  settings.GetValue("logbook.port", DEFAULT_LOGBOOK_PORT);
798           TString dbName =  settings.GetValue("logbook.db", DEFAULT_LOGBOOK_DB);
799           TString user =  settings.GetValue("logbook.user", DEFAULT_LOGBOOK_USER);
800           TString password = settings.GetValue("logbook.pass", DEFAULT_LOGBOOK_PASS);
801           
802           gSystem->cd(cdbPath.Data());
803           gSystem->Exec("rm -fr GRP/");
804           cout<<"CDB path for GRP:"<<cdbPath<<endl;
805
806           TString gdc;
807
808           Int_t ret=AliGRPPreprocessor::ReceivePromptRecoParameters(fCurrentRun, dbHost.Data(),
809                                                                     dbPort, dbName.Data(),
810                                                                     user.Data(), password.Data(),
811                                                                     Form("%s",cdbPath.Data()),
812                                                                     gdc);
813
814           if(ret>0) Info("RetrieveGRP","Last run of the same type is: %d",ret);
815           else if(ret==0) Warning("RetrieveGRP","No previous run of the same type found");
816           else if(ret<0) Error("Retrieve","Error code while retrieving GRP parameters returned: %d",ret);
817
818
819           cdb->SetDefaultStorage(settings.GetValue("cdb.defaultStorage", DEFAULT_CDB_STORAGE));
820           cdb->SetSpecificStorage("GRP/GRP/Data",cdbPath.Data());
821           cdb->SetRun(fCurrentRun);
822           cdb->Print();
823         }
824     }
825   static const TEveException kEH("AliEveEventManager::InitOCDB ");
826     //if (this == fgMaster)
827     {
828         if (cdb->IsDefaultStorageSet() == kTRUE)
829         {
830             Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
831                     cdb->GetDefaultStorage()->GetURI().Data());
832         }
833         else
834         {
835             if (fgCdbUri.IsNull())
836             {
837                 gEnv->SetValue("Root.Stacktrace", "no");
838                 Fatal("Open()", "OCDB path was not specified.");
839             }
840             cout<<"Setting default storage:"<<fgCdbUri<<endl;
841             // Handle some special cases for MC (should be in OCDBManager).
842             if (fgCdbUri == "mcideal://")
843                 cdb->SetDefaultStorage("MC", "Ideal");
844             else if (fgCdbUri == "mcresidual://")
845                 cdb->SetDefaultStorage("MC", "Residual");
846             else if (fgCdbUri == "mcfull://")
847                 cdb->SetDefaultStorage("MC", "Full");
848             else if (fgCdbUri == "local://"){
849                 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
850                 cdb->SetDefaultStorage(fgCdbUri);
851               } 
852             else{
853               cdb->SetDefaultStorage(fgCdbUri);
854               }
855             cdb->SetRun(runNo);
856
857             if (cdb->IsDefaultStorageSet() == kFALSE)
858                 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
859         }/*
860         if (fgCdbUri.BeginsWith("local://"))
861         {
862             TString curPath = gSystem->WorkingDirectory();
863             TString grp     = "GRP/GRP/Data";
864             TString grppath = curPath + "/" + grp;
865             if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
866             {
867                 if (cdb->GetSpecificStorage(grp))
868                 {
869                     Warning(kEH, "Local GRP exists, but the specific storage is already set.");
870                 }
871                 else
872                 {
873                     Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
874                     TString lpath("local://");
875                     lpath += curPath;
876                     cdb->SetSpecificStorage(grp, lpath);
877                 }
878             }
879             }*/
880     }
881 }
882
883 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
884 {
885     // Set an event from an external source.
886     // The method is used in the online visualisation.
887     // AOD is not supported.
888
889     static const TEveException kEH("AliEveEventManager::SetEvent ");
890
891     if (fIsOpen)
892     {
893         Warning(kEH, "Event-files were open. Closing and switching to external control.");
894         Close();
895     }
896
897                         Info(kEH,"setting it!!! ============================");
898
899     fRunLoader = runLoader;
900     fRawReader = rawReader;
901     fESD       = esd;
902     fESDfriend = esdf;
903     fAOD       = 0;
904
905     fEventId++;
906     fHasEvent     = kTRUE;
907     fExternalCtrl = kTRUE;
908
909     SetTitle("Online event in memory");
910     SetName ("Online Event");
911     ElementChanged();
912
913     AfterNewEventLoaded();
914
915     if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
916     
917 }
918
919 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
920 {
921     // Returns maximum available event id.
922     // If under external control or event is not opened -1 is returned.
923     // If raw-data is the only data-source this can not be known
924     // and 10,000,000 is returned.
925     // If neither data-source is initialised an exception is thrown.
926     // If refresh_esd is true and ESD is the primary event-data source
927     // its header is re-read from disk.
928
929     static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
930
931     if (fExternalCtrl || fIsOpen == kFALSE)
932     {
933         return -1;
934     }
935
936     if ((fESDTree!=0) || (fHLTESDTree!=0))
937     {
938         if (refreshESD)
939         {
940             if(fESDTree!=0) fESDTree->Refresh();
941             if(fHLTESDTree!=0) fHLTESDTree->Refresh();
942             fPEventSelector->Update();
943         }
944
945         Int_t maxEventId=0;
946         switch(fgESDvisibleTrees){
947         default:
948         case AliEveEventManager::kOfflineTree :
949             maxEventId = fESDTree->GetEntries() - 1;
950             break;
951         case AliEveEventManager::kHLTTree :
952             maxEventId = fHLTESDTree->GetEntries() - 1;
953             break;
954        }
955
956         return maxEventId;
957     }
958     else if (fAODTree)
959     {
960         return fAODTree->GetEntries() - 1;
961     }
962     else if (fRunLoader)
963     {
964         return fRunLoader->GetNumberOfEvents() - 1;
965     }
966     else if (fRawReader)
967     {
968         Int_t n = fRawReader->GetNumberOfEvents() - 1;
969         return n > -1 ? n : 10000000;
970     }
971     else
972     {
973         throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
974     }
975 }
976
977 void AliEveEventManager::GotoEvent(Int_t event)
978 {
979     cout<<"Go to event:"<<event<<endl;
980     // Load data for specified event.
981     // If event is out of range an exception is thrown and old state
982     // is preserved.
983     // After successful loading of event, the virtual function
984     // AfterNewEventLoaded() is called. This executes commands that
985     // were registered via TEveEventManager::AddNewEventCommand().
986     //
987     // If event is negative, it is subtracted from the number of
988     // available events, thus passing -1 will load the last event.
989     // This is not supported when raw-data is the only data-source
990     // as the number of events is not known.
991
992     static const TEveException kEH("AliEveEventManager::GotoEvent ");
993
994     if (fAutoLoadTimerRunning)
995     {
996         throw (kEH + "Event auto-load timer is running.");
997     }
998     if (fExternalCtrl)
999     {
1000       // throw (kEH + "Event-loop is under external control.");
1001 #ifdef ZMQ
1002       if(fOnlineMode)
1003         {
1004           if (fStorageDown && -1 == event) 
1005             {
1006               NextEvent();
1007               return;
1008             }
1009
1010           if (fESD)
1011             {
1012               // create new server request:
1013               struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1014             
1015               // set request type:
1016               if (event == -1)      {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
1017               else  if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
1018               else  if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
1019               else  if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
1020             
1021               // set event struct:
1022               struct eventStruct eventToLoad;
1023               eventToLoad.runNumber = fESD->GetRunNumber();
1024               eventToLoad.eventNumber = fESD->GetEventNumberInFile();
1025               requestMessage->event = eventToLoad;
1026             
1027               // create event manager:
1028               AliStorageEventManager *eventManager =
1029                 AliStorageEventManager::GetEventManagerInstance();
1030               AliESDEvent *resultEvent = NULL;
1031             
1032               eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1033               fMutex->Lock();
1034             
1035               // send request and receive event:
1036               eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1037               resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1038             
1039               if(resultEvent)
1040                 {
1041                   DestroyElements();
1042                   InitOCDB(resultEvent->GetRunNumber());
1043                   SetEvent(0,0,resultEvent,0);
1044                 }
1045               else
1046                 {
1047                   if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
1048                   if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
1049                   if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
1050                   if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
1051                 }
1052             
1053               fMutex->UnLock();
1054             }
1055           else
1056             {
1057               cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
1058
1059               struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1060               requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1061             
1062               AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1063               eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1064               AliESDEvent *resultEvent = NULL;
1065             
1066               fMutex->Lock();
1067               eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1068               resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1069             
1070               if(resultEvent)
1071                 {
1072                   fESD=resultEvent;
1073                   DestroyElements();
1074                   InitOCDB(resultEvent->GetRunNumber());
1075                   SetEvent(0,0,resultEvent,0);
1076                 }
1077               else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1078               fMutex->UnLock();
1079             }
1080         }
1081 #endif  
1082
1083     }
1084     else if (!fIsOpen)
1085     {
1086         throw (kEH + "Event-files not opened.");
1087     }
1088
1089     fEventInfo.Reset();
1090
1091     fHasEvent = kFALSE;
1092
1093     Int_t maxEvent = 0;
1094     if ((fESDTree!=0) || (fHLTESDTree!=0))
1095     {
1096         if(fESDTree){
1097             if (event >= fESDTree->GetEntries())
1098                 fESDTree->Refresh();
1099             maxEvent = fESDTree->GetEntries() - 1;
1100             if (event < 0)
1101                 event = fESDTree->GetEntries() + event;
1102         }
1103
1104         if(fHLTESDTree){
1105             if (event >= fHLTESDTree->GetEntries())
1106                 fHLTESDTree->Refresh();
1107             maxEvent = fHLTESDTree->GetEntries() - 1;
1108             if (event < 0)
1109                 event = fHLTESDTree->GetEntries() + event;
1110
1111         }
1112     }
1113     else if (fAODTree)
1114     {
1115         maxEvent = fAODTree->GetEntries() - 1;
1116         if (event < 0)
1117             event = fAODTree->GetEntries() + event;
1118     }
1119     else if (fRunLoader)
1120     {
1121         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1122         if (event < 0)
1123             event = fRunLoader->GetNumberOfEvents() + event;
1124     }
1125     else if (fRawReader)
1126     {
1127         maxEvent = fRawReader->GetNumberOfEvents() - 1;
1128         if (maxEvent < 0)
1129         {
1130             maxEvent = 10000000;
1131             if (event < 0) {
1132                 Error(kEH, "current raw-data source does not support direct event access.");
1133                 return;
1134             }
1135             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1136         }
1137         else
1138         {
1139             if (event < 0)
1140                 event = fRawReader->GetNumberOfEvents() + event;
1141         }
1142     }
1143     else
1144     {
1145         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1146     }
1147     if (event < 0)
1148     {
1149         throw (kEH + Form("event %d not present, available range [%d, %d].",
1150                           event, 0, maxEvent));
1151     }
1152     if (event > maxEvent)
1153     {
1154       event=0;
1155       cout<<"Event number out of range. Going to event 0"<<endl;
1156     }
1157
1158     TString sysInfoHeader;
1159     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1160     AliSysInfo::AddStamp(sysInfoHeader + "Start");
1161
1162     TEveManager::TRedrawDisabler rd(gEve);
1163     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1164
1165     // !!! MT this is somewhat brutal; at least optionally, one could be
1166     // a bit gentler, checking for objs owning their external refs and having
1167     // additinal parents.
1168     gEve->GetViewers()->DeleteAnnotations();
1169     fTransients->DestroyElements();
1170     for (TEveElement::List_i i = fTransientLists->BeginChildren();
1171          i != fTransientLists->EndChildren(); ++i)
1172     {
1173         (*i)->DestroyElements();
1174     }
1175     DestroyElements();
1176
1177     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1178
1179     if (fESDTree) {
1180         if (fESDTree->GetEntry(event) <= 0)
1181             throw (kEH + "failed getting required event from ESD.");
1182
1183         if (fESDfriendExists)
1184             fESD->SetESDfriend(fESDfriend);
1185     }
1186
1187     if (fHLTESDTree) {
1188         if (fHLTESDTree->GetEntry(event) <= 0)
1189             throw (kEH + "failed getting required event from HLT ESD.");
1190
1191         if (fESDfriendExists)
1192             fESD->SetESDfriend(fESDfriend);
1193     }
1194
1195     if (fAODTree) {
1196         if (fAODTree->GetEntry(event) <= 0)
1197             throw (kEH + "failed getting required event from AOD.");
1198     }
1199
1200     if (fRunLoader) {
1201         if (fRunLoader->GetEvent(event) != 0)
1202             throw (kEH + "failed getting required event.");
1203     }
1204
1205     if (fRawReader)
1206     {
1207         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1208         if (fRawReader->GotoEvent(event) == kFALSE)
1209         {
1210             // Use fallback method - iteration with NextEvent().
1211             Int_t rawEv = fEventId;
1212             if (event < rawEv)
1213             {
1214                 fRawReader->RewindEvents();
1215                 rawEv = -1;
1216             }
1217
1218             while (rawEv < event)
1219             {
1220                 if ( ! fRawReader->NextEvent())
1221                 {
1222                     fRawReader->RewindEvents();
1223                     fEventId = -1;
1224                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1225                 }
1226                 ++rawEv;
1227             }
1228             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1229         }
1230     }
1231
1232     fHasEvent = kTRUE;
1233     fEventId  = event;
1234     if (this == fgMaster)
1235     {
1236         SetName(Form("Event %d", fEventId));
1237         ElementChanged();
1238     }
1239
1240     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1241
1242     AfterNewEventLoaded();
1243
1244     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1245 }
1246
1247 void AliEveEventManager::Timeout()
1248 {
1249     Emit("Timeout()");
1250 }
1251
1252 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1253 {       
1254         DestroyElements();
1255         InitOCDB(event->GetRunNumber());
1256         printf("======================= setting event to %d\n", fEventId);
1257         SetEvent(0,0,event,0);
1258 }
1259
1260 void AliEveEventManager::NextEvent()
1261 {
1262     // Loads next event.
1263     // Does magick needed for online display when under external event control.
1264
1265     static const TEveException kEH("AliEveEventManager::NextEvent ");
1266
1267     if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1268     
1269     if (fExternalCtrl)
1270     {
1271 #ifdef ZMQ
1272       if(fOnlineMode)
1273         {
1274           if(fIsNewEventAvaliable)
1275             {
1276               fMutex->Lock();
1277               if(fWritingToEventIndex == 0) fEventInUse = 0;
1278               else if(fWritingToEventIndex == 1) fEventInUse = 1;
1279             
1280               if(fCurrentEvent[fEventInUse])
1281                 {
1282                   if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1283                     {
1284                       printf("======================= setting event to %d\n", fCurrentEvent[fEventInUse]->GetEventNumberInFile());
1285                     
1286                       DestroyElements();
1287                       InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1288                       SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1289                     
1290                     }
1291                 }
1292               fIsNewEventAvaliable = false;
1293               fMutex->UnLock();
1294             }
1295           else
1296             {
1297               cout<<"No new event is avaliable."<<endl;
1298               NoEventLoaded();
1299             }
1300         }
1301 #endif
1302     }
1303     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1304     {
1305       Int_t nextevent=0;
1306       if (fPEventSelector->FindNext(nextevent))
1307       {
1308         GotoEvent(nextevent);
1309       }
1310     }
1311     else if (fEventId < GetMaxEventId(kTRUE))
1312     {
1313       GotoEvent(fEventId + 1);
1314     }
1315     
1316     gSystem->ProcessEvents();
1317     
1318     /*
1319     cout<<"VSD"<<endl;
1320     AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1321     cout<<"contructor called"<<endl;
1322     vsdCreator->CreateVSD("myVSD.root");
1323     cout<<"PO"<<endl;
1324 */
1325     //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1326 }
1327
1328 void AliEveEventManager::PrevEvent()
1329 {
1330     // Loads previous event.
1331
1332     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1333
1334     if (fAutoLoadTimerRunning)
1335     {
1336         throw (kEH + "Event auto-load timer is running.");
1337     }
1338     if (fExternalCtrl)
1339     {
1340         throw (kEH + "Event-loop is under external control.");
1341     }
1342
1343     if ((fESDTree!=0) || (fHLTESDTree!=0))
1344     {
1345         Int_t nextevent=0;
1346         if (fPEventSelector->FindPrev(nextevent))
1347         {
1348             GotoEvent(nextevent);
1349         }
1350     }
1351     else if (fEventId > 0)
1352     {
1353         GotoEvent(fEventId - 1);
1354     }
1355 }
1356
1357 void AliEveEventManager::MarkCurrentEvent()
1358 {
1359 #ifdef ZMQ
1360   if(!fOnlineMode){return;}
1361
1362         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1363         struct eventStruct mark;
1364         mark.runNumber = fESD->GetRunNumber();
1365         mark.eventNumber = fESD->GetEventNumberInFile();
1366         requestMessage->messageType = REQUEST_MARK_EVENT;
1367         requestMessage->event = mark;
1368
1369         AliStorageEventManager *eventManager =
1370                 AliStorageEventManager::GetEventManagerInstance();
1371         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1372
1373         /*
1374         std::future<bool> unused = std::async([]()
1375         {
1376                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1377                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1378
1379                 if(response)
1380                 {
1381                 //fStatusLabel->SetText("Event marked");
1382                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1383                 }
1384                 else
1385                 {
1386                 //fStatusLabel->SetText("Couldn't mark this event");
1387                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1388                 }
1389         });
1390         */
1391         
1392         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1393         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1394         
1395         
1396         if(response)
1397         {
1398                 //fStatusLabel->SetText("Event marked");
1399                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1400         }
1401         else
1402         {
1403                 //fStatusLabel->SetText("Couldn't mark this event");
1404                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1405         }
1406         if(requestMessage){delete requestMessage;}
1407 #endif
1408 }
1409
1410 void AliEveEventManager::Close()
1411 {
1412     // Close the event data-files and delete ESD, ESDfriend, run-loader
1413     // and raw-reader.
1414
1415     cout<<"\n\n\nClose() called!!\n\n\n"<<endl;
1416     
1417     static const TEveException kEH("AliEveEventManager::Close ");
1418
1419     if (!fIsOpen)
1420     {
1421         throw (kEH + "Event-files not opened.");
1422     }
1423
1424     if (fAutoLoadTimerRunning)
1425         StopAutoLoadTimer();
1426
1427     if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1428         delete fESD;       fESD       = 0;
1429         // delete fESDfriend; // friend tree is deleted with the tree
1430         fESDfriend = 0;
1431         fESDfriendExists = kFALSE;
1432
1433         if(fESDTree) { delete fESDTree;   fESDTree = 0; }
1434         if(fHLTESDTree) { delete fHLTESDTree;   fHLTESDTree = 0; }
1435         delete fESDFile;   fESDFile = 0;
1436     }
1437
1438     if (fAODTree) {
1439         delete fAOD;       fAOD       = 0;
1440
1441         delete fAODTree;   fAODTree = 0;
1442         delete fAODFile;   fAODFile = 0;
1443     }
1444
1445     if (fRunLoader) {
1446         delete fRunLoader; fRunLoader = 0;
1447     }
1448
1449     if (fRawReader) {
1450         delete fRawReader; fRawReader = 0;
1451     }
1452
1453     fEventId  = -1;
1454     fIsOpen   = kFALSE;
1455     fHasEvent = kFALSE;
1456 }
1457
1458
1459 //------------------------------------------------------------------------------
1460 // Static convenience functions, mainly used from macros.
1461 //------------------------------------------------------------------------------
1462
1463 Int_t AliEveEventManager::CurrentEventId()
1464 {
1465     // Return current event-id.
1466
1467     static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1468
1469     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1470         throw (kEH + "ALICE event not ready.");
1471     return fgCurrent->GetEventId();
1472 }
1473
1474 Bool_t AliEveEventManager::HasRunLoader()
1475 {
1476     // Check if AliRunLoader is initialized.
1477
1478     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1479 }
1480
1481 Bool_t AliEveEventManager::HasESD()
1482 {
1483     // Check if AliESDEvent is initialized.
1484
1485     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1486 }
1487
1488 Bool_t AliEveEventManager::HasESDfriend()
1489 {
1490     // Check if AliESDfriend is initialized.
1491
1492     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1493 }
1494
1495 Bool_t AliEveEventManager::HasAOD()
1496 {
1497     // Check if AliESDEvent is initialized.
1498
1499     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1500 }
1501
1502 Bool_t AliEveEventManager::HasRawReader()
1503 {
1504     // Check if raw-reader is initialized.
1505
1506     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1507 }
1508
1509 AliRunLoader* AliEveEventManager::AssertRunLoader()
1510 {
1511     // Make sure AliRunLoader is initialized and return it.
1512     // Throws exception in case run-loader is not available.
1513     // Static utility for macros.
1514
1515     static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
1516
1517     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1518         throw (kEH + "ALICE event not ready.");
1519     if (fgCurrent->fRunLoader == 0)
1520         throw (kEH + "AliRunLoader not initialised.");
1521     return fgCurrent->fRunLoader;
1522 }
1523
1524 AliESDEvent* AliEveEventManager::AssertESD()
1525 {
1526     // Make sure AliESDEvent is initialized and return it.
1527     // Throws exception in case ESD is not available.
1528     // Static utility for macros.
1529
1530     static const TEveException kEH("AliEveEventManager::AssertESD ");
1531
1532     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1533         throw (kEH + "ALICE event not ready.");
1534     if (fgCurrent->fESD == 0)
1535         throw (kEH + "AliESD not initialised.");
1536     return fgCurrent->fESD;
1537 }
1538
1539 AliESDfriend* AliEveEventManager::AssertESDfriend()
1540 {
1541     // Make sure AliESDfriend is initialized and return it.
1542     // Throws exception in case ESDfriend-loader is not available.
1543     // Static utility for macros.
1544
1545     static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1546
1547     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1548         throw (kEH + "ALICE event not ready.");
1549     if (fgCurrent->fESDfriend == 0)
1550         throw (kEH + "AliESDfriend not initialised.");
1551     return fgCurrent->fESDfriend;
1552 }
1553
1554 AliAODEvent* AliEveEventManager::AssertAOD()
1555 {
1556     // Make sure AliAODEvent is initialized and return it.
1557     // Throws exception in case AOD is not available.
1558     // Static utility for macros.
1559
1560     static const TEveException kEH("AliEveEventManager::AssertAOD ");
1561
1562     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1563         throw (kEH + "ALICE event not ready.");
1564     if (fgCurrent->fAOD == 0)
1565         throw (kEH + "AliAOD not initialised.");
1566     return fgCurrent->fAOD;
1567 }
1568
1569 AliRawReader* AliEveEventManager::AssertRawReader()
1570 {
1571     // Make sure raw-reader is initialized and return it.
1572
1573     static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1574
1575     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1576         throw (kEH + "ALICE event not ready.");
1577     if (fgCurrent->fRawReader == 0)
1578         throw (kEH + "RawReader not ready.");
1579
1580     return fgCurrent->fRawReader;
1581 }
1582
1583 //==============================================================================
1584
1585 AliMagF* AliEveEventManager::AssertMagField()    
1586 {        
1587     // Make sure AliMagF is initialized and returns it.
1588     // Throws exception in case magnetic field is not available.
1589     // Static utility for macros.
1590
1591     static const TEveException kEH("AliEveEventManager::AssertMagField ");
1592
1593     if (fgMagField)
1594         return fgMagField;
1595
1596     if (TGeoGlobalMagField::Instance()->GetField())
1597     {
1598         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1599         if (fgMagField == 0)
1600             throw kEH + "Global field set, but it is not AliMagF.";
1601         return fgMagField;
1602     }
1603
1604     if (!fgGRPLoaded)
1605     {
1606         InitGRP();
1607     }
1608
1609     if (TGeoGlobalMagField::Instance()->GetField())
1610     {
1611         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1612         if (fgMagField == 0)
1613             throw kEH + "Global field set, but it is not AliMagF.";
1614     }
1615     else
1616     {
1617         throw kEH + "Could not initialize magnetic field.";
1618     }
1619
1620     return fgMagField;
1621 }
1622
1623 TGeoManager* AliEveEventManager::AssertGeometry()
1624 {
1625     // Make sure AliGeomManager is initialized and returns the
1626     // corresponding TGeoManger.
1627     // gGeoManager is set to the return value.
1628     // Throws exception if geometry can not be loaded or if it is not
1629     // available and the TGeoManager is locked.
1630     // Static utility for macros.
1631
1632     static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1633
1634     if (AliGeomManager::GetGeometry() == 0)
1635     {
1636         if (TGeoManager::IsLocked())
1637             throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1638
1639         gGeoManager = 0;
1640         AliGeomManager::LoadGeometry();
1641         if ( ! AliGeomManager::GetGeometry())
1642         {
1643             throw (kEH + "can not load geometry.");
1644         }
1645         if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1646         {
1647             ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1648             // throw (kEH + "could not apply align objs.");
1649         }
1650         AliGeomManager::GetGeometry()->DefaultColors();
1651     }
1652
1653     gGeoManager = AliGeomManager::GetGeometry();
1654     return gGeoManager;
1655 }
1656
1657 AliRecoParam* AliEveEventManager::AssertRecoParams()
1658 {
1659     if(!fgRecoParam)
1660         InitRecoParam();
1661
1662     return fgRecoParam;
1663 }
1664
1665 Bool_t AliEveEventManager::InitRecoParam()
1666 {
1667     // This is mostly a reap-off from reconstruction
1668     // The method accesses OCDB and retrieves all
1669     // the available reco-param objects from there.
1670
1671     fgRecoParam = new AliRecoParam;
1672     const Int_t  kNDetectors = 14;
1673
1674     static const TEveException kEH("AliEveEventManager::InitRecoParam");
1675
1676     Bool_t isOK = kTRUE;
1677
1678     if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1679         ::Info(kEH, "Using custom GRP reconstruction parameters");
1680     }
1681     else {
1682         ::Info(kEH, "Loading GRP reconstruction parameter objects");
1683
1684         AliCDBPath path("GRP","Calib","RecoParam");
1685         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1686         if(!entry){
1687             ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
1688             isOK = kFALSE;
1689         }
1690         else {
1691             TObject *recoParamObj = entry->GetObject();
1692             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1693                 // GRP has a normal TobjArray of AliDetectorRecoParam objects
1694                 // Registering them in AliRecoParam
1695                 fgRecoParam->AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
1696             }
1697             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1698                 // GRP has only onse set of reco parameters
1699                 // Registering it in AliRecoParam
1700                 ::Info(kEH, "Single set of GRP reconstruction parameters found");
1701                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1702                 fgRecoParam->AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1703             }
1704             else {
1705                 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1706                 isOK = kFALSE;
1707             }
1708             entry->SetOwner(0);
1709         }
1710     }
1711
1712     const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1713
1714
1715     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1716
1717         if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1718             ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1719             continue;
1720         }
1721
1722         ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1723
1724         AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1725         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1726         if(!entry){
1727             ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
1728             isOK = kFALSE;
1729         }
1730         else {
1731             TObject *recoParamObj = entry->GetObject();
1732             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1733                 // The detector has a normal TobjArray of AliDetectorRecoParam objects
1734                 // Registering them in AliRecoParam
1735                 fgRecoParam->AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
1736             }
1737             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1738                 // The detector has only onse set of reco parameters
1739                 // Registering it in AliRecoParam
1740                 ::Info(kEH, "Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]);
1741                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1742                 fgRecoParam->AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1743             }
1744             else {
1745                 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1746                 isOK = kFALSE;
1747             }
1748             entry->SetOwner(0);
1749
1750         }
1751     }
1752
1753     if(!isOK) {
1754         delete fgRecoParam;
1755         fgRecoParam = 0;
1756     }
1757
1758     return isOK;
1759 }
1760
1761 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1762 {
1763     if(!fESDFile && !fESD) return 0;
1764
1765     static const TEveException kEH("AliEveEventManager::readESDTree ");
1766
1767     TTree* tempTree = 0;
1768
1769     tempTree =(TTree*) fESDFile->Get(treeName);
1770     if (tempTree != 0)
1771     {
1772         TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1773         if (esdFriendFile)
1774         {
1775             if (!esdFriendFile->IsZombie())
1776             {
1777                 esdFriendFile->Close();
1778                 fESDfriendExists = kTRUE;
1779                 tempTree->SetBranchStatus ("ESDfriend*", 1);
1780             }
1781             delete esdFriendFile;
1782         }
1783
1784         fESD->ReadFromTree(tempTree);
1785         if (fESDfriendExists)
1786         {
1787             fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1788             Info(kEH, "found and attached ESD friend.");
1789         }
1790         else
1791         {
1792             Warning(kEH, "ESDfriend not found.");
1793         }
1794
1795         if (tempTree->GetEntry(0) <= 0)
1796         {
1797             Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1798         }
1799         else
1800         {
1801             if (runNo < 0)
1802                 runNo = fESD->GetESDRun()->GetRunNumber();
1803         }
1804     }
1805     else // tree == 0
1806     {
1807         Warning(kEH, "failed getting the tree:%s", treeName);
1808     }
1809
1810     return tempTree;
1811 }
1812
1813
1814 //------------------------------------------------------------------------------
1815
1816 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1817 {
1818     // Create and attach a dependent event-manager.
1819     // It is not added into eve list tree.
1820
1821     static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1822
1823     if (fgMaster == 0)
1824         throw(kEH + "Master event-manager must be instantiated first.");
1825
1826     if (fgMaster->fSubManagers == 0)
1827     {
1828         fgMaster->fSubManagers = new TList;
1829         fgMaster->fSubManagers->SetOwner(kTRUE);
1830     }
1831
1832     AliEveEventManager* new_mgr = 0;
1833     fgCurrent = 0;
1834     try
1835     {
1836         new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1837         new_mgr->SetFilesPath(path);
1838         fgMaster->fSubManagers->Add(new_mgr);
1839     }
1840     catch (TEveException& exc)
1841     {
1842         ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1843     }
1844     fgCurrent = fgMaster;
1845
1846     return new_mgr;
1847 }
1848
1849 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1850 {
1851     // Get a dependant manager by name.
1852     // This will not change the current manager, use helper class
1853     // AliEveEventManager::CurrentChanger for that.
1854
1855     static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1856
1857     if (fgMaster == 0)
1858         throw(kEH + "Master event-manager must be instantiated first.");
1859
1860     if (fgMaster->fSubManagers == 0)
1861         return 0;
1862
1863     return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1864 }
1865
1866 AliEveEventManager* AliEveEventManager::GetMaster()
1867 {
1868     // Get master event-manager.
1869
1870     return fgMaster;
1871 }
1872
1873 AliEveEventManager* AliEveEventManager::GetCurrent()
1874 {
1875     // Get current event-manager.
1876
1877     return fgCurrent;
1878 }
1879
1880 void AliEveEventManager::RegisterTransient(TEveElement* element)
1881 {
1882     GetCurrent()->fTransients->AddElement(element);
1883 }
1884
1885 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1886 {
1887     GetCurrent()->fTransientLists->AddElement(element);
1888 }
1889
1890 //------------------------------------------------------------------------------
1891 // Autoloading of events
1892 //------------------------------------------------------------------------------
1893
1894 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1895 {
1896     // Set the auto-load time in seconds
1897
1898     fAutoLoadTime = time;
1899 }
1900
1901 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1902 {
1903     // Set the automatic event loading mode
1904
1905     static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1906
1907     if (fAutoLoad == autoLoad)
1908     {
1909         Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1910         return;
1911     }
1912
1913     fAutoLoad = autoLoad;
1914     if (fAutoLoad)
1915     {
1916         StartAutoLoadTimer();
1917     }
1918     else
1919     {
1920         StopAutoLoadTimer();
1921     }
1922 }
1923
1924 void AliEveEventManager::SetLoopMarked(Bool_t loopMarked)
1925 {
1926     // Set the automatic event loading mode
1927   if(fLoopMarked == loopMarked)
1928     {
1929       cout<<"loop marked has the same value - ignoring"<<endl;
1930       return;
1931     }
1932   else
1933     {
1934       cout<<"Setting loof marked to:"<<loopMarked<<endl;
1935       fLoopMarked = loopMarked;
1936       if (fLoopMarked){StartAutoLoadTimer();}
1937       else{StopAutoLoadTimer();}
1938     }
1939 }
1940
1941 void AliEveEventManager::SetTrigSel(Int_t trig)
1942 {
1943     static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1944
1945     if (!fRawReader)
1946     {
1947         Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1948         return;
1949     }
1950     else
1951     {
1952         ULong64_t trigMask = 0;
1953         if (trig >= 0) trigMask = (1ull << trig);
1954         Info(kEH,"Trigger selection: 0x%llx",trigMask);
1955         fRawReader->SelectEvents(-1,trigMask,NULL);
1956     }
1957 }
1958
1959 void AliEveEventManager::StartAutoLoadTimer()
1960 {
1961     // Start the auto-load timer.
1962
1963     fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1964     fAutoLoadTimer->Reset();
1965     fAutoLoadTimer->TurnOn();
1966     fAutoLoadTimerRunning = kTRUE;
1967 }
1968
1969 void AliEveEventManager::StopAutoLoadTimer()
1970 {
1971     // Stop the auto-load timer.
1972
1973     fAutoLoadTimerRunning = kFALSE;
1974     fAutoLoadTimer->TurnOff();
1975 }
1976
1977 void AliEveEventManager::AutoLoadNextEvent()
1978 {
1979         // Called from auto-load timer, so it has to be public.
1980         // Do NOT call it directly.
1981
1982         static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1983           
1984         Info(kEH, "called!");
1985
1986         if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1987         {
1988                 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1989                 return;
1990         }
1991
1992         StopAutoLoadTimer();
1993         NextEvent();
1994         if (fAutoLoad || fLoopMarked)
1995                 StartAutoLoadTimer();
1996 }
1997
1998 //------------------------------------------------------------------------------
1999 // Post event-loading functions
2000 //------------------------------------------------------------------------------
2001
2002 void AliEveEventManager::AfterNewEventLoaded()
2003 {
2004   // Execute registered macros and commands.
2005   // At the end emit NewEventLoaded signal.
2006   //
2007   // Virtual from TEveEventManager.
2008
2009   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
2010
2011   Info(kEH, "------------------!!!------------");
2012                       
2013   NewEventDataLoaded();
2014   if (fExecutor) fExecutor->ExecMacros();
2015
2016   TEveEventManager::AfterNewEventLoaded();
2017   NewEventLoaded();
2018
2019   if (this == fgMaster && fSubManagers != 0)
2020   {
2021     TIter next(fSubManagers);
2022     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
2023     {
2024       gEve->SetCurrentEvent(fgCurrent);
2025       try
2026       {
2027         fgCurrent->GotoEvent(fEventId);
2028       }
2029       catch (TEveException& exc)
2030       {
2031         // !!! Should somehow tag / disable / remove it?
2032         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
2033               fEventId, fgCurrent->GetName(), exc.Data());
2034       }
2035       Info(kEH, "------------------!!! while() gEve->SetCurrentEvent() ------------");
2036     }
2037     fgCurrent = fgMaster;
2038     Info(kEH, "------------------!!! while() gEve->SetCurrentEvent(MASTER) ------------");
2039     gEve->SetCurrentEvent(fgMaster);
2040   }
2041 }
2042
2043 void AliEveEventManager::NewEventDataLoaded()
2044 {
2045     // Emit NewEventDataLoaded signal.
2046     Emit("NewEventDataLoaded()");
2047 }
2048 void AliEveEventManager::NewEventLoaded()
2049 {
2050     // Emit NewEventLoaded signal.
2051     Emit("NewEventLoaded()");
2052 }
2053 void AliEveEventManager::NoEventLoaded()
2054 {
2055     // Emit NoEventLoaded signal.
2056     Emit("NoEventLoaded()");
2057 }
2058 void AliEveEventManager::StorageManagerOk()
2059 {
2060     // Emit StorageManagerOk signal.
2061     Emit("StorageManagerOk()");
2062 }
2063 void AliEveEventManager::StorageManagerDown()
2064 {
2065     // Emit StorageManagerOk signal.
2066     Emit("StorageManagerDown()");
2067 }
2068
2069
2070 //------------------------------------------------------------------------------
2071 // Event info dumpers
2072 //------------------------------------------------------------------------------
2073
2074 const AliEventInfo* AliEveEventManager::GetEventInfo() 
2075 {
2076     // Fill the event info object
2077
2078     AliCentralTrigger *aCTP = NULL;
2079     if (fRawReader) {
2080         fEventInfo.SetEventType(fRawReader->GetType());
2081
2082         ULong64_t mask = fRawReader->GetClassMask();
2083         fEventInfo.SetTriggerMask(mask);
2084         UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2085         fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
2086
2087         aCTP = new AliCentralTrigger();
2088         TString configstr("");
2089         if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
2090             AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
2091             delete aCTP;
2092             return 0;
2093         }
2094         aCTP->SetClassMask(mask);
2095         aCTP->SetClusterMask(clmask);
2096
2097         if (fRunLoader) {
2098             AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
2099             if (rlCTP) {
2100                 rlCTP->SetClassMask(mask);
2101                 rlCTP->SetClusterMask(clmask);
2102             }
2103         }
2104     }
2105     else {
2106         fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
2107
2108         if (fRunLoader && (!fRunLoader->LoadTrigger())) {
2109             aCTP = fRunLoader->GetTrigger();
2110             fEventInfo.SetTriggerMask(aCTP->GetClassMask());
2111             // get inputs from actp - just get
2112             AliESDHeader* esdheader = fESD->GetHeader();
2113             esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
2114             esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
2115             esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
2116             fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
2117         }
2118         else {
2119             AliWarning("No trigger can be loaded! The trigger information will not be used!");
2120             return 0;
2121         }
2122     }
2123
2124     AliTriggerConfiguration *config = aCTP->GetConfiguration();
2125     if (!config) {
2126         AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
2127         if (fRawReader) delete aCTP;
2128         return 0;
2129     }
2130
2131     TString declTriggerClasses;
2132
2133     // Load trigger aliases and declare the trigger classes included in aliases
2134     AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
2135     if (entry) {
2136         THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
2137         if (lst) {
2138             lst->Sort(kSortDescending); // to avoid problems with substrings
2139             if (fRawReader) fRawReader->LoadTriggerAlias(lst);
2140             // Now declare all the triggers present in the aliases
2141             TIter iter(lst);
2142             TNamed *nmd = 0;
2143             while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
2144                 declTriggerClasses += " ";
2145                 declTriggerClasses += nmd->GetName();
2146             }
2147         }
2148         else {
2149             AliError("Cannot cast the object with trigger aliases to THashList!");
2150         }
2151     }
2152     else {
2153         AliError("No OCDB entry for the trigger aliases!");
2154     }
2155
2156     // Load trigger classes for this run
2157     UChar_t clustmask = 0;
2158     TString trclasses;
2159     ULong64_t trmask = fEventInfo.GetTriggerMask();
2160     const TObjArray& classesArray = config->GetClasses();
2161     Int_t nclasses = classesArray.GetEntriesFast();
2162     for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
2163         AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
2164         if (trclass && trclass->GetMask()>0) {
2165             Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
2166             if (fESD) fESD->SetTriggerClass(trclass->GetName(),trindex);
2167             if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
2168             if (trmask & (1ull << trindex)) {
2169                 trclasses += " ";
2170                 trclasses += trclass->GetName();
2171                 trclasses += " ";
2172                 clustmask |= trclass->GetCluster()->GetClusterMask();
2173             }
2174         }
2175     }
2176     fEventInfo.SetTriggerClasses(trclasses);
2177
2178     if (!aCTP->CheckTriggeredDetectors()) {
2179         if (fRawReader) delete aCTP;
2180         return 0;
2181     }
2182
2183     if (fRawReader) delete aCTP;
2184
2185     // everything went ok, return pointer
2186     return (&fEventInfo);
2187 }
2188
2189
2190 TString AliEveEventManager::GetEventInfoHorizontal() const
2191 {
2192     // Dumps the event-header contents in vertical formatting.
2193
2194     TString rawInfo, esdInfo;
2195
2196     if (!fRawReader)
2197     {
2198         rawInfo = "No raw-data event info is available!\n";
2199     }
2200     else
2201     {
2202         const UInt_t* attr = fRawReader->GetAttributes();
2203         TTimeStamp ts(fRawReader->GetTimestamp());
2204         rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2205                      "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
2206                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2207                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2208                      fRawReader->GetClassMask(),
2209                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2210                      attr[0],attr[1],attr[2], ts.AsString("s"));
2211     }
2212
2213     if (!fESD)
2214     {
2215         esdInfo = "No ESD event info is available!";
2216     }
2217     else
2218     {
2219         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2220         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2221         TTimeStamp ts(fESD->GetTimeStamp());
2222         esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2223                      "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
2224                      fESD->GetRunNumber(),
2225                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2226                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2227                      acttrclasses.Data(),
2228                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2229                      fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
2230     }
2231
2232     return rawInfo + esdInfo;
2233 }
2234
2235 TString AliEveEventManager::GetEventInfoVertical() const
2236 {
2237     // Dumps the event-header contents in vertical formatting.
2238
2239     TString rawInfo, esdInfo;
2240
2241     if (!fRawReader)
2242     {
2243         rawInfo = "No raw-data event info is available!\n";
2244     }
2245     else
2246     {
2247         const UInt_t* attr = fRawReader->GetAttributes();
2248         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",
2249                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2250                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2251                      fRawReader->GetClassMask(),
2252                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2253                      attr[0],attr[1],attr[2],
2254                      fRawReader->GetTimestamp());
2255     }
2256
2257     if (!fESD)
2258     {
2259         esdInfo = "No ESD event info is available!\n";
2260     }
2261     else
2262     {
2263         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2264         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2265         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",
2266                      fESD->GetRunNumber(),
2267                      acttrclasses.Data(),
2268                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2269                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2270                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2271                      fESD->GetEventNumberInFile(),
2272                      fESD->GetTimeStamp());
2273     }
2274
2275     return rawInfo + "\n" + esdInfo;
2276 }
2277
2278
2279 //==============================================================================
2280 // Reading of GRP and MagneticField.
2281 // This is a reap-off from reconstruction ... should really be a common
2282 // code to do this somewhere in STEER.
2283 //==============================================================================
2284
2285 Bool_t AliEveEventManager::InitGRP()
2286 {
2287     //------------------------------------
2288     // Initialization of the GRP entry
2289     //------------------------------------
2290
2291     static const TEveException kEH("AliEveEventManager::InitGRP ");
2292
2293     AliGRPManager grpMgr;
2294     if (!grpMgr.ReadGRPEntry()) {
2295         return kFALSE;
2296     }
2297     fgGRPLoaded = kTRUE;
2298     if (!grpMgr.SetMagField()) {
2299         throw kEH + "Setting of field failed!";
2300     }
2301
2302     //*** Get the diamond profiles from OCDB
2303     // Eventually useful.
2304
2305     /*
2306     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
2307     if (entry) {
2308     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
2309     } else {
2310     ::Error(kEH, "No SPD diamond profile found in OCDB!");
2311     }
2312
2313     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
2314     if (entry) {
2315     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
2316     } else {
2317     ::Error(kEH, "No diamond profile found in OCDB!");
2318     }
2319
2320     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
2321     if (entry) {
2322     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
2323     } else {
2324     ::Error(kEH, "No TPC diamond profile found in OCDB!");
2325     }
2326   */
2327
2328     return kTRUE;
2329
2330
2331 //------------------------------------
2332 // Global variables management
2333 //------------------------------------
2334
2335 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model)
2336 {
2337     // Insert a new visualization-parameter database entry with the default
2338     return InsertGlobal(tag, model, fGlobalReplace, fGlobalUpdate);
2339 }
2340
2341 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model,
2342                                         Bool_t replace, Bool_t update)
2343 {
2344     TPair* pair = (TPair*) fGlobal->FindObject(tag);
2345     if (pair)
2346     {
2347         if (replace)
2348         {
2349             model->IncDenyDestroy();
2350             model->SetRnrChildren(kFALSE);
2351
2352             TEveElement* old_model = dynamic_cast<TEveElement*>(pair->Value());
2353             if(!old_model) AliFatal("old_model == 0, dynamic cast failed\n");
2354             while (old_model->HasChildren())
2355             {
2356                 TEveElement *el = old_model->FirstChild();
2357                 el->SetVizModel(model);
2358                 if (update)
2359                 {
2360                     el->CopyVizParams(model);
2361                     el->PropagateVizParamsToProjecteds();
2362                 }
2363             }
2364             old_model->DecDenyDestroy();
2365
2366             pair->SetValue(dynamic_cast<TObject*>(model));
2367             return kTRUE;
2368         }
2369         else
2370         {
2371             return kFALSE;
2372         }
2373     }
2374     else
2375     {
2376         model->IncDenyDestroy();
2377         model->SetRnrChildren(kFALSE);
2378         fGlobal->Add(new TObjString(tag), dynamic_cast<TObject*>(model));
2379         return kTRUE;
2380     }
2381 }
2382
2383 TEveElement* AliEveEventManager::FindGlobal(const TString& tag)
2384 {
2385     return dynamic_cast<TEveElement*>(fGlobal->GetValue(tag));
2386 }
2387 Int_t AliEveEventManager::NewEventAvailable()
2388 {
2389   if (fIsNewEventAvaliable)
2390   {
2391     return 1;
2392   }
2393   else
2394   {
2395     return 0;
2396   }
2397 }