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