Remove default OCDB location and exit with fatal error if OCDB URI is
[u/mrichter/AliRoot.git] / EVE / EveBase / AliEveEventManager.cxx
1 // $Id$
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 <TEveManager.h>
14 #include <TEveViewer.h>
15
16 #include <AliRunLoader.h>
17 #include <AliRun.h>
18 #include <AliESDRun.h>
19 #include <AliESDEvent.h>
20 #include <AliESDfriend.h>
21 #include <AliAODEvent.h>
22
23 #include <AliDAQ.h>
24 #include <AliRawEventHeaderBase.h>
25 #include <AliRawReaderRoot.h>
26 #include <AliRawReaderFile.h>
27 #include <AliRawReaderDate.h>
28 #include <AliMagF.h>
29 #include <AliCDBManager.h>
30 #include <AliCDBStorage.h>
31 #include <AliGRPObject.h>
32 #include <AliHeader.h>
33 #include <AliGeomManager.h>
34 #include <AliGRPManager.h>
35 #include <AliSysInfo.h>
36
37 #include <TFile.h>
38 #include <TTree.h>
39 #include <TGeoManager.h>
40 #include <TGeoGlobalMagField.h>
41 #include <TSystem.h>
42 #include <TTimeStamp.h>
43 #include <TPRegexp.h>
44 #include <TError.h>
45
46 //==============================================================================
47 //==============================================================================
48 // AliEveEventManager
49 //==============================================================================
50
51 //______________________________________________________________________________
52 //
53 // Provides interface for loading and navigating standard AliRoot data
54 // (AliRunLoader), ESD, AOD and RAW.
55 //
56 // ESDfriend is attached automatically, if the file is found.
57 //
58 // AODfriends are not attached automatically as there are several
59 // possible files involved. To have a specific AODfriend attached, call
60 // static method
61 //   AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
62 // before initializing the event-manager.
63 //
64 // Also provides interface to magnetic-field and geometry. Mostly
65 // intended as wrappers over standard AliRoot functionality for
66 // convenient use from visualizateion macros.
67 //
68 // There can be a single main event-manger, it is stored in private
69 // data member fgMaster and can be accessed via static member function
70 // GetMaster().
71 //
72 // For event overlaying and embedding one can instantiate additional
73 // event-managers via static method AddDependentManager(const TString& path).
74 // This interface is under development.
75
76 ClassImp(AliEveEventManager)
77
78 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
79 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
80 Bool_t AliEveEventManager::fgAssertAOD       = kFALSE;
81 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
82
83 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
84 TString  AliEveEventManager::fgAODFileName("AliAOD.root");
85 TString  AliEveEventManager::fgRawFileName("raw.root");
86 TString  AliEveEventManager::fgCdbUri;
87
88 TList*   AliEveEventManager::fgAODfriends = 0;
89
90 Bool_t        AliEveEventManager::fgGRPLoaded    = kFALSE;
91 AliMagF*      AliEveEventManager::fgMagField     = 0;
92 Bool_t        AliEveEventManager::fgUniformField = kFALSE;
93
94 AliEveEventManager* AliEveEventManager::fgMaster  = 0;
95 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
96
97 void AliEveEventManager::InitInternals()
98 {
99   // Initialize internal members.
100
101   static const TEveException kEH("AliEveEventManager::InitInternals ");
102
103   if (fgCurrent != 0)
104   {
105     throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
106   }
107
108   if (fgMaster == 0)
109   {
110     fgMaster = this;
111   }
112
113   fgCurrent = this;
114
115   fAutoLoadTimer = new TTimer;
116   fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
117
118   fExecutor = new AliEveMacroExecutor;
119
120   fTransients = new TEveElementList("Transients", "Transient per-event elements.");
121   fTransients->IncDenyDestroy();
122   gEve->AddToListTree(fTransients, kFALSE);
123
124   fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
125   fTransientLists->IncDenyDestroy();
126   gEve->AddToListTree(fTransientLists, kFALSE);
127
128   fPEventSelector = new AliEveEventSelector(this);
129 }
130
131 AliEveEventManager::AliEveEventManager(const TString& name) :
132   TEveEventManager(name),
133
134   fPath      ( ), fEventId (-1),
135   fRunLoader (0),
136   fESDFile   (0), fESDTree (0), fESD (0),
137   fESDfriend (0), fESDfriendExists(kFALSE),
138   fAODFile   (0), fAODTree (0), fAOD (0),
139   fRawReader (0),
140   fAutoLoad  (kFALSE), fAutoLoadTime (5.),     fAutoLoadTimer(0),
141   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
142   fExecutor    (0), fTransients(0), fTransientLists(0),
143   fPEventSelector(0),
144   fSubManagers (0),
145   fAutoLoadTimerRunning(kFALSE)
146 {
147   // Default constructor.
148
149   InitInternals();
150 }
151
152 AliEveEventManager::AliEveEventManager(const TString& name, const TString& path, Int_t ev) :
153   TEveEventManager(name, path),
154
155   fPath   (path), fEventId(-1),
156   fRunLoader (0),
157   fESDFile   (0), fESDTree (0), fESD (0),
158   fESDfriend (0), fESDfriendExists(kFALSE),
159   fAODFile   (0), fAODTree (0), fAOD (0),
160   fRawReader (0),
161   fAutoLoad  (kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
162   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
163   fExecutor    (0), fTransients(0), fTransientLists(0),
164   fPEventSelector(0),
165   fSubManagers (0),
166   fAutoLoadTimerRunning(kFALSE)
167 {
168   // Constructor with event-directory URL and event-id.
169
170   InitInternals();
171
172   Open();
173   if (ev >= 0)
174   {
175     GotoEvent(ev);
176   }
177 }
178
179 AliEveEventManager::~AliEveEventManager()
180 {
181   // Destructor.
182
183   delete fSubManagers;
184
185   if (fIsOpen)
186   {
187     Close();
188   }
189
190   fTransients->DecDenyDestroy();
191   fTransients->Destroy();
192
193   fTransientLists->DecDenyDestroy();
194   fTransientLists->Destroy();
195 }
196
197 /******************************************************************************/
198
199 void AliEveEventManager::SetESDFileName(const TString& esd)
200 {
201   // Set file-name for opening ESD, default "AliESDs.root".
202
203   if ( ! esd.IsNull()) fgESDFileName = esd;
204 }
205
206 void AliEveEventManager::SetAODFileName(const TString& aod)
207 {
208   // Set file-name for opening AOD, default "AliAOD.root".
209
210   if ( ! aod.IsNull()) fgAODFileName = aod;
211 }
212
213 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
214 {
215   // Add new AOD friend file-name to be attached when opening AOD.
216   // This should include '.root', as in 'AliAOD.VertexingHF.root'.
217
218   if (fgAODfriends == 0)
219   {
220     fgAODfriends = new TList;
221     fgAODfriends->SetOwner(kTRUE);
222   }
223   if (fgAODfriends->FindObject(friendFileName) == 0)
224   {
225     fgAODfriends->Add(new TObjString(friendFileName));
226   }
227 }
228
229 void AliEveEventManager::SetRawFileName(const TString& raw)
230 {
231   // Set file-name for opening of raw-data, default "raw.root"
232   if ( ! raw.IsNull()) fgRawFileName = raw;
233 }
234
235 void AliEveEventManager::SetCdbUri(const TString& cdb)
236 {
237   // Set path to CDB, there is no default.
238
239   if ( ! cdb.IsNull()) fgCdbUri = cdb;
240 }
241
242 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
243                                            Bool_t assertAod, Bool_t assertRaw)
244 {
245   // Set global flags that detrmine which parts of the event-data must
246   // be present when the event is opened.
247
248   fgAssertRunLoader = assertRunloader;
249   fgAssertESD = assertEsd;
250   fgAssertAOD = assertAod;
251   fgAssertRaw = assertRaw;
252 }
253
254 /******************************************************************************/
255
256 void AliEveEventManager::Open()
257 {
258   // Open event-data from URL specified in fPath.
259   // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
260   // Warning is reported if run-loader or ESD is not found.
261   // Global data-members fgAssertRunLoader and fgAssertESD can be set
262   // to throw exceptions instead.
263
264   static const TEveException kEH("AliEveEventManager::Open ");
265
266   if (fExternalCtrl)
267   {
268     throw (kEH + "Event-loop is under external control.");
269   }
270   if (fIsOpen)
271   {
272     throw (kEH + "Event-files already opened.");
273   }
274
275   gSystem->ExpandPathName(fPath);
276   // The following magick is required for ESDfriends to be loaded properly
277   // from non-current directory.
278   if (fPath.IsNull() || fPath == ".")
279   {
280     fPath = gSystem->WorkingDirectory();
281   }
282   else if ( ! fPath.BeginsWith("file:/"))
283   {
284     TUrl    url(fPath, kTRUE);
285     TString protocol(url.GetProtocol());
286     if (protocol == "file" && fPath[0] != '/')
287       fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
288   }
289
290   Int_t runNo = -1;
291
292   // Open ESD and ESDfriends
293
294   TString esdPath(Form("%s/%s", fPath.Data(), fgESDFileName.Data()));
295   if ((fESDFile = TFile::Open(esdPath)))
296   {
297     fESD = new AliESDEvent();
298     fESDTree = (TTree*) fESDFile->Get("esdTree");
299     if (fESDTree != 0)
300     {
301       // Check if ESDfriends exists and attach the branch.
302       // We use TFile::Open() instead of gSystem->AccessPathName
303       // as it seems to work better when attachine alieve to a
304       // running reconstruction process with auto-save on.
305       // There was also a problem with TTree::Refresh() - it didn't
306       // save the friend branch on a separate file, fixed in 5.22.2 -
307       // so we might want to try the old way again soon.
308       TString p(Form("%s/AliESDfriends.root", fPath.Data()));
309       TFile *esdFriendFile = TFile::Open(p);
310       if (esdFriendFile)
311       {
312         if (!esdFriendFile->IsZombie())
313         {
314           esdFriendFile->Close();
315           fESDfriendExists = kTRUE;
316           fESDTree->SetBranchStatus ("ESDfriend*", 1);
317         }
318         delete esdFriendFile;
319       }
320
321       fESD->ReadFromTree(fESDTree);
322       if (fESDfriendExists)
323       {
324         fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
325         Info(kEH, "found and attached ESD friend.");
326       }
327       else
328       {
329         Warning(kEH, "ESDfriend not found.");
330       }
331
332       if (fESDTree->GetEntry(0) <= 0)
333       {
334         delete fESDFile; fESDFile = 0;
335         delete fESD; fESD = 0;
336         Warning(kEH, "failed getting the first entry from esdTree.");
337       }
338       else
339       {
340         if (runNo < 0)
341           runNo = fESD->GetESDRun()->GetRunNumber();
342       }
343     }
344     else // esdtree == 0
345     {
346       delete fESDFile; fESDFile = 0;
347       delete fESD; fESD = 0;
348       Warning(kEH, "failed getting the esdTree.");
349     }
350   }
351   else // esd not readable
352   {
353     Warning(kEH, "can not read ESD file '%s'.", esdPath.Data());
354   }
355   if (fESDTree == 0)
356   {
357     if (fgAssertESD)
358     {
359       throw (kEH + "ESD not initialized. Its precence was requested.");
360     } else {
361       Warning(kEH, "ESD not initialized.");
362     }
363   }
364
365   // Open AOD and registered friends
366
367   TString aodPath(Form("%s/%s", fPath.Data(), fgAODFileName.Data()));
368   if ((fAODFile = TFile::Open(aodPath)))
369   {
370     fAOD = new AliAODEvent();
371     fAODTree = (TTree*) fAODFile->Get("aodTree");
372     if (fAODTree != 0)
373     {
374       // Check if AODfriends exist and attach them.
375       TIter       friends(fgAODfriends);
376       TObjString *name;
377       while ((name = (TObjString*) friends()) != 0)
378       {
379         TString p(Form("%s/%s", fPath.Data(), name->GetName()));
380         if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
381         {
382           fAODTree->AddFriend("aodTree", name->GetName());
383         }
384       }
385
386       fAOD->ReadFromTree(fAODTree);
387
388       if (fAODTree->GetEntry(0) <= 0)
389       {
390         delete fAODFile; fAODFile = 0;
391         delete fAOD;     fAOD     = 0;
392         Warning(kEH, "failed getting the first entry from addTree.");
393       }
394       else
395       {
396         if (runNo < 0)
397           runNo = fAOD->GetRunNumber();
398       }
399     }
400     else // aodtree == 0
401     {
402       delete fAODFile; fAODFile = 0;
403       delete fAOD;     fAOD     = 0;
404       Warning(kEH, "failed getting the aodTree.");
405     }
406   }
407   else // aod not readable
408   {
409     Warning(kEH, "can not read AOD file '%s'.", aodPath.Data());
410   }
411   if (fAODTree == 0)
412   {
413     if (fgAssertAOD)
414     {
415       throw (kEH + "AOD not initialized. Its precence was requested.");
416     } else {
417       Warning(kEH, "AOD not initialized.");
418     }
419   }
420
421   // Open RunLoader from galice.root
422
423   TString gaPath(Form("%s/galice.root", fPath.Data()));
424   // If i use open directly, we get fatal.
425   // Is AccessPathName check ok for xrootd / alien? Yes, not for http.
426   if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
427   {
428     fRunLoader = AliRunLoader::Open(gaPath, GetName());
429     if (fRunLoader)
430     {
431       TString alicePath = fPath + "/";
432       fRunLoader->SetDirName(alicePath);
433
434       if (fRunLoader->LoadgAlice() != 0)
435         Warning(kEH, "failed loading gAlice via run-loader.");
436
437       if (fRunLoader->LoadHeader() == 0)
438       {
439         if (runNo < 0)
440           runNo = fRunLoader->GetHeader()->GetRun();
441       }
442       else
443       {
444         Warning(kEH, "failed loading run-loader's header.");
445         delete fRunLoader;
446         fRunLoader = 0;
447       }
448     }
449     else // run-loader open failed
450     {
451       Warning(kEH, "failed opening ALICE run-loader from '%s'.", gaPath.Data());
452     }
453   }
454   else // galice not readable
455   {
456     Warning(kEH, "can not read '%s'.", gaPath.Data());
457   }
458   if (fRunLoader == 0)
459   {
460     if (fgAssertRunLoader)
461       throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
462     else
463       Warning(kEH, "Bootstraping of run-loader failed.");
464   }
465
466   // Open raw-data file
467
468   TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
469   // If i use open directly, raw-reader reports an error but i have
470   // no way to detect it.
471   // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
472   AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
473   if (fgAssertRaw == kFALSE)
474   {
475     AliLog::SetGlobalLogLevel(AliLog::kFatal);
476   }
477   if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
478   {
479     fRawReader = AliRawReader::Create(rawPath);
480   }
481   else
482   {
483     fRawReader = AliRawReader::Create(fgRawFileName);
484   }
485   if (fgAssertRaw == kFALSE)
486   {
487     AliLog::SetGlobalLogLevel(oldLogLevel);
488   }
489
490   if (fRawReader == 0)
491   {
492     if (fgAssertRaw)
493     {
494       throw (kEH + "raw-data not initialized. Its precence was requested.");
495     } else {
496       Warning(kEH, "raw-data not initialized.");
497     }
498   }
499
500   if (runNo < 0)
501   {
502     if (fRawReader)
503     {
504       fRawReader->NextEvent();
505       runNo = fRawReader->GetRunNumber();
506       Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
507       fRawReader->RewindEvents();
508     } else {
509       throw (kEH + "unknown run number.");
510     }
511   }
512
513   // Initialize OCDB ... only in master event-manager
514
515   if (this == fgMaster)
516   {
517     AliCDBManager* cdb = AliCDBManager::Instance();
518     if (cdb->IsDefaultStorageSet() == kTRUE)
519     {
520       Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
521               cdb->GetDefaultStorage()->GetURI().Data());
522     }
523     else
524     {
525       if (fgCdbUri.IsNull())
526       {
527         gEnv->SetValue("Root.Stacktrace", "no");
528         Fatal("Open()", "OCDB path was not specified.");
529       }
530
531       // Handle some special cases for MC (should be in OCDBManager).
532       if (fgCdbUri == "mcideal://")
533         cdb->SetDefaultStorage("MC", "Ideal");
534       else if (fgCdbUri == "mcresidual://")
535         cdb->SetDefaultStorage("MC", "Residual");
536       else if (fgCdbUri == "mcfull://")
537         cdb->SetDefaultStorage("MC", "Full");
538       else if (fgCdbUri == "local://") {
539         fgCdbUri = "local://$ALICE_ROOT/OCDB";
540         cdb->SetDefaultStorage(fgCdbUri);
541       } else
542         cdb->SetDefaultStorage(fgCdbUri);
543       if (cdb->IsDefaultStorageSet() == kFALSE)
544         throw kEH + "CDB initialization failed.";
545     }
546     
547     if (fgCdbUri.BeginsWith("local://"))
548     {
549       TString grp     = "GRP/GRP/Data";
550       TString grppath = fPath + "/" + grp;
551       if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
552       {
553         if (cdb->GetSpecificStorage(grp))
554         {
555           Warning(kEH, "Local GRP exists, but the specific storage is already set.");
556         }
557         else
558         {
559           Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
560           TString lpath("local://");
561           lpath += fPath;
562           cdb->SetSpecificStorage(grp, lpath);
563         }
564       }
565     }
566     cdb->SetRun(runNo);
567   }
568
569   fIsOpen = kTRUE;
570 }
571
572 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
573 {
574   // Set an event from an external source.
575   // The method is used in the online visualisation.
576   // AOD is not supported.
577
578   static const TEveException kEH("AliEveEventManager::SetEvent ");
579
580   if (fIsOpen)
581   {
582     Warning(kEH, "Event-files were open. Closing and switching to external control.");
583     Close();
584   }
585
586   fRunLoader = runLoader;
587   fRawReader = rawReader;
588   fESD       = esd;
589   fESDfriend = esdf;
590   fAOD       = 0;
591
592   fEventId++;
593   fHasEvent     = kTRUE;
594   fExternalCtrl = kTRUE;
595
596   SetTitle("Online event in memory");
597   SetName ("Online Event");
598   ElementChanged();
599
600   AfterNewEventLoaded();
601
602   if (fAutoLoad) StartAutoLoadTimer();
603 }
604
605 Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
606 {
607   // Returns maximum available event id.
608   // If under external control or event is not opened -1 is returned.
609   // If raw-data is the only data-source this can not be known
610   // and 10,000,000 is returned.
611   // If neither data-source is initialised an exception is thrown.
612   // If refresh_esd is true and ESD is the primary event-data source
613   // its header is re-read from disk.
614
615   static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
616
617   if (fExternalCtrl || fIsOpen == kFALSE)
618   {
619     return -1;
620   }
621
622   if (fESDTree)
623   {
624     // Refresh crashes with root-5.21.1-alice.
625     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
626     // when we move to a newer root.
627     // if (refreshESD)
628     //   fESDTree->Refresh();
629     return fESDTree->GetEntries() - 1;
630   }
631   else if (fAODTree)
632   {
633     return fAODTree->GetEntries() - 1;
634   }
635   else if (fRunLoader)
636   {
637     return fRunLoader->GetNumberOfEvents() - 1;
638   }
639   else if (fRawReader)
640   {
641     Int_t n = fRawReader->GetNumberOfEvents() - 1;
642     return n > -1 ? n : 10000000;
643   }
644   else
645   {
646     throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
647   }
648 }
649
650 void AliEveEventManager::GotoEvent(Int_t event)
651 {
652   // Load data for specified event.
653   // If event is out of range an exception is thrown and old state
654   // is preserved.
655   // After successful loading of event, the virtual function
656   // AfterNewEventLoaded() is called. This executes commands that
657   // were registered via TEveEventManager::AddNewEventCommand().
658   //
659   // If event is negative, it is subtracted from the number of
660   // available events, thus passing -1 will load the last event.
661   // This is not supported when raw-data is the only data-source
662   // as the number of events is not known.
663
664   static const TEveException kEH("AliEveEventManager::GotoEvent ");
665
666   if (fAutoLoadTimerRunning)
667   {
668     throw (kEH + "Event auto-load timer is running.");
669   }
670   if (fExternalCtrl)
671   {
672     throw (kEH + "Event-loop is under external control.");
673   }
674   else if (!fIsOpen)
675   {
676     throw (kEH + "Event-files not opened.");
677   }
678
679   fHasEvent = kFALSE;
680
681   Int_t maxEvent = 0;
682   if (fESDTree)
683   {
684     // Refresh crashes with root-5.21.1-alice.
685     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
686     // when we move to a newer root.
687     // fESDTree->Refresh();
688     maxEvent = fESDTree->GetEntries() - 1;
689     if (event < 0)
690       event = fESDTree->GetEntries() + event;
691   }
692   else if (fAODTree)
693   {
694     maxEvent = fAODTree->GetEntries() - 1;
695     if (event < 0)
696       event = fAODTree->GetEntries() + event;
697   }
698   else if (fRunLoader)
699   {
700     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
701     if (event < 0)
702       event = fRunLoader->GetNumberOfEvents() + event;
703   }
704   else if (fRawReader)
705   {
706     maxEvent = fRawReader->GetNumberOfEvents() - 1;
707     if (maxEvent < 0)
708     {
709       maxEvent = 10000000;
710       if (event < 0) {
711         Error(kEH, "current raw-data source does not support direct event access.");
712         return;
713       }
714       Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
715     }
716     else
717     {
718       if (event < 0)
719         event = fRawReader->GetNumberOfEvents() + event;
720     }
721   }
722   else
723   {
724     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
725   }
726   if (event < 0 || event > maxEvent)
727   {
728     throw (kEH + Form("event %d not present, available range [%d, %d].",
729                       event, 0, maxEvent));
730   }
731
732   TString sysInfoHeader;
733   sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
734   AliSysInfo::AddStamp(sysInfoHeader + "Start");
735
736   TEveManager::TRedrawDisabler rd(gEve);
737   gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
738
739   // !!! MT this is somewhat brutal; at least optionally, one could be
740   // a bit gentler, checking for objs owning their external refs and having
741   // additinal parents.
742   gEve->GetViewers()->DeleteAnnotations();
743   fTransients->DestroyElements();
744   for (TEveElement::List_i i = fTransientLists->BeginChildren();
745        i != fTransientLists->EndChildren(); ++i)
746   {
747     (*i)->DestroyElements();
748   }
749   DestroyElements();
750
751   AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
752
753   if (fESDTree) {
754     if (fESDTree->GetEntry(event) <= 0)
755       throw (kEH + "failed getting required event from ESD.");
756
757     if (fESDfriendExists)
758       fESD->SetESDfriend(fESDfriend);
759   }
760
761   if (fAODTree) {
762     if (fAODTree->GetEntry(event) <= 0)
763       throw (kEH + "failed getting required event from AOD.");
764   }
765
766   if (fRunLoader) {
767     if (fRunLoader->GetEvent(event) != 0)
768       throw (kEH + "failed getting required event.");
769   }
770
771   if (fRawReader)
772   {
773     // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
774     if (fRawReader->GotoEvent(event) == kFALSE)
775     {
776       // Use fallback method - iteration with NextEvent().
777       Int_t rawEv = fEventId;
778       if (event < rawEv)
779       {
780         fRawReader->RewindEvents();
781         rawEv = -1;
782       }
783
784       while (rawEv < event)
785       {
786         if ( ! fRawReader->NextEvent())
787         {
788           fRawReader->RewindEvents();
789           fEventId = -1;
790           throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
791         }
792         ++rawEv;
793       }
794       Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
795     }
796   }
797
798   fHasEvent = kTRUE;
799   fEventId  = event;
800   if (this == fgMaster)
801   {
802     SetName(Form("Event %d", fEventId));
803     ElementChanged();
804   }
805
806   AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
807
808   AfterNewEventLoaded();
809
810   AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
811 }
812
813 void AliEveEventManager::NextEvent()
814 {
815   // Loads next event.
816   // Does magick needed for online display when under external event control.
817
818   static const TEveException kEH("AliEveEventManager::NextEvent ");
819
820   if (fAutoLoadTimerRunning)
821   {
822     throw (kEH + "Event auto-load timer is running.");
823   }
824
825   if (fExternalCtrl)
826   {
827     // !!! This should really go somewhere else. It is done in GotoEvent(),
828     // so here we should do it in SetEvent().
829     DestroyElements();
830
831     gSystem->ExitLoop();
832   }
833   else
834   {
835     Int_t nextevent=0;
836     if (fPEventSelector->FindNext(nextevent))
837     {
838       GotoEvent(nextevent);
839     }
840   }
841 }
842
843 void AliEveEventManager::PrevEvent()
844 {
845   // Loads previous event.
846
847   static const TEveException kEH("AliEveEventManager::PrevEvent ");
848
849   if (fAutoLoadTimerRunning)
850   {
851     throw (kEH + "Event auto-load timer is running.");
852   }
853   if (fExternalCtrl)
854   {
855     throw (kEH + "Event-loop is under external control.");
856   }
857   Int_t nextevent=0;
858   if (fPEventSelector->FindPrev(nextevent))
859   {
860     GotoEvent(nextevent);
861   }
862 }
863
864 void AliEveEventManager::Close()
865 {
866   // Close the event data-files and delete ESD, ESDfriend, run-loader
867   // and raw-reader.
868
869   static const TEveException kEH("AliEveEventManager::Close ");
870
871   if (!fIsOpen)
872   {
873     throw (kEH + "Event-files not opened.");
874   }
875
876   if (fAutoLoadTimerRunning)
877     StopAutoLoadTimer();
878
879   if (fESDTree) {
880     delete fESD;       fESD       = 0;
881     delete fESDfriend; fESDfriend = 0;
882     fESDfriendExists = kFALSE;
883
884     delete fESDTree;   fESDTree = 0;
885     delete fESDFile;   fESDFile = 0;
886   }
887
888   if (fAODTree) {
889     delete fAOD;       fAOD       = 0;
890
891     delete fAODTree;   fAODTree = 0;
892     delete fAODFile;   fAODFile = 0;
893   }
894
895   if (fRunLoader) {
896     delete fRunLoader; fRunLoader = 0;
897   }
898
899   if (fRawReader) {
900     delete fRawReader; fRawReader = 0;
901   }
902
903   fEventId  = -1;
904   fIsOpen   = kFALSE;
905   fHasEvent = kFALSE;
906 }
907
908
909 //------------------------------------------------------------------------------
910 // Static convenience functions, mainly used from macros.
911 //------------------------------------------------------------------------------
912
913 Bool_t AliEveEventManager::HasRunLoader()
914 {
915   // Check if AliRunLoader is initialized.
916
917   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
918 }
919
920 Bool_t AliEveEventManager::HasESD()
921 {
922   // Check if AliESDEvent is initialized.
923
924   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
925 }
926
927 Bool_t AliEveEventManager::HasESDfriend()
928 {
929   // Check if AliESDfriend is initialized.
930
931   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
932 }
933
934 Bool_t AliEveEventManager::HasAOD()
935 {
936   // Check if AliESDEvent is initialized.
937
938   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
939 }
940
941 Bool_t AliEveEventManager::HasRawReader()
942 {
943   // Check if raw-reader is initialized.
944
945   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
946 }
947
948 AliRunLoader* AliEveEventManager::AssertRunLoader()
949 {
950   // Make sure AliRunLoader is initialized and return it.
951   // Throws exception in case run-loader is not available.
952   // Static utility for macros.
953
954   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
955
956   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
957     throw (kEH + "ALICE event not ready.");
958   if (fgCurrent->fRunLoader == 0)
959     throw (kEH + "AliRunLoader not initialised.");
960   return fgCurrent->fRunLoader;
961 }
962
963 AliESDEvent* AliEveEventManager::AssertESD()
964 {
965   // Make sure AliESDEvent is initialized and return it.
966   // Throws exception in case ESD is not available.
967   // Static utility for macros.
968
969   static const TEveException kEH("AliEveEventManager::AssertESD ");
970
971   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
972     throw (kEH + "ALICE event not ready.");
973   if (fgCurrent->fESD == 0)
974     throw (kEH + "AliESD not initialised.");
975   return fgCurrent->fESD;
976 }
977
978 AliESDfriend* AliEveEventManager::AssertESDfriend()
979 {
980   // Make sure AliESDfriend is initialized and return it.
981   // Throws exception in case ESDfriend-loader is not available.
982   // Static utility for macros.
983
984   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
985
986   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
987     throw (kEH + "ALICE event not ready.");
988   if (fgCurrent->fESDfriend == 0)
989     throw (kEH + "AliESDfriend not initialised.");
990   return fgCurrent->fESDfriend;
991 }
992
993 AliAODEvent* AliEveEventManager::AssertAOD()
994 {
995   // Make sure AliAODEvent is initialized and return it.
996   // Throws exception in case AOD is not available.
997   // Static utility for macros.
998
999   static const TEveException kEH("AliEveEventManager::AssertAOD ");
1000
1001   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1002     throw (kEH + "ALICE event not ready.");
1003   if (fgCurrent->fAOD == 0)
1004     throw (kEH + "AliAOD not initialised.");
1005   return fgCurrent->fAOD;
1006 }
1007
1008 AliRawReader* AliEveEventManager::AssertRawReader()
1009 {
1010   // Make sure raw-reader is initialized and return it.
1011
1012   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1013
1014   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1015     throw (kEH + "ALICE event not ready.");
1016   if (fgCurrent->fRawReader == 0)
1017     throw (kEH + "RawReader not ready.");
1018
1019   return fgCurrent->fRawReader;
1020 }
1021
1022 //==============================================================================
1023
1024 AliMagF* AliEveEventManager::AssertMagField()    
1025 {        
1026   // Make sure AliMagF is initialized and returns it.    
1027   // Throws exception in case magnetic field is not available.   
1028   // Static utility for macros.          
1029
1030   static const TEveException kEH("AliEveEventManager::AssertMagField ");         
1031                  
1032   if (fgMagField)
1033     return fgMagField;
1034
1035   if (TGeoGlobalMagField::Instance()->GetField())
1036   {
1037     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1038     if (fgMagField == 0)
1039       throw kEH + "Global field set, but it is not AliMagF.";
1040     return fgMagField;
1041   }
1042
1043   if (!fgGRPLoaded)
1044   {
1045     InitGRP();
1046   }
1047
1048   if (TGeoGlobalMagField::Instance()->GetField())
1049   {
1050     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1051     if (fgMagField == 0)
1052       throw kEH + "Global field set, but it is not AliMagF.";
1053   }
1054   else
1055   {
1056     throw kEH + "Could not initialize magnetic field.";
1057   }
1058
1059   return fgMagField;     
1060 }
1061
1062 TGeoManager* AliEveEventManager::AssertGeometry()
1063 {
1064   // Make sure AliGeomManager is initialized and returns the
1065   // corresponding TGeoManger.
1066   // gGeoManager is set to the return value.
1067   // Throws exception if geometry can not be loaded or if it is not
1068   // available and the TGeoManager is locked.
1069   // Static utility for macros.
1070
1071   static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1072
1073   if (AliGeomManager::GetGeometry() == 0)
1074   {
1075     if (TGeoManager::IsLocked())
1076       throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1077
1078     gGeoManager = 0;
1079     AliGeomManager::LoadGeometry();
1080     if ( ! AliGeomManager::GetGeometry())
1081     {
1082       throw (kEH + "can not load geometry.");
1083     }
1084     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1085     {
1086       ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1087       // throw (kEH + "could not apply align objs.");
1088     }
1089     AliGeomManager::GetGeometry()->DefaultColors();
1090   }
1091
1092   gGeoManager = AliGeomManager::GetGeometry();
1093   return gGeoManager;
1094 }
1095
1096 //------------------------------------------------------------------------------
1097
1098 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1099 {
1100   // Create and attach a dependent event-manager.
1101   // It is not added into eve list tree.
1102
1103   static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1104
1105   if (fgMaster == 0)
1106     throw(kEH + "Master event-manager must be instantiated first.");
1107
1108   if (fgMaster->fSubManagers == 0)
1109   {
1110     fgMaster->fSubManagers = new TList;
1111     fgMaster->fSubManagers->SetOwner(kTRUE);
1112   }
1113
1114   AliEveEventManager* new_mgr = 0;
1115   fgCurrent = 0;
1116   try
1117   {
1118     new_mgr = new AliEveEventManager(name, path, fgMaster->fEventId);
1119     fgMaster->fSubManagers->Add(new_mgr);
1120   }
1121   catch (TEveException& exc)
1122   {
1123     ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1124   }
1125   fgCurrent = fgMaster;
1126
1127   return new_mgr;
1128 }
1129
1130 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1131 {
1132   // Get a dependant manager by name.
1133   // This will not change the current manager, use helper class
1134   // AliEveEventManager::CurrentChanger for that.
1135
1136   static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1137
1138   if (fgMaster == 0)
1139     throw(kEH + "Master event-manager must be instantiated first.");
1140
1141   if (fgMaster->fSubManagers == 0)
1142     return 0;
1143
1144   return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1145 }
1146
1147 AliEveEventManager* AliEveEventManager::GetMaster()
1148 {
1149   // Get master event-manager.
1150
1151   return fgMaster;
1152 }
1153
1154 AliEveEventManager* AliEveEventManager::GetCurrent()
1155 {
1156   // Get current event-manager.
1157
1158   return fgCurrent;
1159 }
1160
1161 void AliEveEventManager::RegisterTransient(TEveElement* element)
1162 {
1163   GetCurrent()->fTransients->AddElement(element);
1164 }
1165
1166 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1167 {
1168   GetCurrent()->fTransientLists->AddElement(element);
1169 }
1170
1171 //------------------------------------------------------------------------------
1172 // Autoloading of events
1173 //------------------------------------------------------------------------------
1174
1175 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1176 {
1177   // Set the auto-load time in seconds
1178
1179   fAutoLoadTime = time;
1180 }
1181
1182 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1183 {
1184   // Set the automatic event loading mode
1185
1186   static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1187
1188   if (fAutoLoad == autoLoad)
1189   {
1190     Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1191     return;
1192   }
1193
1194   fAutoLoad = autoLoad;
1195   if (fAutoLoad)
1196   {
1197     StartAutoLoadTimer();
1198   }
1199   else
1200   {
1201     StopAutoLoadTimer();
1202   }
1203 }
1204
1205 void AliEveEventManager::SetTrigSel(Int_t trig)
1206 {
1207   static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1208
1209   if (!fRawReader)
1210     {
1211     Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1212     return;
1213   }
1214   else
1215   {
1216     ULong64_t trigMask = 0;
1217     if (trig >= 0) trigMask = (1ull << trig);
1218     Info(kEH,"Trigger selection: 0x%llx",trigMask);
1219     fRawReader->SelectEvents(-1,trigMask,NULL);
1220   }
1221 }
1222
1223 void AliEveEventManager::StartAutoLoadTimer()
1224 {
1225   // Start the auto-load timer.
1226
1227   fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1228   fAutoLoadTimer->Reset();
1229   fAutoLoadTimer->TurnOn();
1230   fAutoLoadTimerRunning = kTRUE;
1231 }
1232
1233 void AliEveEventManager::StopAutoLoadTimer()
1234 {
1235   // Stop the auto-load timer.
1236
1237   fAutoLoadTimerRunning = kFALSE;
1238   fAutoLoadTimer->TurnOff();
1239 }
1240
1241 void AliEveEventManager::AutoLoadNextEvent()
1242 {
1243   // Called from auto-load timer, so it has to be public.
1244   // Do NOT call it directly.
1245
1246   static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1247
1248   if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1249   {
1250     Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1251     return;
1252   }
1253
1254   StopAutoLoadTimer();
1255   NextEvent();
1256   if (fAutoLoad && !fExternalCtrl)
1257     StartAutoLoadTimer();
1258 }
1259
1260 //------------------------------------------------------------------------------
1261 // Post event-loading functions
1262 //------------------------------------------------------------------------------
1263
1264 void AliEveEventManager::AfterNewEventLoaded()
1265 {
1266   // Execute registered macros and commands.
1267   // At the end emit NewEventLoaded signal.
1268   //
1269   // Virtual from TEveEventManager.
1270
1271   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1272
1273   if (fExecutor)
1274     fExecutor->ExecMacros();
1275
1276   TEveEventManager::AfterNewEventLoaded();
1277
1278   NewEventLoaded();
1279
1280   if (this == fgMaster && fSubManagers != 0)
1281   {
1282     TIter next(fSubManagers);
1283     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1284     {
1285       gEve->SetCurrentEvent(fgCurrent);
1286       try
1287       {
1288         fgCurrent->GotoEvent(fEventId);
1289       }
1290       catch (TEveException& exc)
1291       {
1292         // !!! Should somehow tag / disable / remove it?
1293         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1294               fEventId, fgCurrent->GetName(), exc.Data());
1295       }
1296     }
1297     fgCurrent = fgMaster;
1298     gEve->SetCurrentEvent(fgMaster);
1299   }
1300 }
1301
1302 void AliEveEventManager::NewEventLoaded()
1303 {
1304   // Emit NewEventLoaded signal.
1305
1306   Emit("NewEventLoaded()");
1307 }
1308
1309
1310 //------------------------------------------------------------------------------
1311 // Event info dumpers
1312 //------------------------------------------------------------------------------
1313
1314 TString AliEveEventManager::GetEventInfoHorizontal() const
1315 {
1316   // Dumps the event-header contents in vertical formatting.
1317
1318   TString rawInfo, esdInfo;
1319
1320   if (!fRawReader)
1321   {
1322     rawInfo = "No raw-data event info is available!\n";
1323   }
1324   else
1325   {
1326     const UInt_t* attr = fRawReader->GetAttributes();
1327     TTimeStamp ts(fRawReader->GetTimestamp());
1328     rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1329                  "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
1330                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1331                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1332                  fRawReader->GetClassMask(),
1333                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1334                  attr[0],attr[1],attr[2], ts.AsString("s"));
1335   }
1336
1337   if (!fESD)
1338   {
1339     esdInfo = "No ESD event info is available!";
1340   }
1341   else
1342   {
1343     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1344     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1345     TTimeStamp ts(fESD->GetTimeStamp());
1346     esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1347                  "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
1348                  fESD->GetRunNumber(),
1349                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1350                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1351                  acttrclasses.Data(),
1352                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1353                  fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
1354   }
1355
1356   return rawInfo + esdInfo;
1357 }
1358
1359 TString AliEveEventManager::GetEventInfoVertical() const
1360 {
1361   // Dumps the event-header contents in vertical formatting.
1362
1363   TString rawInfo, esdInfo;
1364
1365   if (!fRawReader)
1366   {
1367     rawInfo = "No raw-data event info is available!\n";
1368   }
1369   else
1370   {
1371     const UInt_t* attr = fRawReader->GetAttributes();
1372     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",
1373                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1374                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1375                  fRawReader->GetClassMask(),
1376                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1377                  attr[0],attr[1],attr[2],
1378                  fRawReader->GetTimestamp());
1379   }
1380
1381   if (!fESD)
1382   {
1383     esdInfo = "No ESD event info is available!\n";
1384   }
1385   else
1386   {
1387     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1388     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1389     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",
1390                  fESD->GetRunNumber(),
1391                  acttrclasses.Data(),
1392                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1393                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1394                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1395                  fESD->GetEventNumberInFile(),
1396                  fESD->GetTimeStamp());
1397   }
1398
1399   return rawInfo + "\n" + esdInfo;
1400 }
1401
1402
1403 //==============================================================================
1404 // Reading of GRP and MagneticField.
1405 // This is a reap-off from reconstruction ... should really be a common
1406 // code to do this somewhere in STEER.
1407 //==============================================================================
1408
1409 Bool_t AliEveEventManager::InitGRP()
1410 {
1411   //------------------------------------
1412   // Initialization of the GRP entry 
1413   //------------------------------------
1414
1415   static const TEveException kEH("AliEveEventManager::InitGRP ");
1416
1417   AliGRPManager grpMgr;
1418   if (!grpMgr.ReadGRPEntry()) {
1419     return kFALSE;
1420   }
1421   fgGRPLoaded = kTRUE;
1422   if (!grpMgr.SetMagField()) {
1423     throw kEH + "Setting of field failed!";
1424   }
1425
1426   //*** Get the diamond profiles from OCDB
1427   // Eventually useful.
1428
1429   /*
1430     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1431     if (entry) {
1432     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1433     } else {
1434     ::Error(kEH, "No SPD diamond profile found in OCDB!");
1435     }
1436
1437     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1438     if (entry) {
1439     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1440     } else {
1441     ::Error(kEH, "No diamond profile found in OCDB!");
1442     }
1443
1444     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1445     if (entry) {
1446     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1447     } else {
1448     ::Error(kEH, "No TPC diamond profile found in OCDB!");
1449     }
1450   */
1451
1452   return kTRUE;
1453