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