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