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