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