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