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