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