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