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