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