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