Fix Prev/NextEvent() when ESD is not present and the event-selector
[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     if (refreshESD)
634     {
635        fESDTree->Refresh();
636        fPEventSelector->Update();
637     }
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 if (fESDTree)
843   {
844     Int_t nextevent=0;
845     if (fPEventSelector->FindNext(nextevent))
846     {
847       GotoEvent(nextevent);
848     }
849   }
850   else if (fEventId < GetMaxEventId(kTRUE))
851   {
852     GotoEvent(fEventId + 1);
853   }
854 }
855
856 void AliEveEventManager::PrevEvent()
857 {
858   // Loads previous event.
859
860   static const TEveException kEH("AliEveEventManager::PrevEvent ");
861
862   if (fAutoLoadTimerRunning)
863   {
864     throw (kEH + "Event auto-load timer is running.");
865   }
866   if (fExternalCtrl)
867   {
868     throw (kEH + "Event-loop is under external control.");
869   }
870
871   if (fESDTree)
872   {
873     Int_t nextevent=0;
874     if (fPEventSelector->FindPrev(nextevent))
875     {
876       GotoEvent(nextevent);
877     }
878   }
879   else if (fEventId > 0)
880   {
881     GotoEvent(fEventId - 1);
882   }
883 }
884
885 void AliEveEventManager::Close()
886 {
887   // Close the event data-files and delete ESD, ESDfriend, run-loader
888   // and raw-reader.
889
890   static const TEveException kEH("AliEveEventManager::Close ");
891
892   if (!fIsOpen)
893   {
894     throw (kEH + "Event-files not opened.");
895   }
896
897   if (fAutoLoadTimerRunning)
898     StopAutoLoadTimer();
899
900   if (fESDTree) {
901     delete fESD;       fESD       = 0;
902     delete fESDfriend; fESDfriend = 0;
903     fESDfriendExists = kFALSE;
904
905     delete fESDTree;   fESDTree = 0;
906     delete fESDFile;   fESDFile = 0;
907   }
908
909   if (fAODTree) {
910     delete fAOD;       fAOD       = 0;
911
912     delete fAODTree;   fAODTree = 0;
913     delete fAODFile;   fAODFile = 0;
914   }
915
916   if (fRunLoader) {
917     delete fRunLoader; fRunLoader = 0;
918   }
919
920   if (fRawReader) {
921     delete fRawReader; fRawReader = 0;
922   }
923
924   fEventId  = -1;
925   fIsOpen   = kFALSE;
926   fHasEvent = kFALSE;
927 }
928
929
930 //------------------------------------------------------------------------------
931 // Static convenience functions, mainly used from macros.
932 //------------------------------------------------------------------------------
933
934 Bool_t AliEveEventManager::HasRunLoader()
935 {
936   // Check if AliRunLoader is initialized.
937
938   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
939 }
940
941 Bool_t AliEveEventManager::HasESD()
942 {
943   // Check if AliESDEvent is initialized.
944
945   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
946 }
947
948 Bool_t AliEveEventManager::HasESDfriend()
949 {
950   // Check if AliESDfriend is initialized.
951
952   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
953 }
954
955 Bool_t AliEveEventManager::HasAOD()
956 {
957   // Check if AliESDEvent is initialized.
958
959   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
960 }
961
962 Bool_t AliEveEventManager::HasRawReader()
963 {
964   // Check if raw-reader is initialized.
965
966   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
967 }
968
969 AliRunLoader* AliEveEventManager::AssertRunLoader()
970 {
971   // Make sure AliRunLoader is initialized and return it.
972   // Throws exception in case run-loader is not available.
973   // Static utility for macros.
974
975   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
976
977   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
978     throw (kEH + "ALICE event not ready.");
979   if (fgCurrent->fRunLoader == 0)
980     throw (kEH + "AliRunLoader not initialised.");
981   return fgCurrent->fRunLoader;
982 }
983
984 AliESDEvent* AliEveEventManager::AssertESD()
985 {
986   // Make sure AliESDEvent is initialized and return it.
987   // Throws exception in case ESD is not available.
988   // Static utility for macros.
989
990   static const TEveException kEH("AliEveEventManager::AssertESD ");
991
992   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
993     throw (kEH + "ALICE event not ready.");
994   if (fgCurrent->fESD == 0)
995     throw (kEH + "AliESD not initialised.");
996   return fgCurrent->fESD;
997 }
998
999 AliESDfriend* AliEveEventManager::AssertESDfriend()
1000 {
1001   // Make sure AliESDfriend is initialized and return it.
1002   // Throws exception in case ESDfriend-loader is not available.
1003   // Static utility for macros.
1004
1005   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1006
1007   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1008     throw (kEH + "ALICE event not ready.");
1009   if (fgCurrent->fESDfriend == 0)
1010     throw (kEH + "AliESDfriend not initialised.");
1011   return fgCurrent->fESDfriend;
1012 }
1013
1014 AliAODEvent* AliEveEventManager::AssertAOD()
1015 {
1016   // Make sure AliAODEvent is initialized and return it.
1017   // Throws exception in case AOD is not available.
1018   // Static utility for macros.
1019
1020   static const TEveException kEH("AliEveEventManager::AssertAOD ");
1021
1022   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1023     throw (kEH + "ALICE event not ready.");
1024   if (fgCurrent->fAOD == 0)
1025     throw (kEH + "AliAOD not initialised.");
1026   return fgCurrent->fAOD;
1027 }
1028
1029 AliRawReader* AliEveEventManager::AssertRawReader()
1030 {
1031   // Make sure raw-reader is initialized and return it.
1032
1033   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1034
1035   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1036     throw (kEH + "ALICE event not ready.");
1037   if (fgCurrent->fRawReader == 0)
1038     throw (kEH + "RawReader not ready.");
1039
1040   return fgCurrent->fRawReader;
1041 }
1042
1043 //==============================================================================
1044
1045 AliMagF* AliEveEventManager::AssertMagField()    
1046 {        
1047   // Make sure AliMagF is initialized and returns it.    
1048   // Throws exception in case magnetic field is not available.   
1049   // Static utility for macros.          
1050
1051   static const TEveException kEH("AliEveEventManager::AssertMagField ");         
1052                  
1053   if (fgMagField)
1054     return fgMagField;
1055
1056   if (TGeoGlobalMagField::Instance()->GetField())
1057   {
1058     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1059     if (fgMagField == 0)
1060       throw kEH + "Global field set, but it is not AliMagF.";
1061     return fgMagField;
1062   }
1063
1064   if (!fgGRPLoaded)
1065   {
1066     InitGRP();
1067   }
1068
1069   if (TGeoGlobalMagField::Instance()->GetField())
1070   {
1071     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1072     if (fgMagField == 0)
1073       throw kEH + "Global field set, but it is not AliMagF.";
1074   }
1075   else
1076   {
1077     throw kEH + "Could not initialize magnetic field.";
1078   }
1079
1080   return fgMagField;     
1081 }
1082
1083 TGeoManager* AliEveEventManager::AssertGeometry()
1084 {
1085   // Make sure AliGeomManager is initialized and returns the
1086   // corresponding TGeoManger.
1087   // gGeoManager is set to the return value.
1088   // Throws exception if geometry can not be loaded or if it is not
1089   // available and the TGeoManager is locked.
1090   // Static utility for macros.
1091
1092   static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1093
1094   if (AliGeomManager::GetGeometry() == 0)
1095   {
1096     if (TGeoManager::IsLocked())
1097       throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1098
1099     gGeoManager = 0;
1100     AliGeomManager::LoadGeometry();
1101     if ( ! AliGeomManager::GetGeometry())
1102     {
1103       throw (kEH + "can not load geometry.");
1104     }
1105     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1106     {
1107       ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1108       // throw (kEH + "could not apply align objs.");
1109     }
1110     AliGeomManager::GetGeometry()->DefaultColors();
1111   }
1112
1113   gGeoManager = AliGeomManager::GetGeometry();
1114   return gGeoManager;
1115 }
1116
1117 //------------------------------------------------------------------------------
1118
1119 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1120 {
1121   // Create and attach a dependent event-manager.
1122   // It is not added into eve list tree.
1123
1124   static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1125
1126   if (fgMaster == 0)
1127     throw(kEH + "Master event-manager must be instantiated first.");
1128
1129   if (fgMaster->fSubManagers == 0)
1130   {
1131     fgMaster->fSubManagers = new TList;
1132     fgMaster->fSubManagers->SetOwner(kTRUE);
1133   }
1134
1135   AliEveEventManager* new_mgr = 0;
1136   fgCurrent = 0;
1137   try
1138   {
1139     new_mgr = new AliEveEventManager(name, path, fgMaster->fEventId);
1140     fgMaster->fSubManagers->Add(new_mgr);
1141   }
1142   catch (TEveException& exc)
1143   {
1144     ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1145   }
1146   fgCurrent = fgMaster;
1147
1148   return new_mgr;
1149 }
1150
1151 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1152 {
1153   // Get a dependant manager by name.
1154   // This will not change the current manager, use helper class
1155   // AliEveEventManager::CurrentChanger for that.
1156
1157   static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1158
1159   if (fgMaster == 0)
1160     throw(kEH + "Master event-manager must be instantiated first.");
1161
1162   if (fgMaster->fSubManagers == 0)
1163     return 0;
1164
1165   return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1166 }
1167
1168 AliEveEventManager* AliEveEventManager::GetMaster()
1169 {
1170   // Get master event-manager.
1171
1172   return fgMaster;
1173 }
1174
1175 AliEveEventManager* AliEveEventManager::GetCurrent()
1176 {
1177   // Get current event-manager.
1178
1179   return fgCurrent;
1180 }
1181
1182 void AliEveEventManager::RegisterTransient(TEveElement* element)
1183 {
1184   GetCurrent()->fTransients->AddElement(element);
1185 }
1186
1187 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1188 {
1189   GetCurrent()->fTransientLists->AddElement(element);
1190 }
1191
1192 //------------------------------------------------------------------------------
1193 // Autoloading of events
1194 //------------------------------------------------------------------------------
1195
1196 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1197 {
1198   // Set the auto-load time in seconds
1199
1200   fAutoLoadTime = time;
1201 }
1202
1203 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1204 {
1205   // Set the automatic event loading mode
1206
1207   static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1208
1209   if (fAutoLoad == autoLoad)
1210   {
1211     Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1212     return;
1213   }
1214
1215   fAutoLoad = autoLoad;
1216   if (fAutoLoad)
1217   {
1218     StartAutoLoadTimer();
1219   }
1220   else
1221   {
1222     StopAutoLoadTimer();
1223   }
1224 }
1225
1226 void AliEveEventManager::SetTrigSel(Int_t trig)
1227 {
1228   static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1229
1230   if (!fRawReader)
1231     {
1232     Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1233     return;
1234   }
1235   else
1236   {
1237     ULong64_t trigMask = 0;
1238     if (trig >= 0) trigMask = (1ull << trig);
1239     Info(kEH,"Trigger selection: 0x%llx",trigMask);
1240     fRawReader->SelectEvents(-1,trigMask,NULL);
1241   }
1242 }
1243
1244 void AliEveEventManager::StartAutoLoadTimer()
1245 {
1246   // Start the auto-load timer.
1247
1248   fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1249   fAutoLoadTimer->Reset();
1250   fAutoLoadTimer->TurnOn();
1251   fAutoLoadTimerRunning = kTRUE;
1252 }
1253
1254 void AliEveEventManager::StopAutoLoadTimer()
1255 {
1256   // Stop the auto-load timer.
1257
1258   fAutoLoadTimerRunning = kFALSE;
1259   fAutoLoadTimer->TurnOff();
1260 }
1261
1262 void AliEveEventManager::AutoLoadNextEvent()
1263 {
1264   // Called from auto-load timer, so it has to be public.
1265   // Do NOT call it directly.
1266
1267   static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1268
1269   if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1270   {
1271     Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1272     return;
1273   }
1274
1275   StopAutoLoadTimer();
1276   NextEvent();
1277   if (fAutoLoad && !fExternalCtrl)
1278     StartAutoLoadTimer();
1279 }
1280
1281 //------------------------------------------------------------------------------
1282 // Post event-loading functions
1283 //------------------------------------------------------------------------------
1284
1285 void AliEveEventManager::AfterNewEventLoaded()
1286 {
1287   // Execute registered macros and commands.
1288   // At the end emit NewEventLoaded signal.
1289   //
1290   // Virtual from TEveEventManager.
1291
1292   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1293
1294   if (fExecutor)
1295     fExecutor->ExecMacros();
1296
1297   TEveEventManager::AfterNewEventLoaded();
1298
1299   NewEventLoaded();
1300
1301   if (this == fgMaster && fSubManagers != 0)
1302   {
1303     TIter next(fSubManagers);
1304     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1305     {
1306       gEve->SetCurrentEvent(fgCurrent);
1307       try
1308       {
1309         fgCurrent->GotoEvent(fEventId);
1310       }
1311       catch (TEveException& exc)
1312       {
1313         // !!! Should somehow tag / disable / remove it?
1314         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1315               fEventId, fgCurrent->GetName(), exc.Data());
1316       }
1317     }
1318     fgCurrent = fgMaster;
1319     gEve->SetCurrentEvent(fgMaster);
1320   }
1321 }
1322
1323 void AliEveEventManager::NewEventLoaded()
1324 {
1325   // Emit NewEventLoaded signal.
1326
1327   Emit("NewEventLoaded()");
1328 }
1329
1330
1331 //------------------------------------------------------------------------------
1332 // Event info dumpers
1333 //------------------------------------------------------------------------------
1334
1335 TString AliEveEventManager::GetEventInfoHorizontal() const
1336 {
1337   // Dumps the event-header contents in vertical formatting.
1338
1339   TString rawInfo, esdInfo;
1340
1341   if (!fRawReader)
1342   {
1343     rawInfo = "No raw-data event info is available!\n";
1344   }
1345   else
1346   {
1347     const UInt_t* attr = fRawReader->GetAttributes();
1348     TTimeStamp ts(fRawReader->GetTimestamp());
1349     rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1350                  "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
1351                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1352                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1353                  fRawReader->GetClassMask(),
1354                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1355                  attr[0],attr[1],attr[2], ts.AsString("s"));
1356   }
1357
1358   if (!fESD)
1359   {
1360     esdInfo = "No ESD event info is available!";
1361   }
1362   else
1363   {
1364     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1365     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1366     TTimeStamp ts(fESD->GetTimeStamp());
1367     esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1368                  "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
1369                  fESD->GetRunNumber(),
1370                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1371                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1372                  acttrclasses.Data(),
1373                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1374                  fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
1375   }
1376
1377   return rawInfo + esdInfo;
1378 }
1379
1380 TString AliEveEventManager::GetEventInfoVertical() const
1381 {
1382   // Dumps the event-header contents in vertical formatting.
1383
1384   TString rawInfo, esdInfo;
1385
1386   if (!fRawReader)
1387   {
1388     rawInfo = "No raw-data event info is available!\n";
1389   }
1390   else
1391   {
1392     const UInt_t* attr = fRawReader->GetAttributes();
1393     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",
1394                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1395                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1396                  fRawReader->GetClassMask(),
1397                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1398                  attr[0],attr[1],attr[2],
1399                  fRawReader->GetTimestamp());
1400   }
1401
1402   if (!fESD)
1403   {
1404     esdInfo = "No ESD event info is available!\n";
1405   }
1406   else
1407   {
1408     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1409     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1410     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",
1411                  fESD->GetRunNumber(),
1412                  acttrclasses.Data(),
1413                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1414                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1415                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1416                  fESD->GetEventNumberInFile(),
1417                  fESD->GetTimeStamp());
1418   }
1419
1420   return rawInfo + "\n" + esdInfo;
1421 }
1422
1423
1424 //==============================================================================
1425 // Reading of GRP and MagneticField.
1426 // This is a reap-off from reconstruction ... should really be a common
1427 // code to do this somewhere in STEER.
1428 //==============================================================================
1429
1430 Bool_t AliEveEventManager::InitGRP()
1431 {
1432   //------------------------------------
1433   // Initialization of the GRP entry 
1434   //------------------------------------
1435
1436   static const TEveException kEH("AliEveEventManager::InitGRP ");
1437
1438   AliGRPManager grpMgr;
1439   if (!grpMgr.ReadGRPEntry()) {
1440     return kFALSE;
1441   }
1442   fgGRPLoaded = kTRUE;
1443   if (!grpMgr.SetMagField()) {
1444     throw kEH + "Setting of field failed!";
1445   }
1446
1447   //*** Get the diamond profiles from OCDB
1448   // Eventually useful.
1449
1450   /*
1451     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1452     if (entry) {
1453     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1454     } else {
1455     ::Error(kEH, "No SPD diamond profile found in OCDB!");
1456     }
1457
1458     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1459     if (entry) {
1460     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1461     } else {
1462     ::Error(kEH, "No diamond profile found in OCDB!");
1463     }
1464
1465     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1466     if (entry) {
1467     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1468     } else {
1469     ::Error(kEH, "No TPC diamond profile found in OCDB!");
1470     }
1471   */
1472
1473   return kTRUE;
1474