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