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 "AliEveMacroExecutor.h"
12 #include <TEveManager.h>
13
14 #include <AliRunLoader.h>
15 #include <AliRun.h>
16 #include <AliESDEvent.h>
17 #include <AliESDfriend.h>
18 #include <AliDAQ.h>
19 #include <AliRawEventHeaderBase.h>
20 #include <AliRawReaderRoot.h>
21 #include <AliRawReaderFile.h>
22 #include <AliRawReaderDate.h>
23 #include <AliMagFMaps.h>
24 #include <AliCDBManager.h>
25 #include <AliHeader.h>
26 #include <AliGeomManager.h>
27
28 #include <TFile.h>
29 #include <TTree.h>
30 #include <TGeoManager.h>
31 #include <TSystem.h>
32 #include <TTimeStamp.h>
33
34 //==============================================================================
35 //==============================================================================
36 // AliEveEventManager
37 //==============================================================================
38
39 //______________________________________________________________________________
40 //
41 // Provide interface for loading and navigating standard AliRoot data
42 // (AliRunLoader) and ESDs.
43 //
44 // Missing support for raw-data. For now this is handled individually
45 // by each sub-detector.
46 //
47 // Also provides interface to magnetic-field and geometry. Mostly
48 // intended as wrappers over standard AliRoot functionality for
49 // convenient use from visualizateion macros.
50
51 ClassImp(AliEveEventManager)
52
53 AliEveEventManager* gAliEveEvent = 0;
54
55 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
56 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
57 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
58
59 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
60 TString  AliEveEventManager::fgRawFileName("raw.root");
61 TString  AliEveEventManager::fgCdbUri("local://$ALICE_ROOT");
62
63 AliMagF* AliEveEventManager::fgMagField = 0;
64
65
66 AliEveEventManager::AliEveEventManager() :
67   TEveEventManager(),
68
69   fPath      ( ), fEventId (-1),
70   fRunLoader (0),
71   fESDFile   (0), fESDTree (0), fESD (0),
72   fESDfriend (0), fESDfriendExists(kFALSE),
73   fRawReader (0),
74   fAutoLoad  (kFALSE), fAutoLoadTime (5.),     fAutoLoadTimer(0),
75   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
76   fExecutor  (new AliEveMacroExecutor)
77 {
78   // Default constructor.
79 }
80
81 AliEveEventManager::AliEveEventManager(TString path, Int_t ev) :
82   TEveEventManager("AliEVE AliEveEventManager"),
83
84   fPath   (path), fEventId(-1),
85   fRunLoader (0),
86   fESDFile   (0), fESDTree (0), fESD (0),
87   fESDfriend (0), fESDfriendExists(kFALSE),
88   fRawReader (0),
89   fAutoLoad  (kFALSE), fAutoLoadTime (5.),     fAutoLoadTimer(0),
90   fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
91   fExecutor  (new AliEveMacroExecutor)
92 {
93   // Constructor with event-directory URL and event-id.
94
95   Open();
96   if (ev >= 0) GotoEvent(ev);
97 }
98
99 AliEveEventManager::~AliEveEventManager()
100 {
101   // Destructor.
102
103   if (fIsOpen)
104   {
105     Close();
106   }
107
108   if (fAutoLoadTimer) delete fAutoLoadTimer;
109   // Somewhat unclear what to do here.
110   // In principle should close all data sources and deregister from
111   // TEveManager.
112 }
113
114 /******************************************************************************/
115
116 void AliEveEventManager::SetESDFileName(const Text_t* esd)
117 {
118   // Set file-name for opening ESD, default "AliESDs.root".
119
120   if (esd) fgESDFileName = esd;
121 }
122
123 void AliEveEventManager::SetRawFileName(const Text_t* raw)
124 {
125   // Set file-name for opening of raw-data, default "raw.root"
126   if (raw) fgRawFileName = raw;
127 }
128
129 void AliEveEventManager::SetCdbUri(const Text_t* cdb)
130 {
131   // Set path to CDB, default "local://$ALICE_ROOT".
132
133   if (cdb) fgCdbUri = cdb;
134 }
135
136 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader,
137                                            Bool_t assertEsd,
138                                            Bool_t assertRaw)
139 {
140   // Set global flags that detrmine which parts of the event-data must
141   // be present when the event is opened.
142
143   fgAssertRunLoader = assertRunloader;
144   fgAssertESD = assertEsd;
145   fgAssertRaw = assertRaw;
146 }
147
148 /******************************************************************************/
149
150 void AliEveEventManager::Open()
151 {
152   // Open event-data from URL specified in fPath.
153   // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
154   // Warning is reported if run-loader or ESD is not found.
155   // Global data-members fgAssertRunLoader and fgAssertESD can be set
156   // to throw exceptions instead.
157
158   static const TEveException kEH("AliEveEventManager::Open ");
159
160   if (fExternalCtrl)
161   {
162     throw (kEH + "Event-loop is under external control.");
163   }
164   if (fIsOpen)
165   {
166     throw (kEH + "Event-files already opened.");
167   }
168
169   gSystem->ExpandPathName(fPath);
170   // The following magick is required for ESDriends to be loaded properly
171   // from non-current directory.
172   if (fPath.IsNull() || fPath == ".")
173   {
174     fPath = gSystem->WorkingDirectory();
175   }
176   else if ( ! fPath.BeginsWith("file:/"))
177   {
178     TUrl    url(fPath, kTRUE);
179     TString protocol(url.GetProtocol());
180     if (protocol == "file" && fPath[0] != '/')
181       fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
182   }
183
184   Int_t runNo = -1;
185
186   // Open ESD and ESDfriends
187
188   TString esdPath(Form("%s/%s", fPath.Data(), fgESDFileName.Data()));
189   if ((fESDFile = TFile::Open(esdPath)))
190   {
191     fESD = new AliESDEvent();
192     fESDTree = (TTree*) fESDFile->Get("esdTree");
193     if (fESDTree != 0)
194     {
195       // Check if ESDfriends exists and attach the branch
196       TString p(Form("%s/AliESDfriends.root", fPath.Data()));
197       TFile *esdFriendFile = TFile::Open(p);
198       if (esdFriendFile) {
199         if (!esdFriendFile->IsZombie())
200           {
201             esdFriendFile->Close();
202             delete esdFriendFile;
203             fESDfriendExists = kTRUE;
204             fESDTree->SetBranchStatus ("ESDfriend*", 1);
205             fESDTree->SetBranchAddress("ESDfriend.", &fESDfriend);
206           }
207         else
208           {
209             esdFriendFile->Close();
210             delete esdFriendFile;
211           }
212       }
213
214       fESD->ReadFromTree(fESDTree);
215       if (!fESDfriendExists) fESDTree->SetBranchStatus ("ESDfriend*", 0);
216       if (fESDTree->GetEntry(0) <= 0)
217         {
218           delete fESDFile; fESDFile = 0;
219           delete fESD; fESD = 0;
220           Warning(kEH, "failed getting the first entry from esdTree.");
221         }
222       else
223         {
224           if (runNo < 0)
225             runNo = fESD->GetESDRun()->GetRunNumber();
226         }
227     }
228     else // esdtree == 0
229     {
230       delete fESDFile; fESDFile = 0;
231       delete fESD; fESD = 0;
232       Warning(kEH, "failed getting the esdTree.");
233     }
234   }
235   else // esd not readable
236   {
237     Warning(kEH, "can not read ESD file '%s'.", esdPath.Data());
238   }
239   if (fESDTree == 0)
240   {
241     if (fgAssertESD)
242     {
243       throw (kEH + "ESD not initialized. Its precence was requested.");
244     } else {
245       Warning(kEH, "ESD not initialized.");
246     }
247   }
248
249   // Open RunLoader from galice.root
250
251   TString gaPath(Form("%s/galice.root", fPath.Data()));
252   // If i use open directly, we get fatal.
253   // Is AccessPathName check ok for xrootd / alien? Yes, not for http.
254   if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
255   {
256     fRunLoader = AliRunLoader::Open(gaPath);
257     if (fRunLoader)
258     {
259       TString alicePath = fPath + "/";
260       fRunLoader->SetDirName(alicePath);
261
262       if (fRunLoader->LoadgAlice() != 0)
263         Warning(kEH, "failed loading gAlice via run-loader.");
264
265       if (fRunLoader->LoadHeader() == 0)
266       {
267         if (runNo < 0)
268           runNo = fRunLoader->GetHeader()->GetRun();
269       }
270       else
271       {
272         Warning(kEH, "failed loading run-loader's header.");
273         delete fRunLoader;
274         fRunLoader = 0;
275       }
276     }
277     else // run-loader open failed
278     {
279       Warning(kEH, "failed opening ALICE run-loader from '%s'.", gaPath.Data());
280     }
281   }
282   else // galice not readable
283   {
284     Warning(kEH, "can not read '%s'.", gaPath.Data());
285   }
286   if (fRunLoader == 0)
287   {
288     if (fgAssertRunLoader)
289       throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
290     else
291       Warning(kEH, "Bootstraping of run-loader failed.");
292   }
293
294   // Open raw-data file
295
296   TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
297   // If i use open directly, raw-reader reports an error but i have      
298   // no way to detect it.        
299   // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.    
300   if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)       
301   {
302     fRawReader = AliRawReader::Create(rawPath);
303   }
304   else
305   {
306     fRawReader = AliRawReader::Create(fgRawFileName);
307   }
308   if (fRawReader == 0)
309   {
310     if (fgAssertRaw)
311     {
312       throw (kEH + "raw-data not initialized. Its precence was requested.");
313     } else {
314       Warning(kEH, "raw-data not initialized.");
315     }
316   }
317
318   if (runNo < 0)
319   {
320     if (fRawReader)
321     {
322       fRawReader->NextEvent();
323       runNo = fRawReader->GetRunNumber();
324       Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
325       fRawReader->RewindEvents();
326     } else {
327       throw (kEH + "unknown run number.");
328     }
329   }
330
331   {
332     AliCDBManager* cdb = AliCDBManager::Instance();
333     cdb->SetDefaultStorage(fgCdbUri);
334     if (cdb->IsDefaultStorageSet() == kFALSE)
335       throw (kEH + "CDB initialization failed.");
336     cdb->SetRun(runNo);
337   }
338
339   SetName(Form("Event %d", fEventId));
340   SetTitle(fPath);
341   fIsOpen = kTRUE;
342 }
343
344 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd)
345 {
346   // Set an event from an external source
347   // The method is used in the online visualisation
348
349   static const TEveException kEH("AliEveEventManager::SetEvent ");
350
351   if (fIsOpen)
352   {
353     Warning(kEH, "Event-files were open. Closing and switching to external control.");
354     Close();
355   }
356
357   fRunLoader = runLoader;
358   fRawReader = rawReader;
359   fESD       = esd;
360
361   fEventId++;
362   fHasEvent     = kTRUE;
363   fExternalCtrl = kTRUE;
364
365   SetTitle("Online event in memory");
366   SetName ("Online Event");
367
368   ElementChanged();
369   AfterNewEventLoaded();
370 }
371
372 Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
373 {
374   // Returns maximum available event id.
375   // If under external control or event is not opened -1 is returned.
376   // If raw-data is the only data-source this can not be known
377   // and 10,000,000 is returned.
378   // If neither data-source is initialised an exception is thrown.
379   // If refresh_esd is true and ESD is the primary event-data source
380   // its header is re-read from disk.
381
382   static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
383
384   if (fExternalCtrl || fIsOpen == kFALSE)
385   {
386     return -1;
387   }
388
389   if (fESDTree)
390   {
391     // Refresh crashes with root-5.21.1-alice.
392     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
393     // when we move to a newer root.
394     // if (refreshESD)
395     //   fESDTree->Refresh();
396     return fESDTree->GetEntries() - 1;
397   }
398   else if (fRunLoader)
399   {
400     return fRunLoader->GetNumberOfEvents() - 1;
401   }
402   else if (fRawReader)
403   {
404     Int_t n = fRawReader->GetNumberOfEvents() - 1;
405     return n > -1 ? n : 10000000;
406   }
407   else
408   {
409     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
410   }
411 }
412
413 void AliEveEventManager::GotoEvent(Int_t event)
414 {
415   // Load data for specified event.
416   // If event is out of range an exception is thrown and old state
417   // is preserved.
418   // After successful loading of event, the virtual function
419   // AfterNewEventLoaded() is called. This executes commands that
420   // were registered via TEveEventManager::AddNewEventCommand().
421   //
422   // If event is negative, it is subtracted from the number of
423   // available events, thus passing -1 will load the last event.
424   // This is not supported when raw-data is the only data-source
425   // as the number of events is not known.
426
427   static const TEveException kEH("AliEveEventManager::GotoEvent ");
428
429   if (fExternalCtrl)
430   {
431     throw (kEH + "Event-loop is under external control.");
432   }
433   if (!fIsOpen)
434   {
435     throw (kEH + "Event-files not opened.");
436   }
437
438   fHasEvent = kFALSE;
439
440   Int_t maxEvent = 0;
441   if (fESDTree)
442   {
443     // Refresh crashes with root-5.21.1-alice.
444     // Fixed by Philippe 5.8.2008 r25053, can be reactivated
445     // when we move to a newer root.
446     // fESDTree->Refresh();
447     maxEvent = fESDTree->GetEntries() - 1;
448     if (event < 0)
449       event = fESDTree->GetEntries() + event;
450   }
451   else if (fRunLoader)
452   {
453     maxEvent = fRunLoader->GetNumberOfEvents() - 1;
454     if (event < 0)
455       event = fRunLoader->GetNumberOfEvents() + event;
456   }
457   else if (fRawReader)
458   {
459     maxEvent = fRawReader->GetNumberOfEvents() - 1;
460     if (maxEvent < 0)
461     {
462       maxEvent = 10000000;
463       if (event < 0) {
464         Error(kEH, "current raw-data source does not support direct event access.");
465         return;
466       }
467       Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
468     }
469     else
470     {
471       if (event < 0)
472         event = fRawReader->GetNumberOfEvents() + event;
473     }
474   }
475   else
476   {
477     throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
478   }
479   if (event < 0 || event > maxEvent)
480   {
481     throw (kEH + Form("event %d not present, available range [%d, %d].",
482                       event, 0, maxEvent));
483   }
484
485   TEveManager::TRedrawDisabler rd(gEve);
486   gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
487
488   // !!! MT this is somewhat brutal; at least optionally, one could be
489   // a bit gentler, checking for objs owning their external refs and having
490   // additinal parents.
491   DestroyElements();
492
493   if (fESDTree) {
494     if (fESDTree->GetEntry(event) <= 0)
495       throw (kEH + "failed getting required event from ESD.");
496
497     if (fESDfriendExists)
498       fESD->SetESDfriend(fESDfriend);
499   }
500
501   if (fRunLoader) {
502     if (fRunLoader->GetEvent(event) != 0)
503       throw (kEH + "failed getting required event.");
504   }
505
506   if (fRawReader)
507   {
508     // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
509     if (fRawReader->GotoEvent(event) == kFALSE)
510     {
511       // Use fallback method - iteration with NextEvent().
512       Int_t rawEv = fEventId;
513       if (event < rawEv)
514       {
515         fRawReader->RewindEvents();
516         rawEv = -1;
517       }
518
519       while (rawEv < event)
520       {
521         if ( ! fRawReader->NextEvent())
522         {
523           fRawReader->RewindEvents();
524           fEventId = -1;
525           throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
526         }
527         ++rawEv;
528       }
529       Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
530     }
531   }
532
533   fHasEvent = kTRUE;
534   fEventId  = event;
535   SetName(Form("Event %d", fEventId));
536   ElementChanged();
537
538   AfterNewEventLoaded();
539 }
540
541 void AliEveEventManager::NextEvent()
542 {
543   // Loads next event.
544   // Does magick needed for online display when under external event control.
545   
546   if (fExternalCtrl)
547   {
548     if (fAutoLoadTimer) fAutoLoadTimer->Stop();
549
550     DestroyElements();
551
552     gSystem->ExitLoop();
553   }
554   else
555   {
556     if (fEventId < GetMaxEventId(kTRUE))
557       GotoEvent(fEventId + 1);
558     else
559       GotoEvent(0);
560     StartStopAutoLoadTimer();
561   }
562 }
563
564 void AliEveEventManager::PrevEvent()
565 {
566   // Loads previous event.
567
568   static const TEveException kEH("AliEveEventManager::PrevEvent ");
569
570   if (fExternalCtrl)
571   {
572     throw (kEH + "Event-loop is under external control.");
573   }
574   if (!fIsOpen)
575   {
576     throw (kEH + "Event-files not opened.");
577   }
578
579   GotoEvent(fEventId - 1);
580   StartStopAutoLoadTimer();
581 }
582
583 void AliEveEventManager::Close()
584 {
585   // Close the event data-files and delete ESD, ESDfriend, run-loader
586   // and raw-reader.
587
588   static const TEveException kEH("AliEveEventManager::Close ");
589
590   if (!fIsOpen)
591   {
592     throw (kEH + "Event-files not opened.");
593   }
594
595   if (fESDTree) {
596     delete fESD;       fESD       = 0;
597     delete fESDfriend; fESDfriend = 0;
598
599     delete fESDTree;   fESDTree = 0;
600     delete fESDFile;   fESDFile = 0;
601   }
602
603   if (fRunLoader) {
604     delete fRunLoader; fRunLoader = 0;
605   }
606
607   if (fRawReader) {
608     delete fRawReader; fRawReader = 0;
609   }
610
611   fEventId  = -1;
612   fIsOpen   = kFALSE;
613   fHasEvent = kFALSE;
614 }
615
616
617 //------------------------------------------------------------------------------
618 // Static convenience functions, mainly used from macros.
619 //------------------------------------------------------------------------------
620
621 Bool_t AliEveEventManager::HasRunLoader()
622 {
623   // Check if AliRunLoader is initialized.
624
625   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRunLoader;
626 }
627
628 Bool_t AliEveEventManager::HasESD()
629 {
630   // Check if AliESDEvent is initialized.
631
632   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESD;
633 }
634
635 Bool_t AliEveEventManager::HasESDfriend()
636 {
637   // Check if AliESDfriend is initialized.
638
639   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESDfriend;
640 }
641
642 Bool_t AliEveEventManager::HasRawReader()
643 {
644   // Check if raw-reader is initialized.
645
646   return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRawReader;
647 }
648
649 AliRunLoader* AliEveEventManager::AssertRunLoader()
650 {
651   // Make sure AliRunLoader is initialized and return it.
652   // Throws exception in case run-loader is not available.
653   // Static utility for macros.
654
655   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
656
657   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
658     throw (kEH + "ALICE event not ready.");
659   if (gAliEveEvent->fRunLoader == 0)
660     throw (kEH + "AliRunLoader not initialised.");
661   return gAliEveEvent->fRunLoader;
662 }
663
664 AliESDEvent* AliEveEventManager::AssertESD()
665 {
666   // Make sure AliESDEvent is initialized and return it.
667   // Throws exception in case ESD is not available.
668   // Static utility for macros.
669
670   static const TEveException kEH("AliEveEventManager::AssertESD ");
671
672   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
673     throw (kEH + "ALICE event not ready.");
674   if (gAliEveEvent->fESD == 0)
675     throw (kEH + "AliESD not initialised.");
676   return gAliEveEvent->fESD;
677 }
678
679 AliESDfriend* AliEveEventManager::AssertESDfriend()
680 {
681   // Make sure AliESDfriend is initialized and return it.
682   // Throws exception in case ESDfriend-loader is not available.
683   // Static utility for macros.
684
685   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
686
687   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
688     throw (kEH + "ALICE event not ready.");
689   if (gAliEveEvent->fESDfriend == 0)
690     throw (kEH + "AliESDfriend not initialised.");
691   return gAliEveEvent->fESDfriend;
692 }
693
694 AliRawReader* AliEveEventManager::AssertRawReader()
695 {
696   // Make sure raw-reader is initialized and return it.
697
698   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
699
700   if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
701     throw (kEH + "ALICE event not ready.");
702   if (gAliEveEvent->fRawReader == 0)
703     throw (kEH + "RawReader not ready.");
704
705   return gAliEveEvent->fRawReader;
706 }
707
708 AliMagF* AliEveEventManager::AssertMagField()
709 {
710   // Make sure AliMagF is initialized and returns it.
711   // Run-loader must be initialized to get the correct magnetic field!
712   // Throws exception in case magnetic field is not available.
713   // Static utility for macros.
714
715   // !!!! This should be fixed ... get field also in some other way,
716   // not only via run-loader.
717
718   if (fgMagField == 0)
719   {
720     if (gAliEveEvent && gAliEveEvent->fRunLoader && gAliEveEvent->fRunLoader->GetAliRun())
721       fgMagField = gAliEveEvent->fRunLoader->GetAliRun()->Field();
722     else
723       fgMagField = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
724   }
725   return fgMagField;
726 }
727
728 TGeoManager* AliEveEventManager::AssertGeometry()
729 {
730   // Make sure AliGeomManager is initialized and returns the
731   // corresponding TGeoManger.
732   // gGeoManager is set to the return value.
733   // Throws exception if geometry can not be loaded or if it is not
734   // available and the TGeoManager is locked.
735   // Static utility for macros.
736
737   static const TEveException kEH("AliEveEventManager::AssertGeometry ");
738
739   if (AliGeomManager::GetGeometry() == 0)
740   {
741     if (TGeoManager::IsLocked())
742       throw (kEH + "geometry is not loaded but TGeoManager is locked.");
743
744     gGeoManager = 0;
745     AliGeomManager::LoadGeometry();
746     if ( ! AliGeomManager::GetGeometry())
747     {
748       throw (kEH + "can not load geometry.");
749     }
750     if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
751     {
752       ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
753       // throw (kEH + "could not apply align objs.");
754     }
755     AliGeomManager::GetGeometry()->DefaultColors();
756   }
757
758   gGeoManager = AliGeomManager::GetGeometry();
759   return gGeoManager;
760 }
761
762
763 //------------------------------------------------------------------------------
764 // Autoloading
765 //------------------------------------------------------------------------------
766
767 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
768 {
769   // Set the automatic event loading mode
770
771   fAutoLoad = autoLoad;
772   StartStopAutoLoadTimer();
773 }
774
775 void AliEveEventManager::SetAutoLoadTime(Double_t time)
776 {
777   // Set the auto-load time in seconds
778
779   fAutoLoadTime = time;
780   StartStopAutoLoadTimer();
781 }
782
783 void AliEveEventManager::StartStopAutoLoadTimer()
784 {
785   // Create if needed and start
786   // the automatic event loading timer
787
788   if (fAutoLoad)
789   {
790     if (!fAutoLoadTimer)
791     {
792       fAutoLoadTimer = new TTimer;
793       fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "NextEvent()");
794     }
795     fAutoLoadTimer->Start((Long_t)fAutoLoadTime*1000, kTRUE);
796   }
797   else
798   {
799     if (fAutoLoadTimer) fAutoLoadTimer->Stop();
800   }
801 }
802
803
804 //------------------------------------------------------------------------------
805 // Post event-loading functions
806 //------------------------------------------------------------------------------
807
808 void AliEveEventManager::AfterNewEventLoaded()
809 {
810   // Execute registered macros and commands.
811   // At the end emit NewEventLoaded signal.
812   //
813   // Virtual from TEveEventManager.
814
815   if (fExecutor)
816     fExecutor->ExecMacros();
817
818   TEveEventManager::AfterNewEventLoaded();
819
820   NewEventLoaded();
821 }
822
823 void AliEveEventManager::NewEventLoaded()
824 {
825   // Emit NewEventLoaded signal.
826
827   Emit("NewEventLoaded()");
828 }
829
830
831 //------------------------------------------------------------------------------
832 // Event info dumpers
833 //------------------------------------------------------------------------------
834
835 TString AliEveEventManager::GetEventInfoHorizontal() const
836 {
837   // Dumps the event-header contents in vertical formatting.
838
839   TString rawInfo, esdInfo;
840
841   if (!fRawReader)
842   {
843     rawInfo = "No raw-data event info is available!\n";
844   }
845   else
846   {
847     const UInt_t* attr = fRawReader->GetAttributes();
848     TTimeStamp ts(fRawReader->GetTimestamp());
849     rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
850                  "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
851                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
852                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
853                  fRawReader->GetClassMask(),
854                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
855                  attr[0],attr[1],attr[2], ts.AsString("s"));
856   }
857
858   if (!fESD)
859   {
860     esdInfo = "No ESD event info is available!";
861   }
862   else
863   {
864     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
865     TString firedtrclasses = fESD->GetFiredTriggerClasses();
866     TTimeStamp ts(fESD->GetTimeStamp());
867     esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
868                  "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s",
869                  fESD->GetRunNumber(),
870                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
871                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
872                  acttrclasses.Data(),
873                  fESD->GetTriggerMask(),firedtrclasses.Data(),
874                  fESD->GetEventNumberInFile(), ts.AsString("s"));
875   }
876
877   return rawInfo + esdInfo;
878 }
879
880 TString AliEveEventManager::GetEventInfoVertical() const
881 {
882   // Dumps the event-header contents in vertical formatting.
883
884   TString rawInfo, esdInfo;
885
886   if (!fRawReader)
887   {
888     rawInfo = "No raw-data event info is available!\n";
889   }
890   else
891   {
892     const UInt_t* attr = fRawReader->GetAttributes();
893     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",
894                  fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
895                  fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
896                  fRawReader->GetClassMask(),
897                  *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
898                  attr[0],attr[1],attr[2],
899                  fRawReader->GetTimestamp());
900   }
901
902   if (!fESD)
903   {
904     esdInfo = "No ESD event info is available!\n";
905   }
906   else
907   {
908     TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
909     TString firedtrclasses = fESD->GetFiredTriggerClasses();
910     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",
911                  fESD->GetRunNumber(),
912                  acttrclasses.Data(),
913                  fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
914                  fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
915                  fESD->GetTriggerMask(),firedtrclasses.Data(),
916                  fESD->GetEventNumberInFile(),
917                  fESD->GetTimeStamp());
918   }
919
920   return rawInfo + "\n" + esdInfo;
921 }
922