ZMQ part of Event Display suppresed in offline mode
[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
116 TList*   AliEveEventManager::fgAODfriends = 0;
117
118 Bool_t   AliEveEventManager::fgRawFromStandardLoc = kFALSE;
119
120 Bool_t   AliEveEventManager::fgGRPLoaded    = kFALSE;
121 AliMagF* AliEveEventManager::fgMagField     = 0;
122 AliRecoParam* AliEveEventManager::fgRecoParam = 0;
123 Bool_t   AliEveEventManager::fgUniformField = kFALSE;
124
125 AliEveEventManager* AliEveEventManager::fgMaster  = 0;
126 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
127
128 AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
129     TEveEventManager(name, ""),
130     fEventId(-1),
131     fRunLoader (0),
132     fESDFile   (0), fESDTree (0), fHLTESDTree(0), fESD (0),
133     fESDfriend (0), fESDfriendExists(kFALSE),
134     fAODFile   (0), fAODTree (0), fAOD (0),
135     fRawReader (0), fEventInfo(),
136     fAutoLoad  (kFALSE),fLoopMarked(kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
137     fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
138     fGlobal    (0), fGlobalReplace (kTRUE), fGlobalUpdate (kTRUE),
139     fExecutor    (0), fTransients(0), fTransientLists(0),
140     fPEventSelector(0),
141     fSubManagers (0),
142     fAutoLoadTimerRunning(kFALSE),
143     fMutex(new TMutex()),
144     fgSubSock(EVENTS_SERVER_SUB),
145     fEventInUse(1),
146     fWritingToEventIndex(0),
147     fIsNewEventAvaliable(false),
148         fOnlineMode(kFALSE),
149     fStorageDown(false),
150     fFinished(false)
151 {
152     // Constructor with event-id.
153                 
154     InitInternals();
155
156     Open();
157     if (ev >= 0)
158     {
159         GotoEvent(ev);
160     }
161     
162     if (0 == name.CompareTo("online")) {
163       fOnlineMode = kTRUE;
164     }
165     else{
166       fOnlineMode = kFALSE;
167     }
168
169
170 #ifdef ZMQ
171     if(fOnlineMode)
172       {
173     cout<<"ZMQ FOUND. Starting subscriber thread."<<endl;
174     fEventListenerThread = new TThread("fEventListenerThread",DispatchEventListener,(void*)this);
175     fEventListenerThread->Run();
176     
177     fStorageManagerWatcherThread = new TThread("fStorageManagerWatcherThread",DispatchStorageManagerWatcher,(void*)this);
178     fStorageManagerWatcherThread->Run();
179       }
180 #else
181     cout<<"NO ZMQ FOUND. Online events not avaliable."<<endl;
182 #endif
183 }
184
185 AliEveEventManager::~AliEveEventManager()
186 {
187     // Destructor.
188     
189     fFinished = true;
190     if(fEventListenerThread)
191     {
192         fEventListenerThread->Join();
193         fEventListenerThread->Kill();
194         delete fEventListenerThread;
195         cout<<"listener thread killed and deleted"<<endl;
196     }
197     if(fStorageManagerWatcherThread)
198     {
199         fStorageManagerWatcherThread->Join();
200         fStorageManagerWatcherThread->Kill();
201         delete fStorageManagerWatcherThread;
202         cout<<"storage watcher thread killed and deleted"<<endl;
203     }
204     
205     fAutoLoadTimer->Stop();
206     fAutoLoadTimer->Disconnect("Timeout");
207     fAutoLoadTimer->Disconnect("AutoLoadNextEvent");
208
209     if(fSubManagers){delete fSubManagers;}
210     if(fMutex){delete fMutex;}
211     if (fIsOpen){Close();}
212
213 //    fTransients->DecDenyDestroy();
214 //    fTransients->Destroy();
215
216 //    fTransientLists->DecDenyDestroy();
217 //    fTransientLists->Destroy();
218
219     //delete fExecutor;
220 }
221
222 void AliEveEventManager::GetNextEvent()
223 {
224 #ifdef ZMQ
225   if(!fOnlineMode){return;}
226   cout<<"\n\nGet next event called\n\n"<<endl;
227
228     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
229     eventManager->CreateSocket(EVENTS_SERVER_SUB);
230     eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
231     
232     fCurrentEvent[0]=0;
233     fCurrentEvent[1]=0;
234
235     AliESDEvent *tmpEvent = NULL;
236     
237     // get list of marked events:
238     struct listRequestStruct list;
239
240     list.runNumber[0]=0;
241     list.runNumber[1]=999999;
242     list.eventNumber[0]=0;
243     list.eventNumber[1]=999999;
244     list.marked[0]=1;
245     list.marked[1]=1;
246     list.multiplicity[0]=1;
247     list.multiplicity[1]=999999;
248     strcpy(list.system[0],"p-p");
249     strcpy(list.system[1],"A-A");
250     
251     struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
252     requestMessage->messageType = REQUEST_LIST_EVENTS;
253     requestMessage->list = list;
254     
255     eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
256     vector<serverListStruct> receivedList = eventManager->GetServerListVector(SERVER_COMMUNICATION_REQ,3000);
257     
258     cout<<"EVENT DISPLAY -- received list of marked events"<<endl;
259     
260     for(int i=0;i<receivedList.size();i++)
261     {
262         cout<<"ev:"<<receivedList[i].eventNumber<<endl;
263     }
264     
265     int iter=0;
266     while(!fFinished)
267     {
268         if(!fLoopMarked || receivedList.size()<=0)
269         {
270             cout<<"taking event from reco server"<<endl;
271             tmpEvent = eventManager->GetEvent(EVENTS_SERVER_SUB,5000);
272             if(!tmpEvent){sleep(1);}
273         }
274         else
275         {
276             cout<<"taking event from storage manager"<<endl;
277             if(iter<receivedList.size())
278             {
279                 cout<<"i:"<<iter<<endl;
280                 struct eventStruct mark;
281                 mark.runNumber = receivedList[iter].runNumber;
282                 mark.eventNumber = receivedList[iter].eventNumber;
283              
284                 requestMessage->messageType = REQUEST_GET_EVENT;
285                 requestMessage->event = mark;
286                 
287                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
288                 tmpEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
289
290                 iter++;
291                 sleep(1);
292             }
293             else{iter=0;}
294         }
295         
296         if(tmpEvent)
297         {
298             cout<<"tmpEvent:"<<tmpEvent->GetRunNumber()<<endl;
299             if(tmpEvent->GetRunNumber()>=0)
300             {
301                 fMutex->Lock();
302                 if(fEventInUse == 0){fWritingToEventIndex = 1;}
303                 else if(fEventInUse == 1){fWritingToEventIndex = 0;}
304                 cout<<"Received new event:"<<tmpEvent->GetEventNumberInFile()<<endl;
305                 if(fCurrentEvent[fWritingToEventIndex])
306                 {
307                     delete fCurrentEvent[fWritingToEventIndex];
308                     fCurrentEvent[fWritingToEventIndex]=0;
309                 }
310                 fCurrentEvent[fWritingToEventIndex] = tmpEvent;
311                 fIsNewEventAvaliable = true;
312                 NewEventLoaded();
313                 fMutex->UnLock();
314             }
315         }
316         else{cout<<"didn't receive new event"<<endl;}
317     }
318     delete requestMessage;
319     
320 #endif
321 }
322
323 void AliEveEventManager::CheckStorageStatus()
324 {
325 #ifdef ZMQ
326   if(!fOnlineMode){return;}
327
328     AliEveConfigManager *configManager = AliEveConfigManager::GetMaster();
329     configManager->ConnectEventManagerSignals();
330     
331     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
332     eventManager->CreateSocket(CLIENT_COMMUNICATION_REQ);
333     
334     struct clientRequestStruct *request = new struct clientRequestStruct;
335     request->messageType = REQUEST_CONNECTION;
336     
337     while (!fFinished)
338     {
339         if(eventManager->Send(request,CLIENT_COMMUNICATION_REQ,5000))
340         {
341             StorageManagerOk();
342             long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
343             fStorageDown = kFALSE;
344         }
345         else
346         {
347             StorageManagerDown();
348             cout<<"WARNING -- Storage Manager is DOWN!!"<<endl;
349             fStorageDown = kTRUE;
350         }
351         sleep(1);
352     }
353     
354     AliEveEventManager *manager = AliEveEventManager::GetCurrent();
355     manager->Disconnect("StorageManagerOk");
356     manager->Disconnect("StorageManagerDown");
357     
358 #endif
359 }
360
361 void AliEveEventManager::InitInternals()
362 {
363     // Initialize internal members.
364     
365     static const TEveException kEH("AliEveEventManager::InitInternals ");
366     
367     if (fgCurrent != 0)
368     {
369         throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
370     }
371     
372     if (fgMaster == 0)
373     {
374         fgMaster = this;
375     }
376     
377     fgCurrent = this;
378     
379     fAutoLoadTimer = new TTimer;
380     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
381     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "Timeout()");
382     
383     fExecutor = new AliEveMacroExecutor;
384     
385     fTransients = new TEveElementList("Transients", "Transient per-event elements.");
386     fTransients->IncDenyDestroy();
387     gEve->AddToListTree(fTransients, kFALSE);
388     
389     fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
390     fTransientLists->IncDenyDestroy();
391     gEve->AddToListTree(fTransientLists, kFALSE);
392     
393     fPEventSelector = new AliEveEventSelector(this);
394     
395     fGlobal = new TMap; fGlobal->SetOwnerKeyValue();
396 }
397
398 /******************************************************************************/
399
400 void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
401 {
402     fgESDvisibleTrees = shown;
403     // Set file-name for opening ESD, default "AliESDs.root".
404     if (esd.IsNull()) return;
405
406     fgESDFileName = esd;
407     if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
408
409 }
410
411 void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
412 {
413     // Set file-name for opening ESD friend, default "AliESDfriends.root".
414
415     if (esdf.IsNull()) return;
416     fgESDfriendsFileName = esdf;
417     
418     if (esdf.EndsWith(".zip")) fgESDfriendsFileName.Form("%s#AliESDfriends.root",esdf.Data());
419 }
420
421 void AliEveEventManager::SetAODFileName(const TString& aod)
422 {
423     // Set file-name for opening AOD, default "AliAOD.root".
424
425     if (aod.IsNull()) return;
426     fgAODFileName = aod;
427     
428     if (aod.EndsWith(".zip")) fgAODFileName.Form("%s#AliAOD.root",aod.Data());
429     
430 }
431
432 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
433 {
434     // Add new AOD friend file-name to be attached when opening AOD.
435     // This should include '.root', as in 'AliAOD.VertexingHF.root'.
436
437     if (fgAODfriends == 0)
438     {
439         fgAODfriends = new TList;
440         fgAODfriends->SetOwner(kTRUE);
441     }
442     if (fgAODfriends->FindObject(friendFileName) == 0)
443     {
444         fgAODfriends->Add(new TObjString(friendFileName));
445     }
446 }
447
448 void AliEveEventManager::SetRawFileName(const TString& raw)
449 {
450     // Set file-name for opening of raw-data, default "raw.root"
451     if (raw.IsNull()) return;
452     
453     fgRawFileName = raw;
454 }
455
456 void AliEveEventManager::SetCdbUri(const TString& cdb)
457 {
458     // Set path to CDB, there is no default.
459     if ( ! cdb.IsNull()) fgCdbUri = cdb;
460 }
461
462 void AliEveEventManager::SetGAliceFileName(const TString& galice)
463 {
464     // Set file-name for opening gAlice, default "galice.root".
465
466     if ( galice.IsNull()) return;
467     fgGAliceFileName = galice;
468     
469     if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
470 }
471
472 void AliEveEventManager::SetFilesPath(const TString& urlPath)
473 {
474     TString path = urlPath;
475     gSystem->ExpandPathName(path);
476     if (path.IsNull() || path == ".")
477     {
478         path = gSystem->WorkingDirectory();
479     }
480
481     TString sep;
482     if(path.EndsWith(".zip")) // if given a path to root_archive.zip
483         sep= "#";
484     else if(!path.EndsWith("/"))
485         sep = "/";
486     
487     SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
488     SetESDfriendFileName(  TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
489     SetAODFileName(  TString(Form("%s%sAliAOD.root", path.Data(), sep.Data())) );
490     AddAODfriend(  TString(Form("%s%sAliAOD.VertexingHF.root", path.Data(), sep.Data())) );
491     SetGAliceFileName( TString(Form("%s%sgalice.root", path.Data(), sep.Data())) );
492     SetRawFileName(TString(Form("%s%sraw.root", path.Data(), sep.Data())));
493 }
494
495 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
496                                            Bool_t assertAod, Bool_t assertRaw)
497 {
498     // Set global flags that detrmine which parts of the event-data must
499     // be present when the event is opened.
500
501     fgAssertRunLoader = assertRunloader;
502     fgAssertESD = assertEsd;
503     fgAssertAOD = assertAod;
504     fgAssertRaw = assertRaw;
505 }
506
507 void AliEveEventManager::SearchRawForCentralReconstruction()
508 {
509     // Enable searching of raw data in standard location. The path passed to
510     // Open() is expected to point to a centrally reconstructed run, e.g.:
511     // "alien:///alice/data/2009/LHC09c/000101134/ESDs/pass1/09000101134018.10".
512
513     fgRawFromStandardLoc = kTRUE;
514 }
515
516 /******************************************************************************/
517
518 void AliEveEventManager::Open()
519 {
520     // Open event-data from URL specified in path.
521     // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
522     // Warning is reported if run-loader or ESD is not found.
523     // Global data-members fgAssertRunLoader and fgAssertESD can be set
524     // to throw exceptions instead.
525
526     static const TEveException kEH("AliEveEventManager::Open ");
527
528     if (fExternalCtrl)
529     {
530         throw (kEH + "Event-loop is under external control.");
531     }
532     if (fIsOpen)
533     {
534         throw (kEH + "Event-files already opened.");
535     }
536
537     Int_t runNo = -1;
538
539     // Open ESD and ESDfriends
540     
541     if ((fESDFile = TFile::Open(fgESDFileName)))
542     {
543         fESD = new AliESDEvent();
544
545         switch(fgESDvisibleTrees){
546         case AliEveEventManager::kOfflineTree :
547             fESDTree = readESDTree("esdTree", runNo);
548             break;
549         case AliEveEventManager::kHLTTree :
550             fHLTESDTree = readESDTree("HLTesdTree", runNo);
551             break;
552         default:
553             fESDTree    = readESDTree("esdTree", runNo);
554             fHLTESDTree = readESDTree("HLTesdTree", runNo);
555         }
556
557         if(!fESDTree && !fHLTESDTree){
558             // both ESD trees are == 0
559             delete fESDFile; fESDFile = 0;
560             delete fESD; fESD = 0;
561         }
562
563
564     }
565     else // esd file not readable
566     {
567         Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
568     }
569     if (fESDTree == 0 && fHLTESDTree==0)
570     {
571         if (fgAssertESD)
572         {
573             throw (kEH + "ESD not initialized. Its precence was requested.");
574         } else {
575             Warning(kEH, "ESD not initialized.");
576         }
577     }
578
579     // Open AOD and registered friends
580     if ( (fAODFile = TFile::Open(fgAODFileName)) )
581     {
582         fAOD = new AliAODEvent();
583         fAODTree = (TTree*) fAODFile->Get("aodTree");
584         if (fAODTree != 0)
585         {
586             // Check if AODfriends exist and attach them.
587             TIter       friends(fgAODfriends);
588             TObjString *name;
589             while ((name = (TObjString*) friends()) != 0)
590             {
591                 TString p(Form("%s/%s", fgAODFileName.Data(), name->GetName()));
592                 if (fgAODFileName.EndsWith(".zip")) p.Form("%s#%s",fgAODFileName.Data(),name->GetName());
593                 if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
594                 {
595                     fAODTree->AddFriend("aodTree", name->GetName());
596                 }
597             }
598
599             fAOD->ReadFromTree(fAODTree);
600
601             if (fAODTree->GetEntry(0) <= 0)
602             {
603                 delete fAODFile; fAODFile = 0;
604                 delete fAOD;     fAOD     = 0;
605                 Warning(kEH, "failed getting the first entry from addTree.");
606             }
607             else
608             {
609                 if (runNo < 0)
610                     runNo = fAOD->GetRunNumber();
611             }
612         }
613         else // aodtree == 0
614         {
615             delete fAODFile; fAODFile = 0;
616             delete fAOD;     fAOD     = 0;
617             Warning(kEH, "failed getting the aodTree.");
618         }
619     }
620     else // aod not readable
621     {
622         Warning(kEH, "can not read AOD file '%s'.", fgAODFileName.Data());
623     }
624     if (fAODTree == 0)
625     {
626         if (fgAssertAOD)
627         {
628             throw (kEH + "AOD not initialized. Its precence was requested.");
629         } else {
630             Warning(kEH, "AOD not initialized.");
631         }
632     }
633
634     // Open RunLoader from galice.root
635 //    fgGAliceFileName = "/Users/Jerus/galice.root"; // temp
636     
637     TFile *gafile = TFile::Open(fgGAliceFileName);
638     cout<<"Opening galice"<<endl;
639     if (gafile)
640     {
641         gafile->Close();
642         delete gafile;
643         cout<<"SETTING RUN LOADER in Open()"<<endl;
644         fRunLoader = AliRunLoader::Open(fgGAliceFileName, GetName());
645         if (fRunLoader)
646         {
647             TString alicePath(gSystem->DirName(fgGAliceFileName));
648             alicePath.Append("/");
649             fRunLoader->SetDirName(alicePath);
650
651             if (fRunLoader->LoadgAlice() != 0)
652                 Warning(kEH, "failed loading gAlice via run-loader.");
653
654             if (fRunLoader->LoadHeader() == 0)
655             {
656                 if (runNo < 0)
657                     runNo = fRunLoader->GetHeader()->GetRun();
658             }
659             else
660             {
661                 Warning(kEH, "failed loading run-loader's header.");
662                 delete fRunLoader;
663                 fRunLoader = 0;
664             }
665         }
666         else // run-loader open failed
667         {
668             Warning(kEH, "failed opening ALICE run-loader from '%s'.", fgGAliceFileName.Data());
669         }
670         
671     }
672     else // galice not readable
673     {
674         Warning(kEH, "can not read '%s'.", fgGAliceFileName.Data());
675     }
676     if (fRunLoader == 0)
677     {
678         if (fgAssertRunLoader)
679             throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
680         else
681             Warning(kEH, "Bootstraping of run-loader failed.");
682     }
683
684     // Open raw-data file
685
686     TString rawPath;
687     if (fgRawFromStandardLoc)
688     {
689         if (!fgRawFileName.BeginsWith("alien:"))
690             throw kEH + "Standard raw search requested, but the directory is not in AliEn.";
691         if (!fgRawFileName.Contains("/ESDs/"))
692             throw kEH + "Standard raw search requested, but does not contain 'ESDs' directory.";
693
694         TPMERegexp chunk("/([\\d\\.])+/?$");
695         Int_t nm = chunk.Match(fgRawFileName);
696         if (nm != 2)
697             throw kEH + "Standard raw search requested, but the path does not end with chunk-id directory.";
698
699         TPMERegexp esdstrip("/ESDs/.*");
700         rawPath = fgRawFileName;
701         esdstrip.Substitute(rawPath, "/raw/");
702         rawPath += chunk[0];
703         rawPath += ".root";
704
705         Info(kEH, "Standard raw search requested, using the following path:\n  %s\n", rawPath.Data());
706     }
707     else
708     {
709         rawPath = fgRawFileName;
710     }
711     // If i use open directly, raw-reader reports an error but i have
712     // no way to detect it.
713     // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
714     AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
715     if (fgAssertRaw == kFALSE)
716     {
717         AliLog::SetGlobalLogLevel(AliLog::kFatal);
718     }
719     if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
720     {
721         fRawReader = AliRawReader::Create(rawPath);
722     }
723     else
724     {
725         fRawReader = AliRawReader::Create(fgRawFileName);
726     }
727     if (fgAssertRaw == kFALSE)
728     {
729         AliLog::SetGlobalLogLevel(oldLogLevel);
730     }
731
732     if (fRawReader == 0)
733     {
734         if (fgAssertRaw)
735         {
736             throw (kEH + "raw-data not initialized. Its precence was requested.");
737         }
738         else
739         {
740             Warning(kEH, "raw-data not initialized.");
741         }
742     }
743
744     if (runNo < 0)
745     {
746         if (fRawReader)
747         {
748             if ( ! fRawReader->NextEvent())
749             {
750                 throw (kEH + "can not go to first event in raw-reader to determine run-id.");
751             }
752             runNo = fRawReader->GetRunNumber();
753             Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
754             fRawReader->RewindEvents();
755         }
756         else
757         {
758             fExternalCtrl = kTRUE;
759              fEventId = 0;
760             return;
761         }
762     }
763
764     // Initialize OCDB ... only in master event-manager
765
766                 InitOCDB(runNo);
767
768
769     fIsOpen = kTRUE;
770 }
771
772 void AliEveEventManager::InitOCDB(int runNo)
773 {
774   static const TEveException kEH("AliEveEventManager::InitOCDB ");
775     //if (this == fgMaster)
776     {
777       AliCDBManager* cdb = AliCDBManager::Instance();
778         if (cdb->IsDefaultStorageSet() == kTRUE)
779         {
780             Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
781                     cdb->GetDefaultStorage()->GetURI().Data());
782         }
783         else
784         {
785             if (fgCdbUri.IsNull())
786             {
787                 gEnv->SetValue("Root.Stacktrace", "no");
788                 Fatal("Open()", "OCDB path was not specified.");
789             }
790
791             // Handle some special cases for MC (should be in OCDBManager).
792             if (fgCdbUri == "mcideal://")
793                 cdb->SetDefaultStorage("MC", "Ideal");
794             else if (fgCdbUri == "mcresidual://")
795                 cdb->SetDefaultStorage("MC", "Residual");
796             else if (fgCdbUri == "mcfull://")
797                 cdb->SetDefaultStorage("MC", "Full");
798             else if (fgCdbUri == "local://") {
799                 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
800                 cdb->SetDefaultStorage(fgCdbUri);
801             } else
802                 cdb->SetDefaultStorage(fgCdbUri);
803
804             cdb->SetRun(runNo);
805
806             if (cdb->IsDefaultStorageSet() == kFALSE)
807                 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
808         }
809         if (fgCdbUri.BeginsWith("local://"))
810         {
811             TString curPath = gSystem->WorkingDirectory();
812             TString grp     = "GRP/GRP/Data";
813             TString grppath = curPath + "/" + grp;
814             if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
815             {
816                 if (cdb->GetSpecificStorage(grp))
817                 {
818                     Warning(kEH, "Local GRP exists, but the specific storage is already set.");
819                 }
820                 else
821                 {
822                     Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
823                     TString lpath("local://");
824                     lpath += curPath;
825                     cdb->SetSpecificStorage(grp, lpath);
826                 }
827             }
828         }
829     }
830 }
831
832 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
833 {
834     // Set an event from an external source.
835     // The method is used in the online visualisation.
836     // AOD is not supported.
837
838     static const TEveException kEH("AliEveEventManager::SetEvent ");
839
840     if (fIsOpen)
841     {
842         Warning(kEH, "Event-files were open. Closing and switching to external control.");
843         Close();
844     }
845
846                         Info(kEH,"setting it!!! ============================");
847
848     fRunLoader = runLoader;
849     fRawReader = rawReader;
850     fESD       = esd;
851     fESDfriend = esdf;
852     fAOD       = 0;
853
854     fEventId++;
855     fHasEvent     = kTRUE;
856     fExternalCtrl = kTRUE;
857
858     SetTitle("Online event in memory");
859     SetName ("Online Event");
860     ElementChanged();
861
862     AfterNewEventLoaded();
863
864     if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
865     
866 }
867
868 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
869 {
870     // Returns maximum available event id.
871     // If under external control or event is not opened -1 is returned.
872     // If raw-data is the only data-source this can not be known
873     // and 10,000,000 is returned.
874     // If neither data-source is initialised an exception is thrown.
875     // If refresh_esd is true and ESD is the primary event-data source
876     // its header is re-read from disk.
877
878     static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
879
880     if (fExternalCtrl || fIsOpen == kFALSE)
881     {
882         return -1;
883     }
884
885     if ((fESDTree!=0) || (fHLTESDTree!=0))
886     {
887         if (refreshESD)
888         {
889             if(fESDTree!=0) fESDTree->Refresh();
890             if(fHLTESDTree!=0) fHLTESDTree->Refresh();
891             fPEventSelector->Update();
892         }
893
894         Int_t maxEventId=0;
895         switch(fgESDvisibleTrees){
896         default:
897         case AliEveEventManager::kOfflineTree :
898             maxEventId = fESDTree->GetEntries() - 1;
899             break;
900         case AliEveEventManager::kHLTTree :
901             maxEventId = fHLTESDTree->GetEntries() - 1;
902             break;
903        }
904
905         return maxEventId;
906     }
907     else if (fAODTree)
908     {
909         return fAODTree->GetEntries() - 1;
910     }
911     else if (fRunLoader)
912     {
913         return fRunLoader->GetNumberOfEvents() - 1;
914     }
915     else if (fRawReader)
916     {
917         Int_t n = fRawReader->GetNumberOfEvents() - 1;
918         return n > -1 ? n : 10000000;
919     }
920     else
921     {
922         throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
923     }
924 }
925
926 void AliEveEventManager::GotoEvent(Int_t event)
927 {
928     cout<<"Go to event:"<<event<<endl;
929     // Load data for specified event.
930     // If event is out of range an exception is thrown and old state
931     // is preserved.
932     // After successful loading of event, the virtual function
933     // AfterNewEventLoaded() is called. This executes commands that
934     // were registered via TEveEventManager::AddNewEventCommand().
935     //
936     // If event is negative, it is subtracted from the number of
937     // available events, thus passing -1 will load the last event.
938     // This is not supported when raw-data is the only data-source
939     // as the number of events is not known.
940
941     static const TEveException kEH("AliEveEventManager::GotoEvent ");
942
943     if (fAutoLoadTimerRunning)
944     {
945         throw (kEH + "Event auto-load timer is running.");
946     }
947     if (fExternalCtrl)
948     {
949       // throw (kEH + "Event-loop is under external control.");
950 #ifdef ZMQ
951       if(fOnlineMode)
952         {
953           if (fStorageDown && -1 == event) 
954             {
955               NextEvent();
956               return;
957             }
958
959           if (fESD)
960             {
961               // create new server request:
962               struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
963             
964               // set request type:
965               if (event == -1)      {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
966               else  if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
967               else  if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
968               else  if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
969             
970               // set event struct:
971               struct eventStruct eventToLoad;
972               eventToLoad.runNumber = fESD->GetRunNumber();
973               eventToLoad.eventNumber = fESD->GetEventNumberInFile();
974               requestMessage->event = eventToLoad;
975             
976               // create event manager:
977               AliStorageEventManager *eventManager =
978                 AliStorageEventManager::GetEventManagerInstance();
979               AliESDEvent *resultEvent = NULL;
980             
981               eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
982               fMutex->Lock();
983             
984               // send request and receive event:
985               eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
986               resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
987             
988               if(resultEvent)
989                 {
990                   DestroyElements();
991                   InitOCDB(resultEvent->GetRunNumber());
992                   SetEvent(0,0,resultEvent,0);
993                 }
994               else
995                 {
996                   if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
997                   if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
998                   if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
999                   if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
1000                 }
1001             
1002               fMutex->UnLock();
1003             }
1004           else
1005             {
1006               cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
1007
1008               struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1009               requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1010             
1011               AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1012               eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1013               AliESDEvent *resultEvent = NULL;
1014             
1015               fMutex->Lock();
1016               eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1017               resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1018             
1019               if(resultEvent)
1020                 {
1021                   fESD=resultEvent;
1022                   DestroyElements();
1023                   InitOCDB(resultEvent->GetRunNumber());
1024                   SetEvent(0,0,resultEvent,0);
1025                 }
1026               else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1027               fMutex->UnLock();
1028             }
1029         }
1030 #endif  
1031
1032     }
1033     else if (!fIsOpen)
1034     {
1035         throw (kEH + "Event-files not opened.");
1036     }
1037
1038     fEventInfo.Reset();
1039
1040     fHasEvent = kFALSE;
1041
1042     Int_t maxEvent = 0;
1043     if ((fESDTree!=0) || (fHLTESDTree!=0))
1044     {
1045         if(fESDTree){
1046             if (event >= fESDTree->GetEntries())
1047                 fESDTree->Refresh();
1048             maxEvent = fESDTree->GetEntries() - 1;
1049             if (event < 0)
1050                 event = fESDTree->GetEntries() + event;
1051         }
1052
1053         if(fHLTESDTree){
1054             if (event >= fHLTESDTree->GetEntries())
1055                 fHLTESDTree->Refresh();
1056             maxEvent = fHLTESDTree->GetEntries() - 1;
1057             if (event < 0)
1058                 event = fHLTESDTree->GetEntries() + event;
1059
1060         }
1061     }
1062     else if (fAODTree)
1063     {
1064         maxEvent = fAODTree->GetEntries() - 1;
1065         if (event < 0)
1066             event = fAODTree->GetEntries() + event;
1067     }
1068     else if (fRunLoader)
1069     {
1070         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1071         if (event < 0)
1072             event = fRunLoader->GetNumberOfEvents() + event;
1073     }
1074     else if (fRawReader)
1075     {
1076         maxEvent = fRawReader->GetNumberOfEvents() - 1;
1077         if (maxEvent < 0)
1078         {
1079             maxEvent = 10000000;
1080             if (event < 0) {
1081                 Error(kEH, "current raw-data source does not support direct event access.");
1082                 return;
1083             }
1084             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1085         }
1086         else
1087         {
1088             if (event < 0)
1089                 event = fRawReader->GetNumberOfEvents() + event;
1090         }
1091     }
1092     else
1093     {
1094         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1095     }
1096     if (event < 0 || event > maxEvent)
1097     {
1098         throw (kEH + Form("event %d not present, available range [%d, %d].",
1099                           event, 0, maxEvent));
1100     }
1101
1102     TString sysInfoHeader;
1103     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1104     AliSysInfo::AddStamp(sysInfoHeader + "Start");
1105
1106     TEveManager::TRedrawDisabler rd(gEve);
1107     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1108
1109     // !!! MT this is somewhat brutal; at least optionally, one could be
1110     // a bit gentler, checking for objs owning their external refs and having
1111     // additinal parents.
1112     gEve->GetViewers()->DeleteAnnotations();
1113     fTransients->DestroyElements();
1114     for (TEveElement::List_i i = fTransientLists->BeginChildren();
1115          i != fTransientLists->EndChildren(); ++i)
1116     {
1117         (*i)->DestroyElements();
1118     }
1119     DestroyElements();
1120
1121     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1122
1123     if (fESDTree) {
1124         if (fESDTree->GetEntry(event) <= 0)
1125             throw (kEH + "failed getting required event from ESD.");
1126
1127         if (fESDfriendExists)
1128             fESD->SetESDfriend(fESDfriend);
1129     }
1130
1131     if (fHLTESDTree) {
1132         if (fHLTESDTree->GetEntry(event) <= 0)
1133             throw (kEH + "failed getting required event from HLT ESD.");
1134
1135         if (fESDfriendExists)
1136             fESD->SetESDfriend(fESDfriend);
1137     }
1138
1139     if (fAODTree) {
1140         if (fAODTree->GetEntry(event) <= 0)
1141             throw (kEH + "failed getting required event from AOD.");
1142     }
1143
1144     if (fRunLoader) {
1145         if (fRunLoader->GetEvent(event) != 0)
1146             throw (kEH + "failed getting required event.");
1147     }
1148
1149     if (fRawReader)
1150     {
1151         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1152         if (fRawReader->GotoEvent(event) == kFALSE)
1153         {
1154             // Use fallback method - iteration with NextEvent().
1155             Int_t rawEv = fEventId;
1156             if (event < rawEv)
1157             {
1158                 fRawReader->RewindEvents();
1159                 rawEv = -1;
1160             }
1161
1162             while (rawEv < event)
1163             {
1164                 if ( ! fRawReader->NextEvent())
1165                 {
1166                     fRawReader->RewindEvents();
1167                     fEventId = -1;
1168                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1169                 }
1170                 ++rawEv;
1171             }
1172             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1173         }
1174     }
1175
1176     fHasEvent = kTRUE;
1177     fEventId  = event;
1178     if (this == fgMaster)
1179     {
1180         SetName(Form("Event %d", fEventId));
1181         ElementChanged();
1182     }
1183
1184     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1185
1186     AfterNewEventLoaded();
1187
1188     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1189 }
1190
1191 void AliEveEventManager::Timeout()
1192 {
1193     Emit("Timeout()");
1194 }
1195
1196 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1197 {       
1198         DestroyElements();
1199         InitOCDB(event->GetRunNumber());
1200         printf("======================= setting event to %d\n", fEventId);
1201         SetEvent(0,0,event,0);
1202 }
1203
1204 void AliEveEventManager::NextEvent()
1205 {
1206     // Loads next event.
1207     // Does magick needed for online display when under external event control.
1208
1209     static const TEveException kEH("AliEveEventManager::NextEvent ");
1210
1211     if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1212     
1213     if (fExternalCtrl)
1214     {
1215 #ifdef ZMQ
1216       if(fOnlineMode)
1217         {
1218           if(fIsNewEventAvaliable)
1219             {
1220               fMutex->Lock();
1221               if(fWritingToEventIndex == 0) fEventInUse = 0;
1222               else if(fWritingToEventIndex == 1) fEventInUse = 1;
1223             
1224               if(fCurrentEvent[fEventInUse])
1225                 {
1226                   if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1227                     {
1228                       printf("======================= setting event to %d\n", fCurrentEvent[fEventInUse]->GetEventNumberInFile());
1229                     
1230                       DestroyElements();
1231                       InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1232                       SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1233                     
1234                     }
1235                 }
1236               fIsNewEventAvaliable = false;
1237               fMutex->UnLock();
1238             }
1239           else
1240             {
1241               cout<<"No new event is avaliable."<<endl;
1242               NoEventLoaded();
1243             }
1244         }
1245 #endif
1246     }
1247     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1248     {
1249       Int_t nextevent=0;
1250       if (fPEventSelector->FindNext(nextevent))
1251       {
1252         GotoEvent(nextevent);
1253       }
1254     }
1255     else if (fEventId < GetMaxEventId(kTRUE))
1256     {
1257       GotoEvent(fEventId + 1);
1258     }
1259     
1260     gSystem->ProcessEvents();
1261     
1262     /*
1263     cout<<"VSD"<<endl;
1264     AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1265     cout<<"contructor called"<<endl;
1266     vsdCreator->CreateVSD("myVSD.root");
1267     cout<<"PO"<<endl;
1268 */
1269     //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1270 }
1271
1272 void AliEveEventManager::PrevEvent()
1273 {
1274     // Loads previous event.
1275
1276     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1277
1278     if (fAutoLoadTimerRunning)
1279     {
1280         throw (kEH + "Event auto-load timer is running.");
1281     }
1282     if (fExternalCtrl)
1283     {
1284         throw (kEH + "Event-loop is under external control.");
1285     }
1286
1287     if ((fESDTree!=0) || (fHLTESDTree!=0))
1288     {
1289         Int_t nextevent=0;
1290         if (fPEventSelector->FindPrev(nextevent))
1291         {
1292             GotoEvent(nextevent);
1293         }
1294     }
1295     else if (fEventId > 0)
1296     {
1297         GotoEvent(fEventId - 1);
1298     }
1299 }
1300
1301 void AliEveEventManager::MarkCurrentEvent()
1302 {
1303 #ifdef ZMQ
1304   if(!fOnlineMode){return;}
1305
1306         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1307         struct eventStruct mark;
1308         mark.runNumber = fESD->GetRunNumber();
1309         mark.eventNumber = fESD->GetEventNumberInFile();
1310         requestMessage->messageType = REQUEST_MARK_EVENT;
1311         requestMessage->event = mark;
1312
1313         AliStorageEventManager *eventManager =
1314                 AliStorageEventManager::GetEventManagerInstance();
1315         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1316
1317         /*
1318         std::future<bool> unused = std::async([]()
1319         {
1320                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1321                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1322
1323                 if(response)
1324                 {
1325                 //fStatusLabel->SetText("Event marked");
1326                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1327                 }
1328                 else
1329                 {
1330                 //fStatusLabel->SetText("Couldn't mark this event");
1331                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1332                 }
1333         });
1334         */
1335         
1336         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1337         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1338         
1339         
1340         if(response)
1341         {
1342                 //fStatusLabel->SetText("Event marked");
1343                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1344         }
1345         else
1346         {
1347                 //fStatusLabel->SetText("Couldn't mark this event");
1348                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1349         }
1350         if(requestMessage){delete requestMessage;}
1351 #endif
1352 }
1353
1354 void AliEveEventManager::Close()
1355 {
1356     // Close the event data-files and delete ESD, ESDfriend, run-loader
1357     // and raw-reader.
1358
1359     cout<<"\n\n\nClose() called!!\n\n\n"<<endl;
1360     
1361     static const TEveException kEH("AliEveEventManager::Close ");
1362
1363     if (!fIsOpen)
1364     {
1365         throw (kEH + "Event-files not opened.");
1366     }
1367
1368     if (fAutoLoadTimerRunning)
1369         StopAutoLoadTimer();
1370
1371     if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1372         delete fESD;       fESD       = 0;
1373         // delete fESDfriend; // friend tree is deleted with the tree
1374         fESDfriend = 0;
1375         fESDfriendExists = kFALSE;
1376
1377         if(fESDTree) { delete fESDTree;   fESDTree = 0; }
1378         if(fHLTESDTree) { delete fHLTESDTree;   fHLTESDTree = 0; }
1379         delete fESDFile;   fESDFile = 0;
1380     }
1381
1382     if (fAODTree) {
1383         delete fAOD;       fAOD       = 0;
1384
1385         delete fAODTree;   fAODTree = 0;
1386         delete fAODFile;   fAODFile = 0;
1387     }
1388
1389     if (fRunLoader) {
1390         delete fRunLoader; fRunLoader = 0;
1391     }
1392
1393     if (fRawReader) {
1394         delete fRawReader; fRawReader = 0;
1395     }
1396
1397     fEventId  = -1;
1398     fIsOpen   = kFALSE;
1399     fHasEvent = kFALSE;
1400 }
1401
1402
1403 //------------------------------------------------------------------------------
1404 // Static convenience functions, mainly used from macros.
1405 //------------------------------------------------------------------------------
1406
1407 Int_t AliEveEventManager::CurrentEventId()
1408 {
1409     // Return current event-id.
1410
1411     static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1412
1413     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1414         throw (kEH + "ALICE event not ready.");
1415     return fgCurrent->GetEventId();
1416 }
1417
1418 Bool_t AliEveEventManager::HasRunLoader()
1419 {
1420     // Check if AliRunLoader is initialized.
1421
1422     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1423 }
1424
1425 Bool_t AliEveEventManager::HasESD()
1426 {
1427     // Check if AliESDEvent is initialized.
1428
1429     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1430 }
1431
1432 Bool_t AliEveEventManager::HasESDfriend()
1433 {
1434     // Check if AliESDfriend is initialized.
1435
1436     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1437 }
1438
1439 Bool_t AliEveEventManager::HasAOD()
1440 {
1441     // Check if AliESDEvent is initialized.
1442
1443     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1444 }
1445
1446 Bool_t AliEveEventManager::HasRawReader()
1447 {
1448     // Check if raw-reader is initialized.
1449
1450     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1451 }
1452
1453 AliRunLoader* AliEveEventManager::AssertRunLoader()
1454 {
1455     // Make sure AliRunLoader is initialized and return it.
1456     // Throws exception in case run-loader is not available.
1457     // Static utility for macros.
1458
1459     static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
1460
1461     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1462         throw (kEH + "ALICE event not ready.");
1463     if (fgCurrent->fRunLoader == 0)
1464         throw (kEH + "AliRunLoader not initialised.");
1465     return fgCurrent->fRunLoader;
1466 }
1467
1468 AliESDEvent* AliEveEventManager::AssertESD()
1469 {
1470     // Make sure AliESDEvent is initialized and return it.
1471     // Throws exception in case ESD is not available.
1472     // Static utility for macros.
1473
1474     static const TEveException kEH("AliEveEventManager::AssertESD ");
1475
1476     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1477         throw (kEH + "ALICE event not ready.");
1478     if (fgCurrent->fESD == 0)
1479         throw (kEH + "AliESD not initialised.");
1480     return fgCurrent->fESD;
1481 }
1482
1483 AliESDfriend* AliEveEventManager::AssertESDfriend()
1484 {
1485     // Make sure AliESDfriend is initialized and return it.
1486     // Throws exception in case ESDfriend-loader is not available.
1487     // Static utility for macros.
1488
1489     static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1490
1491     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1492         throw (kEH + "ALICE event not ready.");
1493     if (fgCurrent->fESDfriend == 0)
1494         throw (kEH + "AliESDfriend not initialised.");
1495     return fgCurrent->fESDfriend;
1496 }
1497
1498 AliAODEvent* AliEveEventManager::AssertAOD()
1499 {
1500     // Make sure AliAODEvent is initialized and return it.
1501     // Throws exception in case AOD is not available.
1502     // Static utility for macros.
1503
1504     static const TEveException kEH("AliEveEventManager::AssertAOD ");
1505
1506     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1507         throw (kEH + "ALICE event not ready.");
1508     if (fgCurrent->fAOD == 0)
1509         throw (kEH + "AliAOD not initialised.");
1510     return fgCurrent->fAOD;
1511 }
1512
1513 AliRawReader* AliEveEventManager::AssertRawReader()
1514 {
1515     // Make sure raw-reader is initialized and return it.
1516
1517     static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1518
1519     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1520         throw (kEH + "ALICE event not ready.");
1521     if (fgCurrent->fRawReader == 0)
1522         throw (kEH + "RawReader not ready.");
1523
1524     return fgCurrent->fRawReader;
1525 }
1526
1527 //==============================================================================
1528
1529 AliMagF* AliEveEventManager::AssertMagField()    
1530 {        
1531     // Make sure AliMagF is initialized and returns it.
1532     // Throws exception in case magnetic field is not available.
1533     // Static utility for macros.
1534
1535     static const TEveException kEH("AliEveEventManager::AssertMagField ");
1536
1537     if (fgMagField)
1538         return fgMagField;
1539
1540     if (TGeoGlobalMagField::Instance()->GetField())
1541     {
1542         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1543         if (fgMagField == 0)
1544             throw kEH + "Global field set, but it is not AliMagF.";
1545         return fgMagField;
1546     }
1547
1548     if (!fgGRPLoaded)
1549     {
1550         InitGRP();
1551     }
1552
1553     if (TGeoGlobalMagField::Instance()->GetField())
1554     {
1555         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1556         if (fgMagField == 0)
1557             throw kEH + "Global field set, but it is not AliMagF.";
1558     }
1559     else
1560     {
1561         throw kEH + "Could not initialize magnetic field.";
1562     }
1563
1564     return fgMagField;
1565 }
1566
1567 TGeoManager* AliEveEventManager::AssertGeometry()
1568 {
1569     // Make sure AliGeomManager is initialized and returns the
1570     // corresponding TGeoManger.
1571     // gGeoManager is set to the return value.
1572     // Throws exception if geometry can not be loaded or if it is not
1573     // available and the TGeoManager is locked.
1574     // Static utility for macros.
1575
1576     static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1577
1578     if (AliGeomManager::GetGeometry() == 0)
1579     {
1580         if (TGeoManager::IsLocked())
1581             throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1582
1583         gGeoManager = 0;
1584         AliGeomManager::LoadGeometry();
1585         if ( ! AliGeomManager::GetGeometry())
1586         {
1587             throw (kEH + "can not load geometry.");
1588         }
1589         if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1590         {
1591             ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1592             // throw (kEH + "could not apply align objs.");
1593         }
1594         AliGeomManager::GetGeometry()->DefaultColors();
1595     }
1596
1597     gGeoManager = AliGeomManager::GetGeometry();
1598     return gGeoManager;
1599 }
1600
1601 AliRecoParam* AliEveEventManager::AssertRecoParams()
1602 {
1603     if(!fgRecoParam)
1604         InitRecoParam();
1605
1606     return fgRecoParam;
1607 }
1608
1609 Bool_t AliEveEventManager::InitRecoParam()
1610 {
1611     // This is mostly a reap-off from reconstruction
1612     // The method accesses OCDB and retrieves all
1613     // the available reco-param objects from there.
1614
1615     fgRecoParam = new AliRecoParam;
1616     const Int_t  kNDetectors = 14;
1617
1618     static const TEveException kEH("AliEveEventManager::InitRecoParam");
1619
1620     Bool_t isOK = kTRUE;
1621
1622     if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1623         ::Info(kEH, "Using custom GRP reconstruction parameters");
1624     }
1625     else {
1626         ::Info(kEH, "Loading GRP reconstruction parameter objects");
1627
1628         AliCDBPath path("GRP","Calib","RecoParam");
1629         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1630         if(!entry){
1631             ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
1632             isOK = kFALSE;
1633         }
1634         else {
1635             TObject *recoParamObj = entry->GetObject();
1636             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1637                 // GRP has a normal TobjArray of AliDetectorRecoParam objects
1638                 // Registering them in AliRecoParam
1639                 fgRecoParam->AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
1640             }
1641             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1642                 // GRP has only onse set of reco parameters
1643                 // Registering it in AliRecoParam
1644                 ::Info(kEH, "Single set of GRP reconstruction parameters found");
1645                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1646                 fgRecoParam->AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1647             }
1648             else {
1649                 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1650                 isOK = kFALSE;
1651             }
1652             entry->SetOwner(0);
1653         }
1654     }
1655
1656     const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1657
1658
1659     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1660
1661         if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1662             ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1663             continue;
1664         }
1665
1666         ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1667
1668         AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1669         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1670         if(!entry){
1671             ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
1672             isOK = kFALSE;
1673         }
1674         else {
1675             TObject *recoParamObj = entry->GetObject();
1676             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1677                 // The detector has a normal TobjArray of AliDetectorRecoParam objects
1678                 // Registering them in AliRecoParam
1679                 fgRecoParam->AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
1680             }
1681             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1682                 // The detector has only onse set of reco parameters
1683                 // Registering it in AliRecoParam
1684                 ::Info(kEH, "Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]);
1685                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1686                 fgRecoParam->AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1687             }
1688             else {
1689                 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1690                 isOK = kFALSE;
1691             }
1692             entry->SetOwner(0);
1693
1694         }
1695     }
1696
1697     if(!isOK) {
1698         delete fgRecoParam;
1699         fgRecoParam = 0;
1700     }
1701
1702     return isOK;
1703 }
1704
1705 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1706 {
1707     if(!fESDFile && !fESD) return 0;
1708
1709     static const TEveException kEH("AliEveEventManager::readESDTree ");
1710
1711     TTree* tempTree = 0;
1712
1713     tempTree =(TTree*) fESDFile->Get(treeName);
1714     if (tempTree != 0)
1715     {
1716         TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1717         if (esdFriendFile)
1718         {
1719             if (!esdFriendFile->IsZombie())
1720             {
1721                 esdFriendFile->Close();
1722                 fESDfriendExists = kTRUE;
1723                 tempTree->SetBranchStatus ("ESDfriend*", 1);
1724             }
1725             delete esdFriendFile;
1726         }
1727
1728         fESD->ReadFromTree(tempTree);
1729         if (fESDfriendExists)
1730         {
1731             fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1732             Info(kEH, "found and attached ESD friend.");
1733         }
1734         else
1735         {
1736             Warning(kEH, "ESDfriend not found.");
1737         }
1738
1739         if (tempTree->GetEntry(0) <= 0)
1740         {
1741             Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1742         }
1743         else
1744         {
1745             if (runNo < 0)
1746                 runNo = fESD->GetESDRun()->GetRunNumber();
1747         }
1748     }
1749     else // tree == 0
1750     {
1751         Warning(kEH, "failed getting the tree:%s", treeName);
1752     }
1753
1754     return tempTree;
1755 }
1756
1757
1758 //------------------------------------------------------------------------------
1759
1760 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1761 {
1762     // Create and attach a dependent event-manager.
1763     // It is not added into eve list tree.
1764
1765     static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1766
1767     if (fgMaster == 0)
1768         throw(kEH + "Master event-manager must be instantiated first.");
1769
1770     if (fgMaster->fSubManagers == 0)
1771     {
1772         fgMaster->fSubManagers = new TList;
1773         fgMaster->fSubManagers->SetOwner(kTRUE);
1774     }
1775
1776     AliEveEventManager* new_mgr = 0;
1777     fgCurrent = 0;
1778     try
1779     {
1780         new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1781         new_mgr->SetFilesPath(path);
1782         fgMaster->fSubManagers->Add(new_mgr);
1783     }
1784     catch (TEveException& exc)
1785     {
1786         ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1787     }
1788     fgCurrent = fgMaster;
1789
1790     return new_mgr;
1791 }
1792
1793 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1794 {
1795     // Get a dependant manager by name.
1796     // This will not change the current manager, use helper class
1797     // AliEveEventManager::CurrentChanger for that.
1798
1799     static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1800
1801     if (fgMaster == 0)
1802         throw(kEH + "Master event-manager must be instantiated first.");
1803
1804     if (fgMaster->fSubManagers == 0)
1805         return 0;
1806
1807     return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1808 }
1809
1810 AliEveEventManager* AliEveEventManager::GetMaster()
1811 {
1812     // Get master event-manager.
1813
1814     return fgMaster;
1815 }
1816
1817 AliEveEventManager* AliEveEventManager::GetCurrent()
1818 {
1819     // Get current event-manager.
1820
1821     return fgCurrent;
1822 }
1823
1824 void AliEveEventManager::RegisterTransient(TEveElement* element)
1825 {
1826     GetCurrent()->fTransients->AddElement(element);
1827 }
1828
1829 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1830 {
1831     GetCurrent()->fTransientLists->AddElement(element);
1832 }
1833
1834 //------------------------------------------------------------------------------
1835 // Autoloading of events
1836 //------------------------------------------------------------------------------
1837
1838 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1839 {
1840     // Set the auto-load time in seconds
1841
1842     fAutoLoadTime = time;
1843 }
1844
1845 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1846 {
1847     // Set the automatic event loading mode
1848
1849     static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1850
1851     if (fAutoLoad == autoLoad)
1852     {
1853         Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1854         return;
1855     }
1856
1857     fAutoLoad = autoLoad;
1858     if (fAutoLoad)
1859     {
1860         StartAutoLoadTimer();
1861     }
1862     else
1863     {
1864         StopAutoLoadTimer();
1865     }
1866 }
1867
1868 void AliEveEventManager::SetLoopMarked(Bool_t loopMarked)
1869 {
1870     // Set the automatic event loading mode
1871     fLoopMarked = loopMarked;
1872     if (fLoopMarked){StartAutoLoadTimer();}
1873     else{StopAutoLoadTimer();}
1874 }
1875
1876 void AliEveEventManager::SetTrigSel(Int_t trig)
1877 {
1878     static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1879
1880     if (!fRawReader)
1881     {
1882         Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1883         return;
1884     }
1885     else
1886     {
1887         ULong64_t trigMask = 0;
1888         if (trig >= 0) trigMask = (1ull << trig);
1889         Info(kEH,"Trigger selection: 0x%llx",trigMask);
1890         fRawReader->SelectEvents(-1,trigMask,NULL);
1891     }
1892 }
1893
1894 void AliEveEventManager::StartAutoLoadTimer()
1895 {
1896     // Start the auto-load timer.
1897
1898     fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1899     fAutoLoadTimer->Reset();
1900     fAutoLoadTimer->TurnOn();
1901     fAutoLoadTimerRunning = kTRUE;
1902 }
1903
1904 void AliEveEventManager::StopAutoLoadTimer()
1905 {
1906     // Stop the auto-load timer.
1907
1908     fAutoLoadTimerRunning = kFALSE;
1909     fAutoLoadTimer->TurnOff();
1910 }
1911
1912 void AliEveEventManager::AutoLoadNextEvent()
1913 {
1914         // Called from auto-load timer, so it has to be public.
1915         // Do NOT call it directly.
1916
1917         static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1918           
1919         Info(kEH, "called!");
1920
1921         if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1922         {
1923                 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1924                 return;
1925         }
1926
1927         StopAutoLoadTimer();
1928         NextEvent();
1929         if (fAutoLoad || fLoopMarked)
1930                 StartAutoLoadTimer();
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 }