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