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