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