1. Fixing memory leaks in alistorage
[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             long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
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 #ifdef ZMQ
854
855       if (fESD) {
856         int runNumber=fESD->GetRunNumber();
857         int eventNumber=fESD->GetEventNumberInFile();
858         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
859         struct eventStruct eventToLoad;
860         eventToLoad.runNumber = runNumber;
861         // // careful! check if exists!
862         eventToLoad.eventNumber = eventNumber;
863
864         if (event == -1) {
865           requestMessage->messageType = REQUEST_GET_LAST_EVENT;
866         } 
867         else  if (event == 0) {
868           requestMessage->messageType = REQUEST_GET_FIRST_EVENT;
869         } 
870         else  if (event == 1) {
871           requestMessage->messageType = REQUEST_GET_PREV_EVENT;
872         } 
873         else  if (event == 2) {
874           requestMessage->messageType = REQUEST_GET_NEXT_EVENT;
875         } 
876
877         requestMessage->event = eventToLoad;
878
879         AliStorageEventManager *eventManager =
880           AliStorageEventManager::GetEventManagerInstance();
881         AliESDEvent *resultEvent = NULL;
882       
883         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
884         fMutex.Lock();
885         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
886         resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
887
888         if(resultEvent)
889           {
890             cout<<"Event Manager -- first/last or prev/next event loaded "<<resultEvent->GetRunNumber() <<endl;
891             DestroyElements();
892             InitOCDB(resultEvent->GetRunNumber());
893             SetEvent(0,0,resultEvent,0);
894             fMutex.UnLock();
895
896           }
897         else{cout<<"No first/last event is avaliable."<<endl;}
898       }
899       else {
900
901       }
902
903
904 #endif  
905
906     }
907     else if (!fIsOpen)
908     {
909         throw (kEH + "Event-files not opened.");
910     }
911
912     fEventInfo.Reset();
913
914     fHasEvent = kFALSE;
915
916     Int_t maxEvent = 0;
917     if ((fESDTree!=0) || (fHLTESDTree!=0))
918     {
919         if(fESDTree){
920             if (event >= fESDTree->GetEntries())
921                 fESDTree->Refresh();
922             maxEvent = fESDTree->GetEntries() - 1;
923             if (event < 0)
924                 event = fESDTree->GetEntries() + event;
925         }
926
927         if(fHLTESDTree){
928             if (event >= fHLTESDTree->GetEntries())
929                 fHLTESDTree->Refresh();
930             maxEvent = fHLTESDTree->GetEntries() - 1;
931             if (event < 0)
932                 event = fHLTESDTree->GetEntries() + event;
933
934         }
935     }
936     else if (fAODTree)
937     {
938         maxEvent = fAODTree->GetEntries() - 1;
939         if (event < 0)
940             event = fAODTree->GetEntries() + event;
941     }
942     else if (fRunLoader)
943     {
944         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
945         if (event < 0)
946             event = fRunLoader->GetNumberOfEvents() + event;
947     }
948     else if (fRawReader)
949     {
950         maxEvent = fRawReader->GetNumberOfEvents() - 1;
951         if (maxEvent < 0)
952         {
953             maxEvent = 10000000;
954             if (event < 0) {
955                 Error(kEH, "current raw-data source does not support direct event access.");
956                 return;
957             }
958             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
959         }
960         else
961         {
962             if (event < 0)
963                 event = fRawReader->GetNumberOfEvents() + event;
964         }
965     }
966     else
967     {
968         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
969     }
970     if (event < 0 || event > maxEvent)
971     {
972         throw (kEH + Form("event %d not present, available range [%d, %d].",
973                           event, 0, maxEvent));
974     }
975
976     TString sysInfoHeader;
977     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
978     AliSysInfo::AddStamp(sysInfoHeader + "Start");
979
980     TEveManager::TRedrawDisabler rd(gEve);
981     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
982
983     // !!! MT this is somewhat brutal; at least optionally, one could be
984     // a bit gentler, checking for objs owning their external refs and having
985     // additinal parents.
986     gEve->GetViewers()->DeleteAnnotations();
987     fTransients->DestroyElements();
988     for (TEveElement::List_i i = fTransientLists->BeginChildren();
989          i != fTransientLists->EndChildren(); ++i)
990     {
991         (*i)->DestroyElements();
992     }
993     DestroyElements();
994
995     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
996
997     if (fESDTree) {
998         if (fESDTree->GetEntry(event) <= 0)
999             throw (kEH + "failed getting required event from ESD.");
1000
1001         if (fESDfriendExists)
1002             fESD->SetESDfriend(fESDfriend);
1003     }
1004
1005     if (fHLTESDTree) {
1006         if (fHLTESDTree->GetEntry(event) <= 0)
1007             throw (kEH + "failed getting required event from HLT ESD.");
1008
1009         if (fESDfriendExists)
1010             fESD->SetESDfriend(fESDfriend);
1011     }
1012
1013     if (fAODTree) {
1014         if (fAODTree->GetEntry(event) <= 0)
1015             throw (kEH + "failed getting required event from AOD.");
1016     }
1017
1018     if (fRunLoader) {
1019         if (fRunLoader->GetEvent(event) != 0)
1020             throw (kEH + "failed getting required event.");
1021     }
1022
1023     if (fRawReader)
1024     {
1025         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1026         if (fRawReader->GotoEvent(event) == kFALSE)
1027         {
1028             // Use fallback method - iteration with NextEvent().
1029             Int_t rawEv = fEventId;
1030             if (event < rawEv)
1031             {
1032                 fRawReader->RewindEvents();
1033                 rawEv = -1;
1034             }
1035
1036             while (rawEv < event)
1037             {
1038                 if ( ! fRawReader->NextEvent())
1039                 {
1040                     fRawReader->RewindEvents();
1041                     fEventId = -1;
1042                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1043                 }
1044                 ++rawEv;
1045             }
1046             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1047         }
1048     }
1049
1050     fHasEvent = kTRUE;
1051     fEventId  = event;
1052     if (this == fgMaster)
1053     {
1054         SetName(Form("Event %d", fEventId));
1055         ElementChanged();
1056     }
1057
1058     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1059
1060     AfterNewEventLoaded();
1061
1062     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1063 }
1064
1065 void AliEveEventManager::Timeout()
1066 {
1067     Emit("Timeout()");
1068 }
1069
1070 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1071 {       
1072         DestroyElements();
1073                 
1074         InitOCDB(event->GetRunNumber());
1075                         
1076         printf("======================= setting event to %d\n", fEventId);
1077         SetEvent(0,0,event,0);
1078 }
1079
1080 void AliEveEventManager::NextEvent()
1081 {
1082     // Loads next event.
1083     // Does magick needed for online display when under external event control.
1084
1085     static const TEveException kEH("AliEveEventManager::NextEvent ");
1086
1087     if (fAutoLoadTimerRunning)
1088     {
1089         throw (kEH + "Event auto-load timer is running.");
1090     }
1091
1092     if (fExternalCtrl)
1093     {
1094 #ifdef ZMQ
1095
1096       cout<<fIsNewEventAvaliable<<"\t"<<"\t"<<fWritingToEventIndex<<endl;
1097
1098       if(fIsNewEventAvaliable)
1099       {
1100         cout<<"new event"<<endl;
1101         fMutex.Lock();
1102         if(fWritingToEventIndex == 0) fEventInUse = 0;
1103         else if(fWritingToEventIndex == 1) fEventInUse = 1;
1104         cout<<"Using:"<<fEventInUse<<endl;
1105
1106         if(fCurrentEvent[fEventInUse])
1107         {
1108           if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1109           {
1110             printf("======================= setting event to %d\n", fEventId);
1111
1112             DestroyElements();
1113             InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1114             SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1115           }
1116         }
1117         fIsNewEventAvaliable = false;
1118         fMutex.UnLock();
1119       }
1120       else{cout<<"No new event is avaliable."<<endl;}
1121
1122 #endif  
1123     }
1124     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1125     {
1126       Int_t nextevent=0;
1127       if (fPEventSelector->FindNext(nextevent))
1128       {
1129         GotoEvent(nextevent);
1130       }
1131     }
1132     else if (fEventId < GetMaxEventId(kTRUE))
1133     {
1134       GotoEvent(fEventId + 1);
1135     }
1136     
1137     gSystem->ProcessEvents();
1138     
1139     /*
1140     cout<<"VSD"<<endl;
1141     AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1142     cout<<"contructor called"<<endl;
1143     vsdCreator->CreateVSD("myVSD.root");
1144     cout<<"PO"<<endl;
1145 */
1146     //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1147 }
1148
1149 void AliEveEventManager::PrevEvent()
1150 {
1151     // Loads previous event.
1152
1153     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1154
1155     if (fAutoLoadTimerRunning)
1156     {
1157         throw (kEH + "Event auto-load timer is running.");
1158     }
1159     if (fExternalCtrl)
1160     {
1161         throw (kEH + "Event-loop is under external control.");
1162     }
1163
1164     if ((fESDTree!=0) || (fHLTESDTree!=0))
1165     {
1166         Int_t nextevent=0;
1167         if (fPEventSelector->FindPrev(nextevent))
1168         {
1169             GotoEvent(nextevent);
1170         }
1171     }
1172     else if (fEventId > 0)
1173     {
1174         GotoEvent(fEventId - 1);
1175     }
1176 }
1177
1178 void AliEveEventManager::MarkCurrentEvent()
1179 {
1180 #ifdef ZMQ
1181         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1182         struct eventStruct mark;
1183         mark.runNumber = fESD->GetRunNumber();
1184         mark.eventNumber = fESD->GetEventNumberInFile();
1185         requestMessage->messageType = REQUEST_MARK_EVENT;
1186         requestMessage->event = mark;
1187
1188         AliStorageEventManager *eventManager =
1189                 AliStorageEventManager::GetEventManagerInstance();
1190         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1191
1192         /*
1193         std::future<bool> unused = std::async([]()
1194         {
1195                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1196                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1197
1198                 if(response)
1199                 {
1200                 //fStatusLabel->SetText("Event marked");
1201                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1202                 }
1203                 else
1204                 {
1205                 //fStatusLabel->SetText("Couldn't mark this event");
1206                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1207                 }
1208         });
1209         */
1210         
1211         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1212         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1213         
1214         
1215         if(response)
1216         {
1217                 //fStatusLabel->SetText("Event marked");
1218                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1219         }
1220         else
1221         {
1222                 //fStatusLabel->SetText("Couldn't mark this event");
1223                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1224         }
1225         if(requestMessage){delete requestMessage;}
1226 #endif
1227 }
1228
1229 void AliEveEventManager::Close()
1230 {
1231     // Close the event data-files and delete ESD, ESDfriend, run-loader
1232     // and raw-reader.
1233
1234     static const TEveException kEH("AliEveEventManager::Close ");
1235
1236     if (!fIsOpen)
1237     {
1238         throw (kEH + "Event-files not opened.");
1239     }
1240
1241     if (fAutoLoadTimerRunning)
1242         StopAutoLoadTimer();
1243
1244     if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1245         delete fESD;       fESD       = 0;
1246         // delete fESDfriend; // friend tree is deleted with the tree
1247         fESDfriend = 0;
1248         fESDfriendExists = kFALSE;
1249
1250         if(fESDTree) { delete fESDTree;   fESDTree = 0; }
1251         if(fHLTESDTree) { delete fHLTESDTree;   fHLTESDTree = 0; }
1252         delete fESDFile;   fESDFile = 0;
1253     }
1254
1255     if (fAODTree) {
1256         delete fAOD;       fAOD       = 0;
1257
1258         delete fAODTree;   fAODTree = 0;
1259         delete fAODFile;   fAODFile = 0;
1260     }
1261
1262     if (fRunLoader) {
1263         delete fRunLoader; fRunLoader = 0;
1264     }
1265
1266     if (fRawReader) {
1267         delete fRawReader; fRawReader = 0;
1268     }
1269
1270     fEventId  = -1;
1271     fIsOpen   = kFALSE;
1272     fHasEvent = kFALSE;
1273 }
1274
1275
1276 //------------------------------------------------------------------------------
1277 // Static convenience functions, mainly used from macros.
1278 //------------------------------------------------------------------------------
1279
1280 Int_t AliEveEventManager::CurrentEventId()
1281 {
1282     // Return current event-id.
1283
1284     static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1285
1286     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1287         throw (kEH + "ALICE event not ready.");
1288     return fgCurrent->GetEventId();
1289 }
1290
1291 Bool_t AliEveEventManager::HasRunLoader()
1292 {
1293     // Check if AliRunLoader is initialized.
1294
1295     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1296 }
1297
1298 Bool_t AliEveEventManager::HasESD()
1299 {
1300     // Check if AliESDEvent is initialized.
1301
1302     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1303 }
1304
1305 Bool_t AliEveEventManager::HasESDfriend()
1306 {
1307     // Check if AliESDfriend is initialized.
1308
1309     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1310 }
1311
1312 Bool_t AliEveEventManager::HasAOD()
1313 {
1314     // Check if AliESDEvent is initialized.
1315
1316     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1317 }
1318
1319 Bool_t AliEveEventManager::HasRawReader()
1320 {
1321     // Check if raw-reader is initialized.
1322
1323     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1324 }
1325
1326 AliRunLoader* AliEveEventManager::AssertRunLoader()
1327 {
1328     // Make sure AliRunLoader is initialized and return it.
1329     // Throws exception in case run-loader is not available.
1330     // Static utility for macros.
1331
1332     static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
1333
1334     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1335         throw (kEH + "ALICE event not ready.");
1336     if (fgCurrent->fRunLoader == 0)
1337         throw (kEH + "AliRunLoader not initialised.");
1338     return fgCurrent->fRunLoader;
1339 }
1340
1341 AliESDEvent* AliEveEventManager::AssertESD()
1342 {
1343     // Make sure AliESDEvent is initialized and return it.
1344     // Throws exception in case ESD is not available.
1345     // Static utility for macros.
1346
1347     static const TEveException kEH("AliEveEventManager::AssertESD ");
1348
1349     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1350         throw (kEH + "ALICE event not ready.");
1351     if (fgCurrent->fESD == 0)
1352         throw (kEH + "AliESD not initialised.");
1353     return fgCurrent->fESD;
1354 }
1355
1356 AliESDfriend* AliEveEventManager::AssertESDfriend()
1357 {
1358     // Make sure AliESDfriend is initialized and return it.
1359     // Throws exception in case ESDfriend-loader is not available.
1360     // Static utility for macros.
1361
1362     static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1363
1364     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1365         throw (kEH + "ALICE event not ready.");
1366     if (fgCurrent->fESDfriend == 0)
1367         throw (kEH + "AliESDfriend not initialised.");
1368     return fgCurrent->fESDfriend;
1369 }
1370
1371 AliAODEvent* AliEveEventManager::AssertAOD()
1372 {
1373     // Make sure AliAODEvent is initialized and return it.
1374     // Throws exception in case AOD is not available.
1375     // Static utility for macros.
1376
1377     static const TEveException kEH("AliEveEventManager::AssertAOD ");
1378
1379     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1380         throw (kEH + "ALICE event not ready.");
1381     if (fgCurrent->fAOD == 0)
1382         throw (kEH + "AliAOD not initialised.");
1383     return fgCurrent->fAOD;
1384 }
1385
1386 AliRawReader* AliEveEventManager::AssertRawReader()
1387 {
1388     // Make sure raw-reader is initialized and return it.
1389
1390     static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1391
1392     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1393         throw (kEH + "ALICE event not ready.");
1394     if (fgCurrent->fRawReader == 0)
1395         throw (kEH + "RawReader not ready.");
1396
1397     return fgCurrent->fRawReader;
1398 }
1399
1400 //==============================================================================
1401
1402 AliMagF* AliEveEventManager::AssertMagField()    
1403 {        
1404     // Make sure AliMagF is initialized and returns it.
1405     // Throws exception in case magnetic field is not available.
1406     // Static utility for macros.
1407
1408     static const TEveException kEH("AliEveEventManager::AssertMagField ");
1409
1410     if (fgMagField)
1411         return fgMagField;
1412
1413     if (TGeoGlobalMagField::Instance()->GetField())
1414     {
1415         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1416         if (fgMagField == 0)
1417             throw kEH + "Global field set, but it is not AliMagF.";
1418         return fgMagField;
1419     }
1420
1421     if (!fgGRPLoaded)
1422     {
1423         InitGRP();
1424     }
1425
1426     if (TGeoGlobalMagField::Instance()->GetField())
1427     {
1428         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1429         if (fgMagField == 0)
1430             throw kEH + "Global field set, but it is not AliMagF.";
1431     }
1432     else
1433     {
1434         throw kEH + "Could not initialize magnetic field.";
1435     }
1436
1437     return fgMagField;
1438 }
1439
1440 TGeoManager* AliEveEventManager::AssertGeometry()
1441 {
1442     // Make sure AliGeomManager is initialized and returns the
1443     // corresponding TGeoManger.
1444     // gGeoManager is set to the return value.
1445     // Throws exception if geometry can not be loaded or if it is not
1446     // available and the TGeoManager is locked.
1447     // Static utility for macros.
1448
1449     static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1450
1451     if (AliGeomManager::GetGeometry() == 0)
1452     {
1453         if (TGeoManager::IsLocked())
1454             throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1455
1456         gGeoManager = 0;
1457         AliGeomManager::LoadGeometry();
1458         if ( ! AliGeomManager::GetGeometry())
1459         {
1460             throw (kEH + "can not load geometry.");
1461         }
1462         if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1463         {
1464             ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1465             // throw (kEH + "could not apply align objs.");
1466         }
1467         AliGeomManager::GetGeometry()->DefaultColors();
1468     }
1469
1470     gGeoManager = AliGeomManager::GetGeometry();
1471     return gGeoManager;
1472 }
1473
1474 AliRecoParam* AliEveEventManager::AssertRecoParams()
1475 {
1476     if(!fgRecoParam)
1477         InitRecoParam();
1478
1479     return fgRecoParam;
1480 }
1481
1482 Bool_t AliEveEventManager::InitRecoParam()
1483 {
1484     // This is mostly a reap-off from reconstruction
1485     // The method accesses OCDB and retrieves all
1486     // the available reco-param objects from there.
1487
1488     fgRecoParam = new AliRecoParam;
1489     const Int_t  kNDetectors = 14;
1490
1491     static const TEveException kEH("AliEveEventManager::InitRecoParam");
1492
1493     Bool_t isOK = kTRUE;
1494
1495     if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1496         ::Info(kEH, "Using custom GRP reconstruction parameters");
1497     }
1498     else {
1499         ::Info(kEH, "Loading GRP reconstruction parameter objects");
1500
1501         AliCDBPath path("GRP","Calib","RecoParam");
1502         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1503         if(!entry){
1504             ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
1505             isOK = kFALSE;
1506         }
1507         else {
1508             TObject *recoParamObj = entry->GetObject();
1509             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1510                 // GRP has a normal TobjArray of AliDetectorRecoParam objects
1511                 // Registering them in AliRecoParam
1512                 fgRecoParam->AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
1513             }
1514             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1515                 // GRP has only onse set of reco parameters
1516                 // Registering it in AliRecoParam
1517                 ::Info(kEH, "Single set of GRP reconstruction parameters found");
1518                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1519                 fgRecoParam->AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1520             }
1521             else {
1522                 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1523                 isOK = kFALSE;
1524             }
1525             entry->SetOwner(0);
1526         }
1527     }
1528
1529     const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1530
1531
1532     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1533
1534         if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1535             ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1536             continue;
1537         }
1538
1539         ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1540
1541         AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1542         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1543         if(!entry){
1544             ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
1545             isOK = kFALSE;
1546         }
1547         else {
1548             TObject *recoParamObj = entry->GetObject();
1549             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1550                 // The detector has a normal TobjArray of AliDetectorRecoParam objects
1551                 // Registering them in AliRecoParam
1552                 fgRecoParam->AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
1553             }
1554             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1555                 // The detector has only onse set of reco parameters
1556                 // Registering it in AliRecoParam
1557                 ::Info(kEH, "Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]);
1558                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1559                 fgRecoParam->AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1560             }
1561             else {
1562                 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1563                 isOK = kFALSE;
1564             }
1565             entry->SetOwner(0);
1566
1567         }
1568     }
1569
1570     if(!isOK) {
1571         delete fgRecoParam;
1572         fgRecoParam = 0;
1573     }
1574
1575     return isOK;
1576 }
1577
1578 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1579 {
1580     if(!fESDFile && !fESD) return 0;
1581
1582     static const TEveException kEH("AliEveEventManager::readESDTree ");
1583
1584     TTree* tempTree = 0;
1585
1586     tempTree =(TTree*) fESDFile->Get(treeName);
1587     if (tempTree != 0)
1588     {
1589         TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1590         if (esdFriendFile)
1591         {
1592             if (!esdFriendFile->IsZombie())
1593             {
1594                 esdFriendFile->Close();
1595                 fESDfriendExists = kTRUE;
1596                 tempTree->SetBranchStatus ("ESDfriend*", 1);
1597             }
1598             delete esdFriendFile;
1599         }
1600
1601         fESD->ReadFromTree(tempTree);
1602         if (fESDfriendExists)
1603         {
1604             fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1605             Info(kEH, "found and attached ESD friend.");
1606         }
1607         else
1608         {
1609             Warning(kEH, "ESDfriend not found.");
1610         }
1611
1612         if (tempTree->GetEntry(0) <= 0)
1613         {
1614             Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1615         }
1616         else
1617         {
1618             if (runNo < 0)
1619                 runNo = fESD->GetESDRun()->GetRunNumber();
1620         }
1621     }
1622     else // tree == 0
1623     {
1624         Warning(kEH, "failed getting the tree:%s", treeName);
1625     }
1626
1627     return tempTree;
1628 }
1629
1630
1631 //------------------------------------------------------------------------------
1632
1633 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1634 {
1635     // Create and attach a dependent event-manager.
1636     // It is not added into eve list tree.
1637
1638     static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1639
1640     if (fgMaster == 0)
1641         throw(kEH + "Master event-manager must be instantiated first.");
1642
1643     if (fgMaster->fSubManagers == 0)
1644     {
1645         fgMaster->fSubManagers = new TList;
1646         fgMaster->fSubManagers->SetOwner(kTRUE);
1647     }
1648
1649     AliEveEventManager* new_mgr = 0;
1650     fgCurrent = 0;
1651     try
1652     {
1653         new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1654         new_mgr->SetFilesPath(path);
1655         fgMaster->fSubManagers->Add(new_mgr);
1656     }
1657     catch (TEveException& exc)
1658     {
1659         ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1660     }
1661     fgCurrent = fgMaster;
1662
1663     return new_mgr;
1664 }
1665
1666 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1667 {
1668     // Get a dependant manager by name.
1669     // This will not change the current manager, use helper class
1670     // AliEveEventManager::CurrentChanger for that.
1671
1672     static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1673
1674     if (fgMaster == 0)
1675         throw(kEH + "Master event-manager must be instantiated first.");
1676
1677     if (fgMaster->fSubManagers == 0)
1678         return 0;
1679
1680     return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1681 }
1682
1683 AliEveEventManager* AliEveEventManager::GetMaster()
1684 {
1685     // Get master event-manager.
1686
1687     return fgMaster;
1688 }
1689
1690 AliEveEventManager* AliEveEventManager::GetCurrent()
1691 {
1692     // Get current event-manager.
1693
1694     return fgCurrent;
1695 }
1696
1697 void AliEveEventManager::RegisterTransient(TEveElement* element)
1698 {
1699     GetCurrent()->fTransients->AddElement(element);
1700 }
1701
1702 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1703 {
1704     GetCurrent()->fTransientLists->AddElement(element);
1705 }
1706
1707 //------------------------------------------------------------------------------
1708 // Autoloading of events
1709 //------------------------------------------------------------------------------
1710
1711 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1712 {
1713     // Set the auto-load time in seconds
1714
1715     fAutoLoadTime = time;
1716 }
1717
1718 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1719 {
1720     // Set the automatic event loading mode
1721
1722     static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1723
1724     if (fAutoLoad == autoLoad)
1725     {
1726         Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1727         return;
1728     }
1729
1730     fAutoLoad = autoLoad;
1731     if (fAutoLoad)
1732     {
1733         StartAutoLoadTimer();
1734     }
1735     else
1736     {
1737         StopAutoLoadTimer();
1738     }
1739 }
1740
1741 void AliEveEventManager::SetTrigSel(Int_t trig)
1742 {
1743     static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1744
1745     if (!fRawReader)
1746     {
1747         Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1748         return;
1749     }
1750     else
1751     {
1752         ULong64_t trigMask = 0;
1753         if (trig >= 0) trigMask = (1ull << trig);
1754         Info(kEH,"Trigger selection: 0x%llx",trigMask);
1755         fRawReader->SelectEvents(-1,trigMask,NULL);
1756     }
1757 }
1758
1759 void AliEveEventManager::StartAutoLoadTimer()
1760 {
1761     // Start the auto-load timer.
1762
1763     fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1764     fAutoLoadTimer->Reset();
1765     fAutoLoadTimer->TurnOn();
1766     fAutoLoadTimerRunning = kTRUE;
1767 }
1768
1769 void AliEveEventManager::StopAutoLoadTimer()
1770 {
1771     // Stop the auto-load timer.
1772
1773     fAutoLoadTimerRunning = kFALSE;
1774     fAutoLoadTimer->TurnOff();
1775 }
1776
1777 void AliEveEventManager::AutoLoadNextEvent()
1778 {
1779         // Called from auto-load timer, so it has to be public.
1780         // Do NOT call it directly.
1781
1782         static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1783           
1784         Info(kEH, "called!");
1785
1786         if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1787         {
1788                 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1789                 return;
1790         }
1791
1792         StopAutoLoadTimer();
1793         NextEvent();
1794         if (fAutoLoad)
1795                 StartAutoLoadTimer();
1796 }
1797
1798 //------------------------------------------------------------------------------
1799 // Post event-loading functions
1800 //------------------------------------------------------------------------------
1801
1802 void AliEveEventManager::AfterNewEventLoaded()
1803 {
1804   // Execute registered macros and commands.
1805   // At the end emit NewEventLoaded signal.
1806   //
1807   // Virtual from TEveEventManager.
1808
1809   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1810
1811   Info(kEH, "------------------!!!------------");
1812                       
1813   NewEventDataLoaded();
1814   if (fExecutor) fExecutor->ExecMacros();
1815
1816   TEveEventManager::AfterNewEventLoaded();
1817   NewEventLoaded();
1818
1819   if (this == fgMaster && fSubManagers != 0)
1820   {
1821     TIter next(fSubManagers);
1822     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1823     {
1824       gEve->SetCurrentEvent(fgCurrent);
1825       try
1826       {
1827         fgCurrent->GotoEvent(fEventId);
1828       }
1829       catch (TEveException& exc)
1830       {
1831         // !!! Should somehow tag / disable / remove it?
1832         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1833               fEventId, fgCurrent->GetName(), exc.Data());
1834       }
1835       Info(kEH, "------------------!!! while() gEve->SetCurrentEvent() ------------");
1836     }
1837     fgCurrent = fgMaster;
1838     Info(kEH, "------------------!!! while() gEve->SetCurrentEvent(MASTER) ------------");
1839     gEve->SetCurrentEvent(fgMaster);
1840   }
1841 }
1842
1843 void AliEveEventManager::NewEventDataLoaded()
1844 {
1845     // Emit NewEventDataLoaded signal.
1846     Emit("NewEventDataLoaded()");
1847 }
1848 void AliEveEventManager::NewEventLoaded()
1849 {
1850     // Emit NewEventLoaded signal.
1851     Emit("NewEventLoaded()");
1852 }
1853 void AliEveEventManager::StorageManagerOk()
1854 {
1855     // Emit StorageManagerOk signal.
1856     Emit("StorageManagerOk()");
1857 }
1858 void AliEveEventManager::StorageManagerDown()
1859 {
1860     // Emit StorageManagerOk signal.
1861     Emit("StorageManagerDown()");
1862 }
1863
1864
1865 //------------------------------------------------------------------------------
1866 // Event info dumpers
1867 //------------------------------------------------------------------------------
1868
1869 const AliEventInfo* AliEveEventManager::GetEventInfo() 
1870 {
1871     // Fill the event info object
1872
1873     AliCentralTrigger *aCTP = NULL;
1874     if (fRawReader) {
1875         fEventInfo.SetEventType(fRawReader->GetType());
1876
1877         ULong64_t mask = fRawReader->GetClassMask();
1878         fEventInfo.SetTriggerMask(mask);
1879         UInt_t clmask = fRawReader->GetDetectorPattern()[0];
1880         fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
1881
1882         aCTP = new AliCentralTrigger();
1883         TString configstr("");
1884         if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1885             AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
1886             delete aCTP;
1887             return 0;
1888         }
1889         aCTP->SetClassMask(mask);
1890         aCTP->SetClusterMask(clmask);
1891
1892         if (fRunLoader) {
1893             AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
1894             if (rlCTP) {
1895                 rlCTP->SetClassMask(mask);
1896                 rlCTP->SetClusterMask(clmask);
1897             }
1898         }
1899     }
1900     else {
1901         fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
1902
1903         if (fRunLoader && (!fRunLoader->LoadTrigger())) {
1904             aCTP = fRunLoader->GetTrigger();
1905             fEventInfo.SetTriggerMask(aCTP->GetClassMask());
1906             // get inputs from actp - just get
1907             AliESDHeader* esdheader = fESD->GetHeader();
1908             esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
1909             esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
1910             esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
1911             fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
1912         }
1913         else {
1914             AliWarning("No trigger can be loaded! The trigger information will not be used!");
1915             return 0;
1916         }
1917     }
1918
1919     AliTriggerConfiguration *config = aCTP->GetConfiguration();
1920     if (!config) {
1921         AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
1922         if (fRawReader) delete aCTP;
1923         return 0;
1924     }
1925
1926     TString declTriggerClasses;
1927
1928     // Load trigger aliases and declare the trigger classes included in aliases
1929     AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
1930     if (entry) {
1931         THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
1932         if (lst) {
1933             lst->Sort(kSortDescending); // to avoid problems with substrings
1934             if (fRawReader) fRawReader->LoadTriggerAlias(lst);
1935             // Now declare all the triggers present in the aliases
1936             TIter iter(lst);
1937             TNamed *nmd = 0;
1938             while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
1939                 declTriggerClasses += " ";
1940                 declTriggerClasses += nmd->GetName();
1941             }
1942         }
1943         else {
1944             AliError("Cannot cast the object with trigger aliases to THashList!");
1945         }
1946     }
1947     else {
1948         AliError("No OCDB entry for the trigger aliases!");
1949     }
1950
1951     // Load trigger classes for this run
1952     UChar_t clustmask = 0;
1953     TString trclasses;
1954     ULong64_t trmask = fEventInfo.GetTriggerMask();
1955     const TObjArray& classesArray = config->GetClasses();
1956     Int_t nclasses = classesArray.GetEntriesFast();
1957     for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
1958         AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
1959         if (trclass && trclass->GetMask()>0) {
1960             Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
1961             if (fESD) fESD->SetTriggerClass(trclass->GetName(),trindex);
1962             if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
1963             if (trmask & (1ull << trindex)) {
1964                 trclasses += " ";
1965                 trclasses += trclass->GetName();
1966                 trclasses += " ";
1967                 clustmask |= trclass->GetCluster()->GetClusterMask();
1968             }
1969         }
1970     }
1971     fEventInfo.SetTriggerClasses(trclasses);
1972
1973     if (!aCTP->CheckTriggeredDetectors()) {
1974         if (fRawReader) delete aCTP;
1975         return 0;
1976     }
1977
1978     if (fRawReader) delete aCTP;
1979
1980     // everything went ok, return pointer
1981     return (&fEventInfo);
1982 }
1983
1984
1985 TString AliEveEventManager::GetEventInfoHorizontal() const
1986 {
1987     // Dumps the event-header contents in vertical formatting.
1988
1989     TString rawInfo, esdInfo;
1990
1991     if (!fRawReader)
1992     {
1993         rawInfo = "No raw-data event info is available!\n";
1994     }
1995     else
1996     {
1997         const UInt_t* attr = fRawReader->GetAttributes();
1998         TTimeStamp ts(fRawReader->GetTimestamp());
1999         rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2000                      "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
2001                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2002                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2003                      fRawReader->GetClassMask(),
2004                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2005                      attr[0],attr[1],attr[2], ts.AsString("s"));
2006     }
2007
2008     if (!fESD)
2009     {
2010         esdInfo = "No ESD event info is available!";
2011     }
2012     else
2013     {
2014         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2015         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2016         TTimeStamp ts(fESD->GetTimeStamp());
2017         esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2018                      "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
2019                      fESD->GetRunNumber(),
2020                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2021                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2022                      acttrclasses.Data(),
2023                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2024                      fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
2025     }
2026
2027     return rawInfo + esdInfo;
2028 }
2029
2030 TString AliEveEventManager::GetEventInfoVertical() const
2031 {
2032     // Dumps the event-header contents in vertical formatting.
2033
2034     TString rawInfo, esdInfo;
2035
2036     if (!fRawReader)
2037     {
2038         rawInfo = "No raw-data event info is available!\n";
2039     }
2040     else
2041     {
2042         const UInt_t* attr = fRawReader->GetAttributes();
2043         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",
2044                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2045                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2046                      fRawReader->GetClassMask(),
2047                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2048                      attr[0],attr[1],attr[2],
2049                      fRawReader->GetTimestamp());
2050     }
2051
2052     if (!fESD)
2053     {
2054         esdInfo = "No ESD event info is available!\n";
2055     }
2056     else
2057     {
2058         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2059         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2060         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",
2061                      fESD->GetRunNumber(),
2062                      acttrclasses.Data(),
2063                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2064                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2065                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2066                      fESD->GetEventNumberInFile(),
2067                      fESD->GetTimeStamp());
2068     }
2069
2070     return rawInfo + "\n" + esdInfo;
2071 }
2072
2073
2074 //==============================================================================
2075 // Reading of GRP and MagneticField.
2076 // This is a reap-off from reconstruction ... should really be a common
2077 // code to do this somewhere in STEER.
2078 //==============================================================================
2079
2080 Bool_t AliEveEventManager::InitGRP()
2081 {
2082     //------------------------------------
2083     // Initialization of the GRP entry
2084     //------------------------------------
2085
2086     static const TEveException kEH("AliEveEventManager::InitGRP ");
2087
2088     AliGRPManager grpMgr;
2089     if (!grpMgr.ReadGRPEntry()) {
2090         return kFALSE;
2091     }
2092     fgGRPLoaded = kTRUE;
2093     if (!grpMgr.SetMagField()) {
2094         throw kEH + "Setting of field failed!";
2095     }
2096
2097     //*** Get the diamond profiles from OCDB
2098     // Eventually useful.
2099
2100     /*
2101     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
2102     if (entry) {
2103     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
2104     } else {
2105     ::Error(kEH, "No SPD diamond profile found in OCDB!");
2106     }
2107
2108     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
2109     if (entry) {
2110     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
2111     } else {
2112     ::Error(kEH, "No diamond profile found in OCDB!");
2113     }
2114
2115     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
2116     if (entry) {
2117     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
2118     } else {
2119     ::Error(kEH, "No TPC diamond profile found in OCDB!");
2120     }
2121   */
2122
2123     return kTRUE;
2124
2125
2126 //------------------------------------
2127 // Global variables management
2128 //------------------------------------
2129
2130 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model)
2131 {
2132     // Insert a new visualization-parameter database entry with the default
2133     return InsertGlobal(tag, model, fGlobalReplace, fGlobalUpdate);
2134 }
2135
2136 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model,
2137                                         Bool_t replace, Bool_t update)
2138 {
2139     TPair* pair = (TPair*) fGlobal->FindObject(tag);
2140     if (pair)
2141     {
2142         if (replace)
2143         {
2144             model->IncDenyDestroy();
2145             model->SetRnrChildren(kFALSE);
2146
2147             TEveElement* old_model = dynamic_cast<TEveElement*>(pair->Value());
2148             if(!old_model) AliFatal("old_model == 0, dynamic cast failed\n");
2149             while (old_model->HasChildren())
2150             {
2151                 TEveElement *el = old_model->FirstChild();
2152                 el->SetVizModel(model);
2153                 if (update)
2154                 {
2155                     el->CopyVizParams(model);
2156                     el->PropagateVizParamsToProjecteds();
2157                 }
2158             }
2159             old_model->DecDenyDestroy();
2160
2161             pair->SetValue(dynamic_cast<TObject*>(model));
2162             return kTRUE;
2163         }
2164         else
2165         {
2166             return kFALSE;
2167         }
2168     }
2169     else
2170     {
2171         model->IncDenyDestroy();
2172         model->SetRnrChildren(kFALSE);
2173         fGlobal->Add(new TObjString(tag), dynamic_cast<TObject*>(model));
2174         return kTRUE;
2175     }
2176 }
2177
2178 TEveElement* AliEveEventManager::FindGlobal(const TString& tag)
2179 {
2180     return dynamic_cast<TEveElement*>(fGlobal->GetValue(tag));
2181 }