The problem with check-if-file-exists-in-alien has been committed to root trunk ...
[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   // Fixed in ROOT on 27.10.2009, rev 30888.
429   // To revert after we move to root-5.26.
430   TFile *gafile = TFile::Open(gaPath);
431   if (gafile)
432   {
433     gafile->Close();
434     delete gafile;
435   // if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
436   // {
437     fRunLoader = AliRunLoader::Open(gaPath, GetName());
438     if (fRunLoader)
439     {
440       TString alicePath = fPath + "/";
441       fRunLoader->SetDirName(alicePath);
442
443       if (fRunLoader->LoadgAlice() != 0)
444         Warning(kEH, "failed loading gAlice via run-loader.");
445
446       if (fRunLoader->LoadHeader() == 0)
447       {
448         if (runNo < 0)
449           runNo = fRunLoader->GetHeader()->GetRun();
450       }
451       else
452       {
453         Warning(kEH, "failed loading run-loader's header.");
454         delete fRunLoader;
455         fRunLoader = 0;
456       }
457     }
458     else // run-loader open failed
459     {
460       Warning(kEH, "failed opening ALICE run-loader from '%s'.", gaPath.Data());
461     }
462   }
463   else // galice not readable
464   {
465     Warning(kEH, "can not read '%s'.", gaPath.Data());
466   }
467   if (fRunLoader == 0)
468   {
469     if (fgAssertRunLoader)
470       throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
471     else
472       Warning(kEH, "Bootstraping of run-loader failed.");
473   }
474
475   // Open raw-data file
476
477   TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
478   // If i use open directly, raw-reader reports an error but i have
479   // no way to detect it.
480   // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
481   AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
482   if (fgAssertRaw == kFALSE)
483   {
484     AliLog::SetGlobalLogLevel(AliLog::kFatal);
485   }
486   if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
487   {
488     fRawReader = AliRawReader::Create(rawPath);
489   }
490   else
491   {
492     fRawReader = AliRawReader::Create(fgRawFileName);
493   }
494   if (fgAssertRaw == kFALSE)
495   {
496     AliLog::SetGlobalLogLevel(oldLogLevel);
497   }
498
499   if (fRawReader == 0)
500   {
501     if (fgAssertRaw)
502     {
503       throw (kEH + "raw-data not initialized. Its precence was requested.");
504     } else {
505       Warning(kEH, "raw-data not initialized.");
506     }
507   }
508
509   if (runNo < 0)
510   {
511     if (fRawReader)
512     {
513       fRawReader->NextEvent();
514       runNo = fRawReader->GetRunNumber();
515       Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
516       fRawReader->RewindEvents();
517     } else {
518       throw (kEH + "unknown run number.");
519     }
520   }
521
522   // Initialize OCDB ... only in master event-manager
523
524   if (this == fgMaster)
525   {
526     AliCDBManager* cdb = AliCDBManager::Instance();
527     if (cdb->IsDefaultStorageSet() == kTRUE)
528     {
529       Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
530               cdb->GetDefaultStorage()->GetURI().Data());
531     }
532     else
533     {
534       if (fgCdbUri.IsNull())
535       {
536         gEnv->SetValue("Root.Stacktrace", "no");
537         Fatal("Open()", "OCDB path was not specified.");
538       }
539
540       // Handle some special cases for MC (should be in OCDBManager).
541       if (fgCdbUri == "mcideal://")
542         cdb->SetDefaultStorage("MC", "Ideal");
543       else if (fgCdbUri == "mcresidual://")
544         cdb->SetDefaultStorage("MC", "Residual");
545       else if (fgCdbUri == "mcfull://")
546         cdb->SetDefaultStorage("MC", "Full");
547       else if (fgCdbUri == "local://") {
548         fgCdbUri = "local://$ALICE_ROOT/OCDB";
549         cdb->SetDefaultStorage(fgCdbUri);
550       } else
551         cdb->SetDefaultStorage(fgCdbUri);
552
553       cdb->SetRun(runNo);
554
555       if (cdb->IsDefaultStorageSet() == kFALSE)
556         throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
557     }
558     
559     if (fgCdbUri.BeginsWith("local://"))
560     {
561       TString grp     = "GRP/GRP/Data";
562       TString grppath = fPath + "/" + grp;
563       if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
564       {
565         if (cdb->GetSpecificStorage(grp))
566         {
567           Warning(kEH, "Local GRP exists, but the specific storage is already set.");
568         }
569         else
570         {
571           Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
572           TString lpath("local://");
573           lpath += fPath;
574           cdb->SetSpecificStorage(grp, lpath);
575         }
576       }
577     }
578   }
579
580   fIsOpen = kTRUE;
581 }
582
583 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
584 {
585   // Set an event from an external source.
586   // The method is used in the online visualisation.
587   // AOD is not supported.
588
589   static const TEveException kEH("AliEveEventManager::SetEvent ");
590
591   if (fIsOpen)
592   {
593     Warning(kEH, "Event-files were open. Closing and switching to external control.");
594     Close();
595   }
596
597   fRunLoader = runLoader;
598   fRawReader = rawReader;
599   fESD       = esd;
600   fESDfriend = esdf;
601   fAOD       = 0;
602
603   fEventId++;
604   fHasEvent     = kTRUE;
605   fExternalCtrl = kTRUE;
606
607   SetTitle("Online event in memory");
608   SetName ("Online Event");
609   ElementChanged();
610
611   AfterNewEventLoaded();
612
613   if (fAutoLoad) StartAutoLoadTimer();
614 }
615
616 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
617 {
618   // Returns maximum available event id.
619   // If under external control or event is not opened -1 is returned.
620   // If raw-data is the only data-source this can not be known
621   // and 10,000,000 is returned.
622   // If neither data-source is initialised an exception is thrown.
623   // If refresh_esd is true and ESD is the primary event-data source
624   // its header is re-read from disk.
625
626   static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
627
628   if (fExternalCtrl || fIsOpen == kFALSE)
629   {
630     return -1;
631   }
632
633   if (fESDTree)
634   {
635     if (refreshESD)
636     {
637        fESDTree->Refresh();
638        fPEventSelector->Update();
639     }
640     return fESDTree->GetEntries() - 1;
641   }
642   else if (fAODTree)
643   {
644     return fAODTree->GetEntries() - 1;
645   }
646   else if (fRunLoader)
647   {
648     return fRunLoader->GetNumberOfEvents() - 1;
649   }
650   else if (fRawReader)
651   {
652     Int_t n = fRawReader->GetNumberOfEvents() - 1;
653     return n > -1 ? n : 10000000;
654   }
655   else
656   {
657     throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
658   }
659 }
660
661 void AliEveEventManager::GotoEvent(Int_t event)
662 {
663   // Load data for specified event.
664   // If event is out of range an exception is thrown and old state
665   // is preserved.
666   // After successful loading of event, the virtual function
667   // AfterNewEventLoaded() is called. This executes commands that
668   // were registered via TEveEventManager::AddNewEventCommand().
669   //
670   // If event is negative, it is subtracted from the number of
671   // available events, thus passing -1 will load the last event.
672   // This is not supported when raw-data is the only data-source
673   // as the number of events is not known.
674
675   static const TEveException kEH("AliEveEventManager::GotoEvent ");
676
677   if (fAutoLoadTimerRunning)
678   {
679     throw (kEH + "Event auto-load timer is running.");
680   }
681   if (fExternalCtrl)
682   {
683     throw (kEH + "Event-loop is under external control.");
684   }
685   else if (!fIsOpen)
686   {
687     throw (kEH + "Event-files not opened.");
688   }
689
690   fHasEvent = kFALSE;
691
692   Int_t maxEvent = 0;
693   if (fESDTree)
694   {
695     // Refresh crashes with root-5.21.1-alice.
696     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
697     // when we move to a newer root.
698     // fESDTree->Refresh();
699     maxEvent = fESDTree->GetEntries() - 1;
700     if (event < 0)
701       event = fESDTree->GetEntries() + event;
702   }
703   else if (fAODTree)
704   {
705     maxEvent = fAODTree->GetEntries() - 1;
706     if (event < 0)
707       event = fAODTree->GetEntries() + event;
708   }
709   else if (fRunLoader)
710   {
711     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
712     if (event < 0)
713       event = fRunLoader->GetNumberOfEvents() + event;
714   }
715   else if (fRawReader)
716   {
717     maxEvent = fRawReader->GetNumberOfEvents() - 1;
718     if (maxEvent < 0)
719     {
720       maxEvent = 10000000;
721       if (event < 0) {
722         Error(kEH, "current raw-data source does not support direct event access.");
723         return;
724       }
725       Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
726     }
727     else
728     {
729       if (event < 0)
730         event = fRawReader->GetNumberOfEvents() + event;
731     }
732   }
733   else
734   {
735     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
736   }
737   if (event < 0 || event > maxEvent)
738   {
739     throw (kEH + Form("event %d not present, available range [%d, %d].",
740                       event, 0, maxEvent));
741   }
742
743   TString sysInfoHeader;
744   sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
745   AliSysInfo::AddStamp(sysInfoHeader + "Start");
746
747   TEveManager::TRedrawDisabler rd(gEve);
748   gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
749
750   // !!! MT this is somewhat brutal; at least optionally, one could be
751   // a bit gentler, checking for objs owning their external refs and having
752   // additinal parents.
753   gEve->GetViewers()->DeleteAnnotations();
754   fTransients->DestroyElements();
755   for (TEveElement::List_i i = fTransientLists->BeginChildren();
756        i != fTransientLists->EndChildren(); ++i)
757   {
758     (*i)->DestroyElements();
759   }
760   DestroyElements();
761
762   AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
763
764   if (fESDTree) {
765     if (fESDTree->GetEntry(event) <= 0)
766       throw (kEH + "failed getting required event from ESD.");
767
768     if (fESDfriendExists)
769       fESD->SetESDfriend(fESDfriend);
770   }
771
772   if (fAODTree) {
773     if (fAODTree->GetEntry(event) <= 0)
774       throw (kEH + "failed getting required event from AOD.");
775   }
776
777   if (fRunLoader) {
778     if (fRunLoader->GetEvent(event) != 0)
779       throw (kEH + "failed getting required event.");
780   }
781
782   if (fRawReader)
783   {
784     // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
785     if (fRawReader->GotoEvent(event) == kFALSE)
786     {
787       // Use fallback method - iteration with NextEvent().
788       Int_t rawEv = fEventId;
789       if (event < rawEv)
790       {
791         fRawReader->RewindEvents();
792         rawEv = -1;
793       }
794
795       while (rawEv < event)
796       {
797         if ( ! fRawReader->NextEvent())
798         {
799           fRawReader->RewindEvents();
800           fEventId = -1;
801           throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
802         }
803         ++rawEv;
804       }
805       Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
806     }
807   }
808
809   fHasEvent = kTRUE;
810   fEventId  = event;
811   if (this == fgMaster)
812   {
813     SetName(Form("Event %d", fEventId));
814     ElementChanged();
815   }
816
817   AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
818
819   AfterNewEventLoaded();
820
821   AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
822 }
823
824 void AliEveEventManager::NextEvent()
825 {
826   // Loads next event.
827   // Does magick needed for online display when under external event control.
828
829   static const TEveException kEH("AliEveEventManager::NextEvent ");
830
831   if (fAutoLoadTimerRunning)
832   {
833     throw (kEH + "Event auto-load timer is running.");
834   }
835
836   if (fExternalCtrl)
837   {
838     // !!! This should really go somewhere else. It is done in GotoEvent(),
839     // so here we should do it in SetEvent().
840     DestroyElements();
841
842     gSystem->ExitLoop();
843   }
844   else if (fESDTree)
845   {
846     Int_t nextevent=0;
847     if (fPEventSelector->FindNext(nextevent))
848     {
849       GotoEvent(nextevent);
850     }
851   }
852   else if (fEventId < GetMaxEventId(kTRUE))
853   {
854     GotoEvent(fEventId + 1);
855   }
856 }
857
858 void AliEveEventManager::PrevEvent()
859 {
860   // Loads previous event.
861
862   static const TEveException kEH("AliEveEventManager::PrevEvent ");
863
864   if (fAutoLoadTimerRunning)
865   {
866     throw (kEH + "Event auto-load timer is running.");
867   }
868   if (fExternalCtrl)
869   {
870     throw (kEH + "Event-loop is under external control.");
871   }
872
873   if (fESDTree)
874   {
875     Int_t nextevent=0;
876     if (fPEventSelector->FindPrev(nextevent))
877     {
878       GotoEvent(nextevent);
879     }
880   }
881   else if (fEventId > 0)
882   {
883     GotoEvent(fEventId - 1);
884   }
885 }
886
887 void AliEveEventManager::Close()
888 {
889   // Close the event data-files and delete ESD, ESDfriend, run-loader
890   // and raw-reader.
891
892   static const TEveException kEH("AliEveEventManager::Close ");
893
894   if (!fIsOpen)
895   {
896     throw (kEH + "Event-files not opened.");
897   }
898
899   if (fAutoLoadTimerRunning)
900     StopAutoLoadTimer();
901
902   if (fESDTree) {
903     delete fESD;       fESD       = 0;
904     delete fESDfriend; fESDfriend = 0;
905     fESDfriendExists = kFALSE;
906
907     delete fESDTree;   fESDTree = 0;
908     delete fESDFile;   fESDFile = 0;
909   }
910
911   if (fAODTree) {
912     delete fAOD;       fAOD       = 0;
913
914     delete fAODTree;   fAODTree = 0;
915     delete fAODFile;   fAODFile = 0;
916   }
917
918   if (fRunLoader) {
919     delete fRunLoader; fRunLoader = 0;
920   }
921
922   if (fRawReader) {
923     delete fRawReader; fRawReader = 0;
924   }
925
926   fEventId  = -1;
927   fIsOpen   = kFALSE;
928   fHasEvent = kFALSE;
929 }
930
931
932 //------------------------------------------------------------------------------
933 // Static convenience functions, mainly used from macros.
934 //------------------------------------------------------------------------------
935
936 Bool_t AliEveEventManager::HasRunLoader()
937 {
938   // Check if AliRunLoader is initialized.
939
940   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
941 }
942
943 Bool_t AliEveEventManager::HasESD()
944 {
945   // Check if AliESDEvent is initialized.
946
947   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
948 }
949
950 Bool_t AliEveEventManager::HasESDfriend()
951 {
952   // Check if AliESDfriend is initialized.
953
954   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
955 }
956
957 Bool_t AliEveEventManager::HasAOD()
958 {
959   // Check if AliESDEvent is initialized.
960
961   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
962 }
963
964 Bool_t AliEveEventManager::HasRawReader()
965 {
966   // Check if raw-reader is initialized.
967
968   return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
969 }
970
971 AliRunLoader* AliEveEventManager::AssertRunLoader()
972 {
973   // Make sure AliRunLoader is initialized and return it.
974   // Throws exception in case run-loader is not available.
975   // Static utility for macros.
976
977   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
978
979   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
980     throw (kEH + "ALICE event not ready.");
981   if (fgCurrent->fRunLoader == 0)
982     throw (kEH + "AliRunLoader not initialised.");
983   return fgCurrent->fRunLoader;
984 }
985
986 AliESDEvent* AliEveEventManager::AssertESD()
987 {
988   // Make sure AliESDEvent is initialized and return it.
989   // Throws exception in case ESD is not available.
990   // Static utility for macros.
991
992   static const TEveException kEH("AliEveEventManager::AssertESD ");
993
994   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
995     throw (kEH + "ALICE event not ready.");
996   if (fgCurrent->fESD == 0)
997     throw (kEH + "AliESD not initialised.");
998   return fgCurrent->fESD;
999 }
1000
1001 AliESDfriend* AliEveEventManager::AssertESDfriend()
1002 {
1003   // Make sure AliESDfriend is initialized and return it.
1004   // Throws exception in case ESDfriend-loader is not available.
1005   // Static utility for macros.
1006
1007   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1008
1009   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1010     throw (kEH + "ALICE event not ready.");
1011   if (fgCurrent->fESDfriend == 0)
1012     throw (kEH + "AliESDfriend not initialised.");
1013   return fgCurrent->fESDfriend;
1014 }
1015
1016 AliAODEvent* AliEveEventManager::AssertAOD()
1017 {
1018   // Make sure AliAODEvent is initialized and return it.
1019   // Throws exception in case AOD is not available.
1020   // Static utility for macros.
1021
1022   static const TEveException kEH("AliEveEventManager::AssertAOD ");
1023
1024   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1025     throw (kEH + "ALICE event not ready.");
1026   if (fgCurrent->fAOD == 0)
1027     throw (kEH + "AliAOD not initialised.");
1028   return fgCurrent->fAOD;
1029 }
1030
1031 AliRawReader* AliEveEventManager::AssertRawReader()
1032 {
1033   // Make sure raw-reader is initialized and return it.
1034
1035   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1036
1037   if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1038     throw (kEH + "ALICE event not ready.");
1039   if (fgCurrent->fRawReader == 0)
1040     throw (kEH + "RawReader not ready.");
1041
1042   return fgCurrent->fRawReader;
1043 }
1044
1045 //==============================================================================
1046
1047 AliMagF* AliEveEventManager::AssertMagField()    
1048 {        
1049   // Make sure AliMagF is initialized and returns it.    
1050   // Throws exception in case magnetic field is not available.   
1051   // Static utility for macros.          
1052
1053   static const TEveException kEH("AliEveEventManager::AssertMagField ");         
1054                  
1055   if (fgMagField)
1056     return fgMagField;
1057
1058   if (TGeoGlobalMagField::Instance()->GetField())
1059   {
1060     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1061     if (fgMagField == 0)
1062       throw kEH + "Global field set, but it is not AliMagF.";
1063     return fgMagField;
1064   }
1065
1066   if (!fgGRPLoaded)
1067   {
1068     InitGRP();
1069   }
1070
1071   if (TGeoGlobalMagField::Instance()->GetField())
1072   {
1073     fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1074     if (fgMagField == 0)
1075       throw kEH + "Global field set, but it is not AliMagF.";
1076   }
1077   else
1078   {
1079     throw kEH + "Could not initialize magnetic field.";
1080   }
1081
1082   return fgMagField;     
1083 }
1084
1085 TGeoManager* AliEveEventManager::AssertGeometry()
1086 {
1087   // Make sure AliGeomManager is initialized and returns the
1088   // corresponding TGeoManger.
1089   // gGeoManager is set to the return value.
1090   // Throws exception if geometry can not be loaded or if it is not
1091   // available and the TGeoManager is locked.
1092   // Static utility for macros.
1093
1094   static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1095
1096   if (AliGeomManager::GetGeometry() == 0)
1097   {
1098     if (TGeoManager::IsLocked())
1099       throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1100
1101     gGeoManager = 0;
1102     AliGeomManager::LoadGeometry();
1103     if ( ! AliGeomManager::GetGeometry())
1104     {
1105       throw (kEH + "can not load geometry.");
1106     }
1107     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1108     {
1109       ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1110       // throw (kEH + "could not apply align objs.");
1111     }
1112     AliGeomManager::GetGeometry()->DefaultColors();
1113   }
1114
1115   gGeoManager = AliGeomManager::GetGeometry();
1116   return gGeoManager;
1117 }
1118
1119 //------------------------------------------------------------------------------
1120
1121 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1122 {
1123   // Create and attach a dependent event-manager.
1124   // It is not added into eve list tree.
1125
1126   static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1127
1128   if (fgMaster == 0)
1129     throw(kEH + "Master event-manager must be instantiated first.");
1130
1131   if (fgMaster->fSubManagers == 0)
1132   {
1133     fgMaster->fSubManagers = new TList;
1134     fgMaster->fSubManagers->SetOwner(kTRUE);
1135   }
1136
1137   AliEveEventManager* new_mgr = 0;
1138   fgCurrent = 0;
1139   try
1140   {
1141     new_mgr = new AliEveEventManager(name, path, fgMaster->fEventId);
1142     fgMaster->fSubManagers->Add(new_mgr);
1143   }
1144   catch (TEveException& exc)
1145   {
1146     ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1147   }
1148   fgCurrent = fgMaster;
1149
1150   return new_mgr;
1151 }
1152
1153 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1154 {
1155   // Get a dependant manager by name.
1156   // This will not change the current manager, use helper class
1157   // AliEveEventManager::CurrentChanger for that.
1158
1159   static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1160
1161   if (fgMaster == 0)
1162     throw(kEH + "Master event-manager must be instantiated first.");
1163
1164   if (fgMaster->fSubManagers == 0)
1165     return 0;
1166
1167   return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1168 }
1169
1170 AliEveEventManager* AliEveEventManager::GetMaster()
1171 {
1172   // Get master event-manager.
1173
1174   return fgMaster;
1175 }
1176
1177 AliEveEventManager* AliEveEventManager::GetCurrent()
1178 {
1179   // Get current event-manager.
1180
1181   return fgCurrent;
1182 }
1183
1184 void AliEveEventManager::RegisterTransient(TEveElement* element)
1185 {
1186   GetCurrent()->fTransients->AddElement(element);
1187 }
1188
1189 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1190 {
1191   GetCurrent()->fTransientLists->AddElement(element);
1192 }
1193
1194 //------------------------------------------------------------------------------
1195 // Autoloading of events
1196 //------------------------------------------------------------------------------
1197
1198 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1199 {
1200   // Set the auto-load time in seconds
1201
1202   fAutoLoadTime = time;
1203 }
1204
1205 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1206 {
1207   // Set the automatic event loading mode
1208
1209   static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1210
1211   if (fAutoLoad == autoLoad)
1212   {
1213     Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1214     return;
1215   }
1216
1217   fAutoLoad = autoLoad;
1218   if (fAutoLoad)
1219   {
1220     StartAutoLoadTimer();
1221   }
1222   else
1223   {
1224     StopAutoLoadTimer();
1225   }
1226 }
1227
1228 void AliEveEventManager::SetTrigSel(Int_t trig)
1229 {
1230   static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1231
1232   if (!fRawReader)
1233     {
1234     Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1235     return;
1236   }
1237   else
1238   {
1239     ULong64_t trigMask = 0;
1240     if (trig >= 0) trigMask = (1ull << trig);
1241     Info(kEH,"Trigger selection: 0x%llx",trigMask);
1242     fRawReader->SelectEvents(-1,trigMask,NULL);
1243   }
1244 }
1245
1246 void AliEveEventManager::StartAutoLoadTimer()
1247 {
1248   // Start the auto-load timer.
1249
1250   fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1251   fAutoLoadTimer->Reset();
1252   fAutoLoadTimer->TurnOn();
1253   fAutoLoadTimerRunning = kTRUE;
1254 }
1255
1256 void AliEveEventManager::StopAutoLoadTimer()
1257 {
1258   // Stop the auto-load timer.
1259
1260   fAutoLoadTimerRunning = kFALSE;
1261   fAutoLoadTimer->TurnOff();
1262 }
1263
1264 void AliEveEventManager::AutoLoadNextEvent()
1265 {
1266   // Called from auto-load timer, so it has to be public.
1267   // Do NOT call it directly.
1268
1269   static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1270
1271   if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1272   {
1273     Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1274     return;
1275   }
1276
1277   StopAutoLoadTimer();
1278   NextEvent();
1279   if (fAutoLoad && !fExternalCtrl)
1280     StartAutoLoadTimer();
1281 }
1282
1283 //------------------------------------------------------------------------------
1284 // Post event-loading functions
1285 //------------------------------------------------------------------------------
1286
1287 void AliEveEventManager::AfterNewEventLoaded()
1288 {
1289   // Execute registered macros and commands.
1290   // At the end emit NewEventLoaded signal.
1291   //
1292   // Virtual from TEveEventManager.
1293
1294   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1295
1296   if (fExecutor)
1297     fExecutor->ExecMacros();
1298
1299   TEveEventManager::AfterNewEventLoaded();
1300
1301   NewEventLoaded();
1302
1303   if (this == fgMaster && fSubManagers != 0)
1304   {
1305     TIter next(fSubManagers);
1306     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1307     {
1308       gEve->SetCurrentEvent(fgCurrent);
1309       try
1310       {
1311         fgCurrent->GotoEvent(fEventId);
1312       }
1313       catch (TEveException& exc)
1314       {
1315         // !!! Should somehow tag / disable / remove it?
1316         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1317               fEventId, fgCurrent->GetName(), exc.Data());
1318       }
1319     }
1320     fgCurrent = fgMaster;
1321     gEve->SetCurrentEvent(fgMaster);
1322   }
1323 }
1324
1325 void AliEveEventManager::NewEventLoaded()
1326 {
1327   // Emit NewEventLoaded signal.
1328
1329   Emit("NewEventLoaded()");
1330 }
1331
1332
1333 //------------------------------------------------------------------------------
1334 // Event info dumpers
1335 //------------------------------------------------------------------------------
1336
1337 TString AliEveEventManager::GetEventInfoHorizontal() const
1338 {
1339   // Dumps the event-header contents in vertical formatting.
1340
1341   TString rawInfo, esdInfo;
1342
1343   if (!fRawReader)
1344   {
1345     rawInfo = "No raw-data event info is available!\n";
1346   }
1347   else
1348   {
1349     const UInt_t* attr = fRawReader->GetAttributes();
1350     TTimeStamp ts(fRawReader->GetTimestamp());
1351     rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1352                  "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
1353                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1354                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1355                  fRawReader->GetClassMask(),
1356                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1357                  attr[0],attr[1],attr[2], ts.AsString("s"));
1358   }
1359
1360   if (!fESD)
1361   {
1362     esdInfo = "No ESD event info is available!";
1363   }
1364   else
1365   {
1366     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1367     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1368     TTimeStamp ts(fESD->GetTimeStamp());
1369     esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
1370                  "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
1371                  fESD->GetRunNumber(),
1372                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1373                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1374                  acttrclasses.Data(),
1375                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1376                  fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
1377   }
1378
1379   return rawInfo + esdInfo;
1380 }
1381
1382 TString AliEveEventManager::GetEventInfoVertical() const
1383 {
1384   // Dumps the event-header contents in vertical formatting.
1385
1386   TString rawInfo, esdInfo;
1387
1388   if (!fRawReader)
1389   {
1390     rawInfo = "No raw-data event info is available!\n";
1391   }
1392   else
1393   {
1394     const UInt_t* attr = fRawReader->GetAttributes();
1395     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",
1396                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
1397                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
1398                  fRawReader->GetClassMask(),
1399                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
1400                  attr[0],attr[1],attr[2],
1401                  fRawReader->GetTimestamp());
1402   }
1403
1404   if (!fESD)
1405   {
1406     esdInfo = "No ESD event info is available!\n";
1407   }
1408   else
1409   {
1410     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
1411     TString firedtrclasses = fESD->GetFiredTriggerClasses();
1412     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",
1413                  fESD->GetRunNumber(),
1414                  acttrclasses.Data(),
1415                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
1416                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
1417                  fESD->GetTriggerMask(),firedtrclasses.Data(),
1418                  fESD->GetEventNumberInFile(),
1419                  fESD->GetTimeStamp());
1420   }
1421
1422   return rawInfo + "\n" + esdInfo;
1423 }
1424
1425
1426 //==============================================================================
1427 // Reading of GRP and MagneticField.
1428 // This is a reap-off from reconstruction ... should really be a common
1429 // code to do this somewhere in STEER.
1430 //==============================================================================
1431
1432 Bool_t AliEveEventManager::InitGRP()
1433 {
1434   //------------------------------------
1435   // Initialization of the GRP entry 
1436   //------------------------------------
1437
1438   static const TEveException kEH("AliEveEventManager::InitGRP ");
1439
1440   AliGRPManager grpMgr;
1441   if (!grpMgr.ReadGRPEntry()) {
1442     return kFALSE;
1443   }
1444   fgGRPLoaded = kTRUE;
1445   if (!grpMgr.SetMagField()) {
1446     throw kEH + "Setting of field failed!";
1447   }
1448
1449   //*** Get the diamond profiles from OCDB
1450   // Eventually useful.
1451
1452   /*
1453     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1454     if (entry) {
1455     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1456     } else {
1457     ::Error(kEH, "No SPD diamond profile found in OCDB!");
1458     }
1459
1460     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1461     if (entry) {
1462     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1463     } else {
1464     ::Error(kEH, "No diamond profile found in OCDB!");
1465     }
1466
1467     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1468     if (entry) {
1469     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1470     } else {
1471     ::Error(kEH, "No TPC diamond profile found in OCDB!");
1472     }
1473   */
1474
1475   return kTRUE;
1476