Fixed bug in AliEveEventManager causing frequent crashes. Fixed bug in Storage Manage...
[u/mrichter/AliRoot.git] / EVE / EveBase / AliEveEventManager.cxx
1 // $Id: AliEveEventManager.cxx 64557 2013-10-16 20:03:08Z hristov $
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 "AliEveConfigManager.h"
14 #include "AliEveVSDCreator.h"
15
16 #include <THashList.h>
17 #include <TEveElement.h>
18 #include <TEveManager.h>
19 #include <TEveViewer.h>
20
21 #include <AliLog.h>
22 #include <AliRunLoader.h>
23 #include <AliRun.h>
24 #include <AliESDRun.h>
25 #include <AliESDEvent.h>
26 #include <AliESDfriend.h>
27 #include <AliAODEvent.h>
28
29 #include <AliRecoParam.h>
30 #include <AliCentralTrigger.h>
31 #include <AliCDBEntry.h>
32 #include <AliTriggerClass.h>
33 #include <AliTriggerConfiguration.h>
34 #include <AliTriggerCluster.h>
35 #include <AliDetectorRecoParam.h>
36
37 #include <AliDAQ.h>
38 #include <AliRawEventHeaderBase.h>
39 #include <AliRawReaderRoot.h>
40 #include <AliRawReaderFile.h>
41 #include <AliRawReaderDate.h>
42 #include <AliMagF.h>
43 #include <AliCDBManager.h>
44 #include <AliCDBStorage.h>
45 #include <AliGRPObject.h>
46 #include <AliHeader.h>
47 #include <AliGeomManager.h>
48 #include <AliGRPManager.h>
49 #include <AliSysInfo.h>
50
51 #include <TFile.h>
52 #include <TTree.h>
53 #include <TGeoManager.h>
54 #include <TGeoGlobalMagField.h>
55 #include <TSystem.h>
56 #include <TTimeStamp.h>
57 #include <TPRegexp.h>
58 #include <TError.h>
59 #include <TEnv.h>
60 #include <TString.h>
61 #include <TMap.h>
62 #include <TROOT.h>
63
64 #ifdef ZMQ
65 #include "AliStorageEventManager.h"
66 #endif
67
68 using std::cout;
69 using std::endl;
70 using std::vector;
71 //==============================================================================
72 //==============================================================================
73 // AliEveEventManager
74 //==============================================================================
75
76 //______________________________________________________________________________
77 //
78 // Provides interface for loading and navigating standard AliRoot data
79 // (AliRunLoader), ESD, AOD and RAW.
80 //
81 // ESDfriend is attached automatically, if the file is found.
82 //
83 // AODfriends are not attached automatically as there are several
84 // possible files involved. To have a specific AODfriend attached, call
85 // static method
86 //   AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
87 // before initializing the event-manager.
88 //
89 // Also provides interface to magnetic-field and geometry. Mostly
90 // intended as wrappers over standard AliRoot functionality for
91 // convenient use from visualizateion macros.
92 //
93 // There can be a single main event-manger, it is stored in private
94 // data member fgMaster and can be accessed via static member function
95 // GetMaster().
96 //
97 // For event overlaying and embedding one can instantiate additional
98 // event-managers via static method AddDependentManager(const TString& path).
99 // This interface is under development.
100
101 ClassImp(AliEveEventManager)
102
103 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
104 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
105 Bool_t AliEveEventManager::fgAssertAOD       = kFALSE;
106 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
107
108 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
109 AliEveEventManager::EVisibleESDTrees  AliEveEventManager::fgESDvisibleTrees(AliEveEventManager::kOfflineTree);
110 TString  AliEveEventManager::fgESDfriendsFileName("AliESDfriends.root");
111 TString  AliEveEventManager::fgAODFileName("AliAOD.root");
112 TString  AliEveEventManager::fgGAliceFileName("galice.root");
113 TString  AliEveEventManager::fgRawFileName("raw.root");
114 TString  AliEveEventManager::fgCdbUri;
115
116 TList*   AliEveEventManager::fgAODfriends = 0;
117
118 Bool_t   AliEveEventManager::fgRawFromStandardLoc = kFALSE;
119
120 Bool_t   AliEveEventManager::fgGRPLoaded    = kFALSE;
121 AliMagF* AliEveEventManager::fgMagField     = 0;
122 AliRecoParam* AliEveEventManager::fgRecoParam = 0;
123 Bool_t   AliEveEventManager::fgUniformField = kFALSE;
124
125 AliEveEventManager* AliEveEventManager::fgMaster  = 0;
126 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
127
128 AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
129     TEveEventManager(name, ""),
130     fEventId(-1),
131     fRunLoader (0),
132     fESDFile   (0), fESDTree (0), fHLTESDTree(0), fESD (0),
133     fESDfriend (0), fESDfriendExists(kFALSE),
134     fAODFile   (0), fAODTree (0), fAOD (0),
135     fRawReader (0), fEventInfo(),
136     fAutoLoad  (kFALSE),fLoopMarked(kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
137     fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
138     fGlobal    (0), fGlobalReplace (kTRUE), fGlobalUpdate (kTRUE),
139     fExecutor    (0), fTransients(0), fTransientLists(0),
140     fPEventSelector(0),
141     fSubManagers (0),
142     fAutoLoadTimerRunning(kFALSE),
143     fMutex(new TMutex()),
144     fgSubSock(EVENTS_SERVER_SUB),
145     fEventInUse(1),
146     fWritingToEventIndex(0),
147     fIsNewEventAvaliable(false),
148     fStorageDown(false),
149     fFinished(false)
150 {
151     // Constructor with event-id.
152                 
153     InitInternals();
154
155     Open();
156     if (ev >= 0)
157     {
158         GotoEvent(ev);
159     }
160     
161     if (0 == name.CompareTo("online")) {
162       fOnlineMode = kTRUE;
163     }
164     else{
165       fOnlineMode = kFALSE;
166     }
167
168
169 #ifdef ZMQ
170     cout<<"ZMQ FOUND. Starting subscriber thread."<<endl;
171     fEventListenerThread = new TThread("fEventListenerThread",DispatchEventListener,(void*)this);
172     fEventListenerThread->Run();
173     
174     fStorageManagerWatcherThread = new TThread("fStorageManagerWatcherThread",DispatchStorageManagerWatcher,(void*)this);
175     fStorageManagerWatcherThread->Run();
176 #else
177     cout<<"NO ZMQ FOUND. Online events not avaliable."<<endl;
178 #endif
179 }
180
181 AliEveEventManager::~AliEveEventManager()
182 {
183     // Destructor.
184     
185     fFinished = true;
186     
187     if(fEventListenerThread)
188     {
189         fEventListenerThread->Kill();
190         delete fEventListenerThread;
191     }
192     if(fStorageManagerWatcherThread)
193     {
194         fStorageManagerWatcherThread->Kill();
195         delete fStorageManagerWatcherThread;
196     }
197     
198     
199     fAutoLoadTimer->Stop();
200     fAutoLoadTimer->Disconnect("Timeout");
201     fAutoLoadTimer->Disconnect("AutoLoadNextEvent");
202
203     AliEveEventManager *manager = AliEveEventManager::GetCurrent();
204     manager->Disconnect("StorageManagerOk");
205     manager->Disconnect("StorageManagerDown");
206
207     if(fSubManagers){delete fSubManagers;}
208     if(fMutex){delete fMutex;}
209     
210     if (fIsOpen)
211     {
212         Close();
213     }
214
215 //    fTransients->DecDenyDestroy();
216 //    fTransients->Destroy();
217
218 //    fTransientLists->DecDenyDestroy();
219 //    fTransientLists->Destroy();
220
221     //delete fExecutor;
222 }
223
224 void AliEveEventManager::GetNextEvent()
225 {
226 #ifdef ZMQ
227     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
228     eventManager->CreateSocket(EVENTS_SERVER_SUB);
229     eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
230     
231     fCurrentEvent[0]=0;
232     fCurrentEvent[1]=0;
233
234     AliESDEvent *tmpEvent = NULL;
235     
236     // get list of marked events:
237     struct listRequestStruct list;
238
239     list.runNumber[0]=0;
240     list.runNumber[1]=999999;
241     list.eventNumber[0]=0;
242     list.eventNumber[1]=999999;
243     list.marked[0]=1;
244     list.marked[1]=1;
245     list.multiplicity[0]=1;
246     list.multiplicity[1]=999999;
247     strcpy(list.system[0],"p-p");
248     strcpy(list.system[1],"A-A");
249     
250     struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
251     requestMessage->messageType = REQUEST_LIST_EVENTS;
252     requestMessage->list = list;
253     
254     eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
255     vector<serverListStruct> receivedList = eventManager->GetServerListVector(SERVER_COMMUNICATION_REQ);
256     
257     cout<<"EVENT DISPLAY -- received list of marked events"<<endl;
258     
259     for(int i=0;i<receivedList.size();i++)
260     {
261         cout<<"ev:"<<receivedList[i].eventNumber<<endl;
262     }
263     
264     int iter=0;
265     while(!fFinished)
266     {
267         if(!fLoopMarked)
268         {
269             cout<<"taking event from reco server"<<endl;
270             tmpEvent = eventManager->GetEvent(EVENTS_SERVER_SUB,5);
271             if(!tmpEvent){sleep(1);}
272         }
273         else
274         {
275             cout<<"taking event from storage manager"<<endl;
276             if(iter<receivedList.size())
277             {
278                 cout<<"i:"<<iter<<endl;
279                 struct eventStruct mark;
280                 mark.runNumber = receivedList[iter].runNumber;
281                 mark.eventNumber = receivedList[iter].eventNumber;
282              
283                 requestMessage->messageType = REQUEST_GET_EVENT;
284                 requestMessage->event = mark;
285                 
286                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
287                 tmpEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
288
289                 iter++;
290                 sleep(1);
291             }
292             else{iter=0;}
293         }
294         
295         if(tmpEvent)
296         {
297             if(tmpEvent->GetRunNumber()>=0)
298             {
299                 fMutex->Lock();
300                 if(fEventInUse == 0){fWritingToEventIndex = 1;}
301                 else if(fEventInUse == 1){fWritingToEventIndex = 0;}
302                 cout<<"Received new event:"<<tmpEvent->GetEventNumberInFile()<<endl;
303                 if(fCurrentEvent[fWritingToEventIndex])
304                 {
305                     delete fCurrentEvent[fWritingToEventIndex];
306                     fCurrentEvent[fWritingToEventIndex]=0;
307                 }
308                 fCurrentEvent[fWritingToEventIndex] = tmpEvent;
309                 fIsNewEventAvaliable = true;
310                 NewEventLoaded();
311                 fMutex->UnLock();
312             }
313         }
314         else{cout<<"didn't receive new event"<<endl;}
315     }
316     delete requestMessage;
317     
318 #endif
319 }
320
321 void AliEveEventManager::CheckStorageStatus()
322 {
323 #ifdef ZMQ
324     AliEveConfigManager *configManager = AliEveConfigManager::GetMaster();
325     configManager->ConnectEventManagerSignals();
326     
327     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
328     eventManager->CreateSocket(CLIENT_COMMUNICATION_REQ);
329     
330     struct clientRequestStruct *request = new struct clientRequestStruct;
331     request->messageType = REQUEST_CONNECTION;
332     
333     while (!fFinished)
334     {
335         if(eventManager->Send(request,CLIENT_COMMUNICATION_REQ,5000))
336         {
337             StorageManagerOk();
338             long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
339             fStorageDown = kFALSE;
340         }
341         else
342         {
343             StorageManagerDown();
344             cout<<"WARNING -- Storage Manager is DOWN!!"<<endl;
345             fStorageDown = kTRUE;
346         }
347         sleep(1);
348     }
349 #endif
350 }
351
352 void AliEveEventManager::InitInternals()
353 {
354     // Initialize internal members.
355     
356     static const TEveException kEH("AliEveEventManager::InitInternals ");
357     
358     if (fgCurrent != 0)
359     {
360         throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
361     }
362     
363     if (fgMaster == 0)
364     {
365         fgMaster = this;
366     }
367     
368     fgCurrent = this;
369     
370     fAutoLoadTimer = new TTimer;
371     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
372     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "Timeout()");
373     
374     fExecutor = new AliEveMacroExecutor;
375     
376     fTransients = new TEveElementList("Transients", "Transient per-event elements.");
377     fTransients->IncDenyDestroy();
378     gEve->AddToListTree(fTransients, kFALSE);
379     
380     fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
381     fTransientLists->IncDenyDestroy();
382     gEve->AddToListTree(fTransientLists, kFALSE);
383     
384     fPEventSelector = new AliEveEventSelector(this);
385     
386     fGlobal = new TMap; fGlobal->SetOwnerKeyValue();
387 }
388
389 /******************************************************************************/
390
391 void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
392 {
393     fgESDvisibleTrees = shown;
394     // Set file-name for opening ESD, default "AliESDs.root".
395     if (esd.IsNull()) return;
396
397     fgESDFileName = esd;
398     if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
399
400 }
401
402 void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
403 {
404     // Set file-name for opening ESD friend, default "AliESDfriends.root".
405
406     if (esdf.IsNull()) return;
407     fgESDfriendsFileName = esdf;
408     
409     if (esdf.EndsWith(".zip")) fgESDfriendsFileName.Form("%s#AliESDfriends.root",esdf.Data());
410 }
411
412 void AliEveEventManager::SetAODFileName(const TString& aod)
413 {
414     // Set file-name for opening AOD, default "AliAOD.root".
415
416     if (aod.IsNull()) return;
417     fgAODFileName = aod;
418     
419     if (aod.EndsWith(".zip")) fgAODFileName.Form("%s#AliAOD.root",aod.Data());
420     
421 }
422
423 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
424 {
425     // Add new AOD friend file-name to be attached when opening AOD.
426     // This should include '.root', as in 'AliAOD.VertexingHF.root'.
427
428     if (fgAODfriends == 0)
429     {
430         fgAODfriends = new TList;
431         fgAODfriends->SetOwner(kTRUE);
432     }
433     if (fgAODfriends->FindObject(friendFileName) == 0)
434     {
435         fgAODfriends->Add(new TObjString(friendFileName));
436     }
437 }
438
439 void AliEveEventManager::SetRawFileName(const TString& raw)
440 {
441     // Set file-name for opening of raw-data, default "raw.root"
442     if (raw.IsNull()) return;
443     
444     fgRawFileName = raw;
445 }
446
447 void AliEveEventManager::SetCdbUri(const TString& cdb)
448 {
449     // Set path to CDB, there is no default.
450     if ( ! cdb.IsNull()) fgCdbUri = cdb;
451 }
452
453 void AliEveEventManager::SetGAliceFileName(const TString& galice)
454 {
455     // Set file-name for opening gAlice, default "galice.root".
456
457     if ( galice.IsNull()) return;
458     fgGAliceFileName = galice;
459     
460     if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
461 }
462
463 void AliEveEventManager::SetFilesPath(const TString& urlPath)
464 {
465     TString path = urlPath;
466     gSystem->ExpandPathName(path);
467     if (path.IsNull() || path == ".")
468     {
469         path = gSystem->WorkingDirectory();
470     }
471
472     TString sep;
473     if(path.EndsWith(".zip")) // if given a path to root_archive.zip
474         sep= "#";
475     else if(!path.EndsWith("/"))
476         sep = "/";
477     
478     SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
479     SetESDfriendFileName(  TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
480     SetAODFileName(  TString(Form("%s%sAliAOD.root", path.Data(), sep.Data())) );
481     AddAODfriend(  TString(Form("%s%sAliAOD.VertexingHF.root", path.Data(), sep.Data())) );
482     SetGAliceFileName( TString(Form("%s%sgalice.root", path.Data(), sep.Data())) );
483     SetRawFileName(TString(Form("%s%sraw.root", path.Data(), sep.Data())));
484 }
485
486 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
487                                            Bool_t assertAod, Bool_t assertRaw)
488 {
489     // Set global flags that detrmine which parts of the event-data must
490     // be present when the event is opened.
491
492     fgAssertRunLoader = assertRunloader;
493     fgAssertESD = assertEsd;
494     fgAssertAOD = assertAod;
495     fgAssertRaw = assertRaw;
496 }
497
498 void AliEveEventManager::SearchRawForCentralReconstruction()
499 {
500     // Enable searching of raw data in standard location. The path passed to
501     // Open() is expected to point to a centrally reconstructed run, e.g.:
502     // "alien:///alice/data/2009/LHC09c/000101134/ESDs/pass1/09000101134018.10".
503
504     fgRawFromStandardLoc = kTRUE;
505 }
506
507 /******************************************************************************/
508
509 void AliEveEventManager::Open()
510 {
511     // Open event-data from URL specified in path.
512     // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
513     // Warning is reported if run-loader or ESD is not found.
514     // Global data-members fgAssertRunLoader and fgAssertESD can be set
515     // to throw exceptions instead.
516
517     static const TEveException kEH("AliEveEventManager::Open ");
518
519     if (fExternalCtrl)
520     {
521         throw (kEH + "Event-loop is under external control.");
522     }
523     if (fIsOpen)
524     {
525         throw (kEH + "Event-files already opened.");
526     }
527
528     Int_t runNo = -1;
529
530     // Open ESD and ESDfriends
531     
532     if ((fESDFile = TFile::Open(fgESDFileName)))
533     {
534         fESD = new AliESDEvent();
535
536         switch(fgESDvisibleTrees){
537         case AliEveEventManager::kOfflineTree :
538             fESDTree = readESDTree("esdTree", runNo);
539             break;
540         case AliEveEventManager::kHLTTree :
541             fHLTESDTree = readESDTree("HLTesdTree", runNo);
542             break;
543         default:
544             fESDTree    = readESDTree("esdTree", runNo);
545             fHLTESDTree = readESDTree("HLTesdTree", runNo);
546         }
547
548         if(!fESDTree && !fHLTESDTree){
549             // both ESD trees are == 0
550             delete fESDFile; fESDFile = 0;
551             delete fESD; fESD = 0;
552         }
553
554
555     }
556     else // esd file not readable
557     {
558         Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
559     }
560     if (fESDTree == 0 && fHLTESDTree==0)
561     {
562         if (fgAssertESD)
563         {
564             throw (kEH + "ESD not initialized. Its precence was requested.");
565         } else {
566             Warning(kEH, "ESD not initialized.");
567         }
568     }
569
570     // Open AOD and registered friends
571     if ( (fAODFile = TFile::Open(fgAODFileName)) )
572     {
573         fAOD = new AliAODEvent();
574         fAODTree = (TTree*) fAODFile->Get("aodTree");
575         if (fAODTree != 0)
576         {
577             // Check if AODfriends exist and attach them.
578             TIter       friends(fgAODfriends);
579             TObjString *name;
580             while ((name = (TObjString*) friends()) != 0)
581             {
582                 TString p(Form("%s/%s", fgAODFileName.Data(), name->GetName()));
583                 if (fgAODFileName.EndsWith(".zip")) p.Form("%s#%s",fgAODFileName.Data(),name->GetName());
584                 if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
585                 {
586                     fAODTree->AddFriend("aodTree", name->GetName());
587                 }
588             }
589
590             fAOD->ReadFromTree(fAODTree);
591
592             if (fAODTree->GetEntry(0) <= 0)
593             {
594                 delete fAODFile; fAODFile = 0;
595                 delete fAOD;     fAOD     = 0;
596                 Warning(kEH, "failed getting the first entry from addTree.");
597             }
598             else
599             {
600                 if (runNo < 0)
601                     runNo = fAOD->GetRunNumber();
602             }
603         }
604         else // aodtree == 0
605         {
606             delete fAODFile; fAODFile = 0;
607             delete fAOD;     fAOD     = 0;
608             Warning(kEH, "failed getting the aodTree.");
609         }
610     }
611     else // aod not readable
612     {
613         Warning(kEH, "can not read AOD file '%s'.", fgAODFileName.Data());
614     }
615     if (fAODTree == 0)
616     {
617         if (fgAssertAOD)
618         {
619             throw (kEH + "AOD not initialized. Its precence was requested.");
620         } else {
621             Warning(kEH, "AOD not initialized.");
622         }
623     }
624
625     // Open RunLoader from galice.root
626 //    fgGAliceFileName = "/Users/Jerus/galice.root"; // temp
627     
628     TFile *gafile = TFile::Open(fgGAliceFileName);
629     cout<<"Opening galice"<<endl;
630     if (gafile)
631     {
632         gafile->Close();
633         delete gafile;
634         cout<<"SETTING RUN LOADER in Open()"<<endl;
635         fRunLoader = AliRunLoader::Open(fgGAliceFileName, GetName());
636         if (fRunLoader)
637         {
638             TString alicePath(gSystem->DirName(fgGAliceFileName));
639             alicePath.Append("/");
640             fRunLoader->SetDirName(alicePath);
641
642             if (fRunLoader->LoadgAlice() != 0)
643                 Warning(kEH, "failed loading gAlice via run-loader.");
644
645             if (fRunLoader->LoadHeader() == 0)
646             {
647                 if (runNo < 0)
648                     runNo = fRunLoader->GetHeader()->GetRun();
649             }
650             else
651             {
652                 Warning(kEH, "failed loading run-loader's header.");
653                 delete fRunLoader;
654                 fRunLoader = 0;
655             }
656         }
657         else // run-loader open failed
658         {
659             Warning(kEH, "failed opening ALICE run-loader from '%s'.", fgGAliceFileName.Data());
660         }
661         
662     }
663     else // galice not readable
664     {
665         Warning(kEH, "can not read '%s'.", fgGAliceFileName.Data());
666     }
667     if (fRunLoader == 0)
668     {
669         if (fgAssertRunLoader)
670             throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
671         else
672             Warning(kEH, "Bootstraping of run-loader failed.");
673     }
674
675     // Open raw-data file
676
677     TString rawPath;
678     if (fgRawFromStandardLoc)
679     {
680         if (!fgRawFileName.BeginsWith("alien:"))
681             throw kEH + "Standard raw search requested, but the directory is not in AliEn.";
682         if (!fgRawFileName.Contains("/ESDs/"))
683             throw kEH + "Standard raw search requested, but does not contain 'ESDs' directory.";
684
685         TPMERegexp chunk("/([\\d\\.])+/?$");
686         Int_t nm = chunk.Match(fgRawFileName);
687         if (nm != 2)
688             throw kEH + "Standard raw search requested, but the path does not end with chunk-id directory.";
689
690         TPMERegexp esdstrip("/ESDs/.*");
691         rawPath = fgRawFileName;
692         esdstrip.Substitute(rawPath, "/raw/");
693         rawPath += chunk[0];
694         rawPath += ".root";
695
696         Info(kEH, "Standard raw search requested, using the following path:\n  %s\n", rawPath.Data());
697     }
698     else
699     {
700         rawPath = fgRawFileName;
701     }
702     // If i use open directly, raw-reader reports an error but i have
703     // no way to detect it.
704     // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
705     AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
706     if (fgAssertRaw == kFALSE)
707     {
708         AliLog::SetGlobalLogLevel(AliLog::kFatal);
709     }
710     if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
711     {
712         fRawReader = AliRawReader::Create(rawPath);
713     }
714     else
715     {
716         fRawReader = AliRawReader::Create(fgRawFileName);
717     }
718     if (fgAssertRaw == kFALSE)
719     {
720         AliLog::SetGlobalLogLevel(oldLogLevel);
721     }
722
723     if (fRawReader == 0)
724     {
725         if (fgAssertRaw)
726         {
727             throw (kEH + "raw-data not initialized. Its precence was requested.");
728         }
729         else
730         {
731             Warning(kEH, "raw-data not initialized.");
732         }
733     }
734
735     if (runNo < 0)
736     {
737         if (fRawReader)
738         {
739             if ( ! fRawReader->NextEvent())
740             {
741                 throw (kEH + "can not go to first event in raw-reader to determine run-id.");
742             }
743             runNo = fRawReader->GetRunNumber();
744             Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
745             fRawReader->RewindEvents();
746         }
747         else
748         {
749             fExternalCtrl = kTRUE;
750              fEventId = 0;
751             return;
752         }
753     }
754
755     // Initialize OCDB ... only in master event-manager
756
757                 InitOCDB(runNo);
758
759
760     fIsOpen = kTRUE;
761 }
762
763 void AliEveEventManager::InitOCDB(int runNo)
764 {
765                 static const TEveException kEH("AliEveEventManager::InitOCDB ");
766     //if (this == fgMaster)
767     {
768         AliCDBManager* cdb = AliCDBManager::Instance();
769         if (cdb->IsDefaultStorageSet() == kTRUE)
770         {
771             Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
772                     cdb->GetDefaultStorage()->GetURI().Data());
773         }
774         else
775         {
776             if (fgCdbUri.IsNull())
777             {
778                 gEnv->SetValue("Root.Stacktrace", "no");
779                 Fatal("Open()", "OCDB path was not specified.");
780             }
781
782             // Handle some special cases for MC (should be in OCDBManager).
783             if (fgCdbUri == "mcideal://")
784                 cdb->SetDefaultStorage("MC", "Ideal");
785             else if (fgCdbUri == "mcresidual://")
786                 cdb->SetDefaultStorage("MC", "Residual");
787             else if (fgCdbUri == "mcfull://")
788                 cdb->SetDefaultStorage("MC", "Full");
789             else if (fgCdbUri == "local://") {
790                 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
791                 cdb->SetDefaultStorage(fgCdbUri);
792             } else
793                 cdb->SetDefaultStorage(fgCdbUri);
794
795             cdb->SetRun(runNo);
796
797             if (cdb->IsDefaultStorageSet() == kFALSE)
798                 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
799         }
800
801         if (fgCdbUri.BeginsWith("local://"))
802         {
803             TString curPath = gSystem->WorkingDirectory();
804             TString grp     = "GRP/GRP/Data";
805             TString grppath = curPath + "/" + grp;
806             if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
807             {
808                 if (cdb->GetSpecificStorage(grp))
809                 {
810                     Warning(kEH, "Local GRP exists, but the specific storage is already set.");
811                 }
812                 else
813                 {
814                     Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
815                     TString lpath("local://");
816                     lpath += curPath;
817                     cdb->SetSpecificStorage(grp, lpath);
818                 }
819             }
820         }
821     }
822 }
823
824 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
825 {
826     // Set an event from an external source.
827     // The method is used in the online visualisation.
828     // AOD is not supported.
829
830     static const TEveException kEH("AliEveEventManager::SetEvent ");
831
832     if (fIsOpen)
833     {
834         Warning(kEH, "Event-files were open. Closing and switching to external control.");
835         Close();
836     }
837
838                         Info(kEH,"setting it!!! ============================");
839
840     fRunLoader = runLoader;
841     fRawReader = rawReader;
842     fESD       = esd;
843     fESDfriend = esdf;
844     fAOD       = 0;
845
846     fEventId++;
847     fHasEvent     = kTRUE;
848     fExternalCtrl = kTRUE;
849
850     SetTitle("Online event in memory");
851     SetName ("Online Event");
852     ElementChanged();
853
854     AfterNewEventLoaded();
855
856     if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
857     
858 }
859
860 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
861 {
862     // Returns maximum available event id.
863     // If under external control or event is not opened -1 is returned.
864     // If raw-data is the only data-source this can not be known
865     // and 10,000,000 is returned.
866     // If neither data-source is initialised an exception is thrown.
867     // If refresh_esd is true and ESD is the primary event-data source
868     // its header is re-read from disk.
869
870     static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
871
872     if (fExternalCtrl || fIsOpen == kFALSE)
873     {
874         return -1;
875     }
876
877     if ((fESDTree!=0) || (fHLTESDTree!=0))
878     {
879         if (refreshESD)
880         {
881             if(fESDTree!=0) fESDTree->Refresh();
882             if(fHLTESDTree!=0) fHLTESDTree->Refresh();
883             fPEventSelector->Update();
884         }
885
886         Int_t maxEventId=0;
887         switch(fgESDvisibleTrees){
888         default:
889         case AliEveEventManager::kOfflineTree :
890             maxEventId = fESDTree->GetEntries() - 1;
891             break;
892         case AliEveEventManager::kHLTTree :
893             maxEventId = fHLTESDTree->GetEntries() - 1;
894             break;
895        }
896
897         return maxEventId;
898     }
899     else if (fAODTree)
900     {
901         return fAODTree->GetEntries() - 1;
902     }
903     else if (fRunLoader)
904     {
905         return fRunLoader->GetNumberOfEvents() - 1;
906     }
907     else if (fRawReader)
908     {
909         Int_t n = fRawReader->GetNumberOfEvents() - 1;
910         return n > -1 ? n : 10000000;
911     }
912     else
913     {
914         throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
915     }
916 }
917
918 void AliEveEventManager::GotoEvent(Int_t event)
919 {
920     cout<<"Go to event:"<<event<<endl;
921     // Load data for specified event.
922     // If event is out of range an exception is thrown and old state
923     // is preserved.
924     // After successful loading of event, the virtual function
925     // AfterNewEventLoaded() is called. This executes commands that
926     // were registered via TEveEventManager::AddNewEventCommand().
927     //
928     // If event is negative, it is subtracted from the number of
929     // available events, thus passing -1 will load the last event.
930     // This is not supported when raw-data is the only data-source
931     // as the number of events is not known.
932
933     static const TEveException kEH("AliEveEventManager::GotoEvent ");
934
935     if (fAutoLoadTimerRunning)
936     {
937         throw (kEH + "Event auto-load timer is running.");
938     }
939     if (fExternalCtrl)
940     {
941       // throw (kEH + "Event-loop is under external control.");
942 #ifdef ZMQ
943       if (fStorageDown && -1 == event) 
944       {
945         NextEvent();
946         return;
947       }
948
949       if (fESD)
950       {
951           // create new server request:
952           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
953             
954           // set request type:
955           if (event == -1)      {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
956           else  if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
957           else  if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
958           else  if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
959             
960           // set event struct:
961           struct eventStruct eventToLoad;
962           eventToLoad.runNumber = fESD->GetRunNumber();
963           eventToLoad.eventNumber = fESD->GetEventNumberInFile();
964           requestMessage->event = eventToLoad;
965             
966           // create event manager:
967           AliStorageEventManager *eventManager =
968             AliStorageEventManager::GetEventManagerInstance();
969           AliESDEvent *resultEvent = NULL;
970             
971           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
972           fMutex->Lock();
973             
974           // send request and receive event:
975           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
976           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
977             
978           if(resultEvent)
979           {
980               DestroyElements();
981               InitOCDB(resultEvent->GetRunNumber());
982               SetEvent(0,0,resultEvent,0);
983           }
984           else
985           {
986               if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
987               if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
988               if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
989               if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
990           }
991             
992           fMutex->UnLock();
993         }
994       else
995       {
996           cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
997
998           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
999           requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1000             
1001           AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1002           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1003           AliESDEvent *resultEvent = NULL;
1004             
1005           fMutex->Lock();
1006           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1007           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1008             
1009           if(resultEvent)
1010           {
1011               fESD=resultEvent;
1012               DestroyElements();
1013               InitOCDB(resultEvent->GetRunNumber());
1014               SetEvent(0,0,resultEvent,0);
1015           }
1016           else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1017           fMutex->UnLock();
1018       }
1019 #endif  
1020
1021     }
1022     else if (!fIsOpen)
1023     {
1024         throw (kEH + "Event-files not opened.");
1025     }
1026
1027     fEventInfo.Reset();
1028
1029     fHasEvent = kFALSE;
1030
1031     Int_t maxEvent = 0;
1032     if ((fESDTree!=0) || (fHLTESDTree!=0))
1033     {
1034         if(fESDTree){
1035             if (event >= fESDTree->GetEntries())
1036                 fESDTree->Refresh();
1037             maxEvent = fESDTree->GetEntries() - 1;
1038             if (event < 0)
1039                 event = fESDTree->GetEntries() + event;
1040         }
1041
1042         if(fHLTESDTree){
1043             if (event >= fHLTESDTree->GetEntries())
1044                 fHLTESDTree->Refresh();
1045             maxEvent = fHLTESDTree->GetEntries() - 1;
1046             if (event < 0)
1047                 event = fHLTESDTree->GetEntries() + event;
1048
1049         }
1050     }
1051     else if (fAODTree)
1052     {
1053         maxEvent = fAODTree->GetEntries() - 1;
1054         if (event < 0)
1055             event = fAODTree->GetEntries() + event;
1056     }
1057     else if (fRunLoader)
1058     {
1059         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1060         if (event < 0)
1061             event = fRunLoader->GetNumberOfEvents() + event;
1062     }
1063     else if (fRawReader)
1064     {
1065         maxEvent = fRawReader->GetNumberOfEvents() - 1;
1066         if (maxEvent < 0)
1067         {
1068             maxEvent = 10000000;
1069             if (event < 0) {
1070                 Error(kEH, "current raw-data source does not support direct event access.");
1071                 return;
1072             }
1073             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1074         }
1075         else
1076         {
1077             if (event < 0)
1078                 event = fRawReader->GetNumberOfEvents() + event;
1079         }
1080     }
1081     else
1082     {
1083         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1084     }
1085     if (event < 0 || event > maxEvent)
1086     {
1087         throw (kEH + Form("event %d not present, available range [%d, %d].",
1088                           event, 0, maxEvent));
1089     }
1090
1091     TString sysInfoHeader;
1092     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1093     AliSysInfo::AddStamp(sysInfoHeader + "Start");
1094
1095     TEveManager::TRedrawDisabler rd(gEve);
1096     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1097
1098     // !!! MT this is somewhat brutal; at least optionally, one could be
1099     // a bit gentler, checking for objs owning their external refs and having
1100     // additinal parents.
1101     gEve->GetViewers()->DeleteAnnotations();
1102     fTransients->DestroyElements();
1103     for (TEveElement::List_i i = fTransientLists->BeginChildren();
1104          i != fTransientLists->EndChildren(); ++i)
1105     {
1106         (*i)->DestroyElements();
1107     }
1108     DestroyElements();
1109
1110     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1111
1112     if (fESDTree) {
1113         if (fESDTree->GetEntry(event) <= 0)
1114             throw (kEH + "failed getting required event from ESD.");
1115
1116         if (fESDfriendExists)
1117             fESD->SetESDfriend(fESDfriend);
1118     }
1119
1120     if (fHLTESDTree) {
1121         if (fHLTESDTree->GetEntry(event) <= 0)
1122             throw (kEH + "failed getting required event from HLT ESD.");
1123
1124         if (fESDfriendExists)
1125             fESD->SetESDfriend(fESDfriend);
1126     }
1127
1128     if (fAODTree) {
1129         if (fAODTree->GetEntry(event) <= 0)
1130             throw (kEH + "failed getting required event from AOD.");
1131     }
1132
1133     if (fRunLoader) {
1134         if (fRunLoader->GetEvent(event) != 0)
1135             throw (kEH + "failed getting required event.");
1136     }
1137
1138     if (fRawReader)
1139     {
1140         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1141         if (fRawReader->GotoEvent(event) == kFALSE)
1142         {
1143             // Use fallback method - iteration with NextEvent().
1144             Int_t rawEv = fEventId;
1145             if (event < rawEv)
1146             {
1147                 fRawReader->RewindEvents();
1148                 rawEv = -1;
1149             }
1150
1151             while (rawEv < event)
1152             {
1153                 if ( ! fRawReader->NextEvent())
1154                 {
1155                     fRawReader->RewindEvents();
1156                     fEventId = -1;
1157                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1158                 }
1159                 ++rawEv;
1160             }
1161             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1162         }
1163     }
1164
1165     fHasEvent = kTRUE;
1166     fEventId  = event;
1167     if (this == fgMaster)
1168     {
1169         SetName(Form("Event %d", fEventId));
1170         ElementChanged();
1171     }
1172
1173     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1174
1175     AfterNewEventLoaded();
1176
1177     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1178 }
1179
1180 void AliEveEventManager::Timeout()
1181 {
1182     Emit("Timeout()");
1183 }
1184
1185 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1186 {       
1187         DestroyElements();
1188         InitOCDB(event->GetRunNumber());
1189         printf("======================= setting event to %d\n", fEventId);
1190         SetEvent(0,0,event,0);
1191 }
1192
1193 void AliEveEventManager::NextEvent()
1194 {
1195     // Loads next event.
1196     // Does magick needed for online display when under external event control.
1197
1198     static const TEveException kEH("AliEveEventManager::NextEvent ");
1199
1200     if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1201     
1202     if (fExternalCtrl)
1203     {
1204 #ifdef ZMQ
1205         if(fIsNewEventAvaliable)
1206         {
1207             fMutex->Lock();
1208             if(fWritingToEventIndex == 0) fEventInUse = 0;
1209             else if(fWritingToEventIndex == 1) fEventInUse = 1;
1210             
1211             if(fCurrentEvent[fEventInUse])
1212             {
1213                 if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1214                 {
1215                     printf("======================= setting event to %d\n", fEventId);
1216                     
1217                     DestroyElements();
1218                     InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1219                     SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1220                     
1221                 }
1222             }
1223             fIsNewEventAvaliable = false;
1224             fMutex->UnLock();
1225         }
1226         else
1227         {
1228             cout<<"No new event is avaliable."<<endl;
1229             NoEventLoaded();
1230         }
1231 #endif
1232     }
1233     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1234     {
1235       Int_t nextevent=0;
1236       if (fPEventSelector->FindNext(nextevent))
1237       {
1238         GotoEvent(nextevent);
1239       }
1240     }
1241     else if (fEventId < GetMaxEventId(kTRUE))
1242     {
1243       GotoEvent(fEventId + 1);
1244     }
1245     
1246     gSystem->ProcessEvents();
1247     
1248     /*
1249     cout<<"VSD"<<endl;
1250     AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1251     cout<<"contructor called"<<endl;
1252     vsdCreator->CreateVSD("myVSD.root");
1253     cout<<"PO"<<endl;
1254 */
1255     //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1256 }
1257
1258 void AliEveEventManager::PrevEvent()
1259 {
1260     // Loads previous event.
1261
1262     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1263
1264     if (fAutoLoadTimerRunning)
1265     {
1266         throw (kEH + "Event auto-load timer is running.");
1267     }
1268     if (fExternalCtrl)
1269     {
1270         throw (kEH + "Event-loop is under external control.");
1271     }
1272
1273     if ((fESDTree!=0) || (fHLTESDTree!=0))
1274     {
1275         Int_t nextevent=0;
1276         if (fPEventSelector->FindPrev(nextevent))
1277         {
1278             GotoEvent(nextevent);
1279         }
1280     }
1281     else if (fEventId > 0)
1282     {
1283         GotoEvent(fEventId - 1);
1284     }
1285 }
1286
1287 void AliEveEventManager::MarkCurrentEvent()
1288 {
1289 #ifdef ZMQ
1290         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1291         struct eventStruct mark;
1292         mark.runNumber = fESD->GetRunNumber();
1293         mark.eventNumber = fESD->GetEventNumberInFile();
1294         requestMessage->messageType = REQUEST_MARK_EVENT;
1295         requestMessage->event = mark;
1296
1297         AliStorageEventManager *eventManager =
1298                 AliStorageEventManager::GetEventManagerInstance();
1299         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1300
1301         /*
1302         std::future<bool> unused = std::async([]()
1303         {
1304                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1305                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1306
1307                 if(response)
1308                 {
1309                 //fStatusLabel->SetText("Event marked");
1310                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1311                 }
1312                 else
1313                 {
1314                 //fStatusLabel->SetText("Couldn't mark this event");
1315                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1316                 }
1317         });
1318         */
1319         
1320         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1321         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1322         
1323         
1324         if(response)
1325         {
1326                 //fStatusLabel->SetText("Event marked");
1327                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1328         }
1329         else
1330         {
1331                 //fStatusLabel->SetText("Couldn't mark this event");
1332                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1333         }
1334         if(requestMessage){delete requestMessage;}
1335 #endif
1336 }
1337
1338 void AliEveEventManager::Close()
1339 {
1340     // Close the event data-files and delete ESD, ESDfriend, run-loader
1341     // and raw-reader.
1342
1343     static const TEveException kEH("AliEveEventManager::Close ");
1344
1345     if (!fIsOpen)
1346     {
1347         throw (kEH + "Event-files not opened.");
1348     }
1349
1350     if (fAutoLoadTimerRunning)
1351         StopAutoLoadTimer();
1352
1353     if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1354         delete fESD;       fESD       = 0;
1355         // delete fESDfriend; // friend tree is deleted with the tree
1356         fESDfriend = 0;
1357         fESDfriendExists = kFALSE;
1358
1359         if(fESDTree) { delete fESDTree;   fESDTree = 0; }
1360         if(fHLTESDTree) { delete fHLTESDTree;   fHLTESDTree = 0; }
1361         delete fESDFile;   fESDFile = 0;
1362     }
1363
1364     if (fAODTree) {
1365         delete fAOD;       fAOD       = 0;
1366
1367         delete fAODTree;   fAODTree = 0;
1368         delete fAODFile;   fAODFile = 0;
1369     }
1370
1371     if (fRunLoader) {
1372         delete fRunLoader; fRunLoader = 0;
1373     }
1374
1375     if (fRawReader) {
1376         delete fRawReader; fRawReader = 0;
1377     }
1378
1379     fEventId  = -1;
1380     fIsOpen   = kFALSE;
1381     fHasEvent = kFALSE;
1382 }
1383
1384
1385 //------------------------------------------------------------------------------
1386 // Static convenience functions, mainly used from macros.
1387 //------------------------------------------------------------------------------
1388
1389 Int_t AliEveEventManager::CurrentEventId()
1390 {
1391     // Return current event-id.
1392
1393     static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1394
1395     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1396         throw (kEH + "ALICE event not ready.");
1397     return fgCurrent->GetEventId();
1398 }
1399
1400 Bool_t AliEveEventManager::HasRunLoader()
1401 {
1402     // Check if AliRunLoader is initialized.
1403
1404     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1405 }
1406
1407 Bool_t AliEveEventManager::HasESD()
1408 {
1409     // Check if AliESDEvent is initialized.
1410
1411     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1412 }
1413
1414 Bool_t AliEveEventManager::HasESDfriend()
1415 {
1416     // Check if AliESDfriend is initialized.
1417
1418     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1419 }
1420
1421 Bool_t AliEveEventManager::HasAOD()
1422 {
1423     // Check if AliESDEvent is initialized.
1424
1425     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1426 }
1427
1428 Bool_t AliEveEventManager::HasRawReader()
1429 {
1430     // Check if raw-reader is initialized.
1431
1432     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1433 }
1434
1435 AliRunLoader* AliEveEventManager::AssertRunLoader()
1436 {
1437     // Make sure AliRunLoader is initialized and return it.
1438     // Throws exception in case run-loader is not available.
1439     // Static utility for macros.
1440
1441     static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
1442
1443     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1444         throw (kEH + "ALICE event not ready.");
1445     if (fgCurrent->fRunLoader == 0)
1446         throw (kEH + "AliRunLoader not initialised.");
1447     return fgCurrent->fRunLoader;
1448 }
1449
1450 AliESDEvent* AliEveEventManager::AssertESD()
1451 {
1452     // Make sure AliESDEvent is initialized and return it.
1453     // Throws exception in case ESD is not available.
1454     // Static utility for macros.
1455
1456     static const TEveException kEH("AliEveEventManager::AssertESD ");
1457
1458     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1459         throw (kEH + "ALICE event not ready.");
1460     if (fgCurrent->fESD == 0)
1461         throw (kEH + "AliESD not initialised.");
1462     return fgCurrent->fESD;
1463 }
1464
1465 AliESDfriend* AliEveEventManager::AssertESDfriend()
1466 {
1467     // Make sure AliESDfriend is initialized and return it.
1468     // Throws exception in case ESDfriend-loader is not available.
1469     // Static utility for macros.
1470
1471     static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1472
1473     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1474         throw (kEH + "ALICE event not ready.");
1475     if (fgCurrent->fESDfriend == 0)
1476         throw (kEH + "AliESDfriend not initialised.");
1477     return fgCurrent->fESDfriend;
1478 }
1479
1480 AliAODEvent* AliEveEventManager::AssertAOD()
1481 {
1482     // Make sure AliAODEvent is initialized and return it.
1483     // Throws exception in case AOD is not available.
1484     // Static utility for macros.
1485
1486     static const TEveException kEH("AliEveEventManager::AssertAOD ");
1487
1488     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1489         throw (kEH + "ALICE event not ready.");
1490     if (fgCurrent->fAOD == 0)
1491         throw (kEH + "AliAOD not initialised.");
1492     return fgCurrent->fAOD;
1493 }
1494
1495 AliRawReader* AliEveEventManager::AssertRawReader()
1496 {
1497     // Make sure raw-reader is initialized and return it.
1498
1499     static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1500
1501     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1502         throw (kEH + "ALICE event not ready.");
1503     if (fgCurrent->fRawReader == 0)
1504         throw (kEH + "RawReader not ready.");
1505
1506     return fgCurrent->fRawReader;
1507 }
1508
1509 //==============================================================================
1510
1511 AliMagF* AliEveEventManager::AssertMagField()    
1512 {        
1513     // Make sure AliMagF is initialized and returns it.
1514     // Throws exception in case magnetic field is not available.
1515     // Static utility for macros.
1516
1517     static const TEveException kEH("AliEveEventManager::AssertMagField ");
1518
1519     if (fgMagField)
1520         return fgMagField;
1521
1522     if (TGeoGlobalMagField::Instance()->GetField())
1523     {
1524         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1525         if (fgMagField == 0)
1526             throw kEH + "Global field set, but it is not AliMagF.";
1527         return fgMagField;
1528     }
1529
1530     if (!fgGRPLoaded)
1531     {
1532         InitGRP();
1533     }
1534
1535     if (TGeoGlobalMagField::Instance()->GetField())
1536     {
1537         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1538         if (fgMagField == 0)
1539             throw kEH + "Global field set, but it is not AliMagF.";
1540     }
1541     else
1542     {
1543         throw kEH + "Could not initialize magnetic field.";
1544     }
1545
1546     return fgMagField;
1547 }
1548
1549 TGeoManager* AliEveEventManager::AssertGeometry()
1550 {
1551     // Make sure AliGeomManager is initialized and returns the
1552     // corresponding TGeoManger.
1553     // gGeoManager is set to the return value.
1554     // Throws exception if geometry can not be loaded or if it is not
1555     // available and the TGeoManager is locked.
1556     // Static utility for macros.
1557
1558     static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1559
1560     if (AliGeomManager::GetGeometry() == 0)
1561     {
1562         if (TGeoManager::IsLocked())
1563             throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1564
1565         gGeoManager = 0;
1566         AliGeomManager::LoadGeometry();
1567         if ( ! AliGeomManager::GetGeometry())
1568         {
1569             throw (kEH + "can not load geometry.");
1570         }
1571         if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1572         {
1573             ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1574             // throw (kEH + "could not apply align objs.");
1575         }
1576         AliGeomManager::GetGeometry()->DefaultColors();
1577     }
1578
1579     gGeoManager = AliGeomManager::GetGeometry();
1580     return gGeoManager;
1581 }
1582
1583 AliRecoParam* AliEveEventManager::AssertRecoParams()
1584 {
1585     if(!fgRecoParam)
1586         InitRecoParam();
1587
1588     return fgRecoParam;
1589 }
1590
1591 Bool_t AliEveEventManager::InitRecoParam()
1592 {
1593     // This is mostly a reap-off from reconstruction
1594     // The method accesses OCDB and retrieves all
1595     // the available reco-param objects from there.
1596
1597     fgRecoParam = new AliRecoParam;
1598     const Int_t  kNDetectors = 14;
1599
1600     static const TEveException kEH("AliEveEventManager::InitRecoParam");
1601
1602     Bool_t isOK = kTRUE;
1603
1604     if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1605         ::Info(kEH, "Using custom GRP reconstruction parameters");
1606     }
1607     else {
1608         ::Info(kEH, "Loading GRP reconstruction parameter objects");
1609
1610         AliCDBPath path("GRP","Calib","RecoParam");
1611         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1612         if(!entry){
1613             ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
1614             isOK = kFALSE;
1615         }
1616         else {
1617             TObject *recoParamObj = entry->GetObject();
1618             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1619                 // GRP has a normal TobjArray of AliDetectorRecoParam objects
1620                 // Registering them in AliRecoParam
1621                 fgRecoParam->AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
1622             }
1623             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1624                 // GRP has only onse set of reco parameters
1625                 // Registering it in AliRecoParam
1626                 ::Info(kEH, "Single set of GRP reconstruction parameters found");
1627                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1628                 fgRecoParam->AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1629             }
1630             else {
1631                 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1632                 isOK = kFALSE;
1633             }
1634             entry->SetOwner(0);
1635         }
1636     }
1637
1638     const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1639
1640
1641     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1642
1643         if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1644             ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1645             continue;
1646         }
1647
1648         ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1649
1650         AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1651         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1652         if(!entry){
1653             ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
1654             isOK = kFALSE;
1655         }
1656         else {
1657             TObject *recoParamObj = entry->GetObject();
1658             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1659                 // The detector has a normal TobjArray of AliDetectorRecoParam objects
1660                 // Registering them in AliRecoParam
1661                 fgRecoParam->AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
1662             }
1663             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1664                 // The detector has only onse set of reco parameters
1665                 // Registering it in AliRecoParam
1666                 ::Info(kEH, "Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]);
1667                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1668                 fgRecoParam->AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1669             }
1670             else {
1671                 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1672                 isOK = kFALSE;
1673             }
1674             entry->SetOwner(0);
1675
1676         }
1677     }
1678
1679     if(!isOK) {
1680         delete fgRecoParam;
1681         fgRecoParam = 0;
1682     }
1683
1684     return isOK;
1685 }
1686
1687 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1688 {
1689     if(!fESDFile && !fESD) return 0;
1690
1691     static const TEveException kEH("AliEveEventManager::readESDTree ");
1692
1693     TTree* tempTree = 0;
1694
1695     tempTree =(TTree*) fESDFile->Get(treeName);
1696     if (tempTree != 0)
1697     {
1698         TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1699         if (esdFriendFile)
1700         {
1701             if (!esdFriendFile->IsZombie())
1702             {
1703                 esdFriendFile->Close();
1704                 fESDfriendExists = kTRUE;
1705                 tempTree->SetBranchStatus ("ESDfriend*", 1);
1706             }
1707             delete esdFriendFile;
1708         }
1709
1710         fESD->ReadFromTree(tempTree);
1711         if (fESDfriendExists)
1712         {
1713             fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1714             Info(kEH, "found and attached ESD friend.");
1715         }
1716         else
1717         {
1718             Warning(kEH, "ESDfriend not found.");
1719         }
1720
1721         if (tempTree->GetEntry(0) <= 0)
1722         {
1723             Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1724         }
1725         else
1726         {
1727             if (runNo < 0)
1728                 runNo = fESD->GetESDRun()->GetRunNumber();
1729         }
1730     }
1731     else // tree == 0
1732     {
1733         Warning(kEH, "failed getting the tree:%s", treeName);
1734     }
1735
1736     return tempTree;
1737 }
1738
1739
1740 //------------------------------------------------------------------------------
1741
1742 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1743 {
1744     // Create and attach a dependent event-manager.
1745     // It is not added into eve list tree.
1746
1747     static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1748
1749     if (fgMaster == 0)
1750         throw(kEH + "Master event-manager must be instantiated first.");
1751
1752     if (fgMaster->fSubManagers == 0)
1753     {
1754         fgMaster->fSubManagers = new TList;
1755         fgMaster->fSubManagers->SetOwner(kTRUE);
1756     }
1757
1758     AliEveEventManager* new_mgr = 0;
1759     fgCurrent = 0;
1760     try
1761     {
1762         new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1763         new_mgr->SetFilesPath(path);
1764         fgMaster->fSubManagers->Add(new_mgr);
1765     }
1766     catch (TEveException& exc)
1767     {
1768         ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1769     }
1770     fgCurrent = fgMaster;
1771
1772     return new_mgr;
1773 }
1774
1775 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1776 {
1777     // Get a dependant manager by name.
1778     // This will not change the current manager, use helper class
1779     // AliEveEventManager::CurrentChanger for that.
1780
1781     static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1782
1783     if (fgMaster == 0)
1784         throw(kEH + "Master event-manager must be instantiated first.");
1785
1786     if (fgMaster->fSubManagers == 0)
1787         return 0;
1788
1789     return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1790 }
1791
1792 AliEveEventManager* AliEveEventManager::GetMaster()
1793 {
1794     // Get master event-manager.
1795
1796     return fgMaster;
1797 }
1798
1799 AliEveEventManager* AliEveEventManager::GetCurrent()
1800 {
1801     // Get current event-manager.
1802
1803     return fgCurrent;
1804 }
1805
1806 void AliEveEventManager::RegisterTransient(TEveElement* element)
1807 {
1808     GetCurrent()->fTransients->AddElement(element);
1809 }
1810
1811 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1812 {
1813     GetCurrent()->fTransientLists->AddElement(element);
1814 }
1815
1816 //------------------------------------------------------------------------------
1817 // Autoloading of events
1818 //------------------------------------------------------------------------------
1819
1820 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1821 {
1822     // Set the auto-load time in seconds
1823
1824     fAutoLoadTime = time;
1825 }
1826
1827 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1828 {
1829     // Set the automatic event loading mode
1830
1831     static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1832
1833     if (fAutoLoad == autoLoad)
1834     {
1835         Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1836         return;
1837     }
1838
1839     fAutoLoad = autoLoad;
1840     if (fAutoLoad)
1841     {
1842         StartAutoLoadTimer();
1843     }
1844     else
1845     {
1846         StopAutoLoadTimer();
1847     }
1848 }
1849
1850 void AliEveEventManager::SetLoopMarked(Bool_t loopMarked)
1851 {
1852     // Set the automatic event loading mode
1853     fLoopMarked = loopMarked;
1854     if (fLoopMarked){StartAutoLoadTimer();}
1855     else{StopAutoLoadTimer();}
1856 }
1857
1858 void AliEveEventManager::SetTrigSel(Int_t trig)
1859 {
1860     static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1861
1862     if (!fRawReader)
1863     {
1864         Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1865         return;
1866     }
1867     else
1868     {
1869         ULong64_t trigMask = 0;
1870         if (trig >= 0) trigMask = (1ull << trig);
1871         Info(kEH,"Trigger selection: 0x%llx",trigMask);
1872         fRawReader->SelectEvents(-1,trigMask,NULL);
1873     }
1874 }
1875
1876 void AliEveEventManager::StartAutoLoadTimer()
1877 {
1878     // Start the auto-load timer.
1879
1880     fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1881     fAutoLoadTimer->Reset();
1882     fAutoLoadTimer->TurnOn();
1883     fAutoLoadTimerRunning = kTRUE;
1884 }
1885
1886 void AliEveEventManager::StopAutoLoadTimer()
1887 {
1888     // Stop the auto-load timer.
1889
1890     fAutoLoadTimerRunning = kFALSE;
1891     fAutoLoadTimer->TurnOff();
1892 }
1893
1894 void AliEveEventManager::AutoLoadNextEvent()
1895 {
1896         // Called from auto-load timer, so it has to be public.
1897         // Do NOT call it directly.
1898
1899         static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1900           
1901         Info(kEH, "called!");
1902
1903         if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1904         {
1905                 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1906                 return;
1907         }
1908
1909         StopAutoLoadTimer();
1910         NextEvent();
1911         if (fAutoLoad || fLoopMarked)
1912                 StartAutoLoadTimer();
1913 }
1914
1915 //------------------------------------------------------------------------------
1916 // Post event-loading functions
1917 //------------------------------------------------------------------------------
1918
1919 void AliEveEventManager::AfterNewEventLoaded()
1920 {
1921   // Execute registered macros and commands.
1922   // At the end emit NewEventLoaded signal.
1923   //
1924   // Virtual from TEveEventManager.
1925
1926   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1927
1928   Info(kEH, "------------------!!!------------");
1929                       
1930   NewEventDataLoaded();
1931   if (fExecutor) fExecutor->ExecMacros();
1932
1933   TEveEventManager::AfterNewEventLoaded();
1934   NewEventLoaded();
1935
1936   if (this == fgMaster && fSubManagers != 0)
1937   {
1938     TIter next(fSubManagers);
1939     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1940     {
1941       gEve->SetCurrentEvent(fgCurrent);
1942       try
1943       {
1944         fgCurrent->GotoEvent(fEventId);
1945       }
1946       catch (TEveException& exc)
1947       {
1948         // !!! Should somehow tag / disable / remove it?
1949         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1950               fEventId, fgCurrent->GetName(), exc.Data());
1951       }
1952       Info(kEH, "------------------!!! while() gEve->SetCurrentEvent() ------------");
1953     }
1954     fgCurrent = fgMaster;
1955     Info(kEH, "------------------!!! while() gEve->SetCurrentEvent(MASTER) ------------");
1956     gEve->SetCurrentEvent(fgMaster);
1957   }
1958 }
1959
1960 void AliEveEventManager::NewEventDataLoaded()
1961 {
1962     // Emit NewEventDataLoaded signal.
1963     Emit("NewEventDataLoaded()");
1964 }
1965 void AliEveEventManager::NewEventLoaded()
1966 {
1967     // Emit NewEventLoaded signal.
1968     Emit("NewEventLoaded()");
1969 }
1970 void AliEveEventManager::NoEventLoaded()
1971 {
1972     // Emit NoEventLoaded signal.
1973     Emit("NoEventLoaded()");
1974 }
1975 void AliEveEventManager::StorageManagerOk()
1976 {
1977     // Emit StorageManagerOk signal.
1978     Emit("StorageManagerOk()");
1979 }
1980 void AliEveEventManager::StorageManagerDown()
1981 {
1982     // Emit StorageManagerOk signal.
1983     Emit("StorageManagerDown()");
1984 }
1985
1986
1987 //------------------------------------------------------------------------------
1988 // Event info dumpers
1989 //------------------------------------------------------------------------------
1990
1991 const AliEventInfo* AliEveEventManager::GetEventInfo() 
1992 {
1993     // Fill the event info object
1994
1995     AliCentralTrigger *aCTP = NULL;
1996     if (fRawReader) {
1997         fEventInfo.SetEventType(fRawReader->GetType());
1998
1999         ULong64_t mask = fRawReader->GetClassMask();
2000         fEventInfo.SetTriggerMask(mask);
2001         UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2002         fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
2003
2004         aCTP = new AliCentralTrigger();
2005         TString configstr("");
2006         if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
2007             AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
2008             delete aCTP;
2009             return 0;
2010         }
2011         aCTP->SetClassMask(mask);
2012         aCTP->SetClusterMask(clmask);
2013
2014         if (fRunLoader) {
2015             AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
2016             if (rlCTP) {
2017                 rlCTP->SetClassMask(mask);
2018                 rlCTP->SetClusterMask(clmask);
2019             }
2020         }
2021     }
2022     else {
2023         fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
2024
2025         if (fRunLoader && (!fRunLoader->LoadTrigger())) {
2026             aCTP = fRunLoader->GetTrigger();
2027             fEventInfo.SetTriggerMask(aCTP->GetClassMask());
2028             // get inputs from actp - just get
2029             AliESDHeader* esdheader = fESD->GetHeader();
2030             esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
2031             esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
2032             esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
2033             fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
2034         }
2035         else {
2036             AliWarning("No trigger can be loaded! The trigger information will not be used!");
2037             return 0;
2038         }
2039     }
2040
2041     AliTriggerConfiguration *config = aCTP->GetConfiguration();
2042     if (!config) {
2043         AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
2044         if (fRawReader) delete aCTP;
2045         return 0;
2046     }
2047
2048     TString declTriggerClasses;
2049
2050     // Load trigger aliases and declare the trigger classes included in aliases
2051     AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
2052     if (entry) {
2053         THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
2054         if (lst) {
2055             lst->Sort(kSortDescending); // to avoid problems with substrings
2056             if (fRawReader) fRawReader->LoadTriggerAlias(lst);
2057             // Now declare all the triggers present in the aliases
2058             TIter iter(lst);
2059             TNamed *nmd = 0;
2060             while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
2061                 declTriggerClasses += " ";
2062                 declTriggerClasses += nmd->GetName();
2063             }
2064         }
2065         else {
2066             AliError("Cannot cast the object with trigger aliases to THashList!");
2067         }
2068     }
2069     else {
2070         AliError("No OCDB entry for the trigger aliases!");
2071     }
2072
2073     // Load trigger classes for this run
2074     UChar_t clustmask = 0;
2075     TString trclasses;
2076     ULong64_t trmask = fEventInfo.GetTriggerMask();
2077     const TObjArray& classesArray = config->GetClasses();
2078     Int_t nclasses = classesArray.GetEntriesFast();
2079     for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
2080         AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
2081         if (trclass && trclass->GetMask()>0) {
2082             Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
2083             if (fESD) fESD->SetTriggerClass(trclass->GetName(),trindex);
2084             if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
2085             if (trmask & (1ull << trindex)) {
2086                 trclasses += " ";
2087                 trclasses += trclass->GetName();
2088                 trclasses += " ";
2089                 clustmask |= trclass->GetCluster()->GetClusterMask();
2090             }
2091         }
2092     }
2093     fEventInfo.SetTriggerClasses(trclasses);
2094
2095     if (!aCTP->CheckTriggeredDetectors()) {
2096         if (fRawReader) delete aCTP;
2097         return 0;
2098     }
2099
2100     if (fRawReader) delete aCTP;
2101
2102     // everything went ok, return pointer
2103     return (&fEventInfo);
2104 }
2105
2106
2107 TString AliEveEventManager::GetEventInfoHorizontal() const
2108 {
2109     // Dumps the event-header contents in vertical formatting.
2110
2111     TString rawInfo, esdInfo;
2112
2113     if (!fRawReader)
2114     {
2115         rawInfo = "No raw-data event info is available!\n";
2116     }
2117     else
2118     {
2119         const UInt_t* attr = fRawReader->GetAttributes();
2120         TTimeStamp ts(fRawReader->GetTimestamp());
2121         rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2122                      "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
2123                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2124                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2125                      fRawReader->GetClassMask(),
2126                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2127                      attr[0],attr[1],attr[2], ts.AsString("s"));
2128     }
2129
2130     if (!fESD)
2131     {
2132         esdInfo = "No ESD event info is available!";
2133     }
2134     else
2135     {
2136         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2137         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2138         TTimeStamp ts(fESD->GetTimeStamp());
2139         esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2140                      "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
2141                      fESD->GetRunNumber(),
2142                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2143                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2144                      acttrclasses.Data(),
2145                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2146                      fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
2147     }
2148
2149     return rawInfo + esdInfo;
2150 }
2151
2152 TString AliEveEventManager::GetEventInfoVertical() const
2153 {
2154     // Dumps the event-header contents in vertical formatting.
2155
2156     TString rawInfo, esdInfo;
2157
2158     if (!fRawReader)
2159     {
2160         rawInfo = "No raw-data event info is available!\n";
2161     }
2162     else
2163     {
2164         const UInt_t* attr = fRawReader->GetAttributes();
2165         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",
2166                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2167                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2168                      fRawReader->GetClassMask(),
2169                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2170                      attr[0],attr[1],attr[2],
2171                      fRawReader->GetTimestamp());
2172     }
2173
2174     if (!fESD)
2175     {
2176         esdInfo = "No ESD event info is available!\n";
2177     }
2178     else
2179     {
2180         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2181         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2182         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",
2183                      fESD->GetRunNumber(),
2184                      acttrclasses.Data(),
2185                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2186                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2187                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2188                      fESD->GetEventNumberInFile(),
2189                      fESD->GetTimeStamp());
2190     }
2191
2192     return rawInfo + "\n" + esdInfo;
2193 }
2194
2195
2196 //==============================================================================
2197 // Reading of GRP and MagneticField.
2198 // This is a reap-off from reconstruction ... should really be a common
2199 // code to do this somewhere in STEER.
2200 //==============================================================================
2201
2202 Bool_t AliEveEventManager::InitGRP()
2203 {
2204     //------------------------------------
2205     // Initialization of the GRP entry
2206     //------------------------------------
2207
2208     static const TEveException kEH("AliEveEventManager::InitGRP ");
2209
2210     AliGRPManager grpMgr;
2211     if (!grpMgr.ReadGRPEntry()) {
2212         return kFALSE;
2213     }
2214     fgGRPLoaded = kTRUE;
2215     if (!grpMgr.SetMagField()) {
2216         throw kEH + "Setting of field failed!";
2217     }
2218
2219     //*** Get the diamond profiles from OCDB
2220     // Eventually useful.
2221
2222     /*
2223     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
2224     if (entry) {
2225     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
2226     } else {
2227     ::Error(kEH, "No SPD diamond profile found in OCDB!");
2228     }
2229
2230     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
2231     if (entry) {
2232     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
2233     } else {
2234     ::Error(kEH, "No diamond profile found in OCDB!");
2235     }
2236
2237     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
2238     if (entry) {
2239     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
2240     } else {
2241     ::Error(kEH, "No TPC diamond profile found in OCDB!");
2242     }
2243   */
2244
2245     return kTRUE;
2246
2247
2248 //------------------------------------
2249 // Global variables management
2250 //------------------------------------
2251
2252 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model)
2253 {
2254     // Insert a new visualization-parameter database entry with the default
2255     return InsertGlobal(tag, model, fGlobalReplace, fGlobalUpdate);
2256 }
2257
2258 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model,
2259                                         Bool_t replace, Bool_t update)
2260 {
2261     TPair* pair = (TPair*) fGlobal->FindObject(tag);
2262     if (pair)
2263     {
2264         if (replace)
2265         {
2266             model->IncDenyDestroy();
2267             model->SetRnrChildren(kFALSE);
2268
2269             TEveElement* old_model = dynamic_cast<TEveElement*>(pair->Value());
2270             if(!old_model) AliFatal("old_model == 0, dynamic cast failed\n");
2271             while (old_model->HasChildren())
2272             {
2273                 TEveElement *el = old_model->FirstChild();
2274                 el->SetVizModel(model);
2275                 if (update)
2276                 {
2277                     el->CopyVizParams(model);
2278                     el->PropagateVizParamsToProjecteds();
2279                 }
2280             }
2281             old_model->DecDenyDestroy();
2282
2283             pair->SetValue(dynamic_cast<TObject*>(model));
2284             return kTRUE;
2285         }
2286         else
2287         {
2288             return kFALSE;
2289         }
2290     }
2291     else
2292     {
2293         model->IncDenyDestroy();
2294         model->SetRnrChildren(kFALSE);
2295         fGlobal->Add(new TObjString(tag), dynamic_cast<TObject*>(model));
2296         return kTRUE;
2297     }
2298 }
2299
2300 TEveElement* AliEveEventManager::FindGlobal(const TString& tag)
2301 {
2302     return dynamic_cast<TEveElement*>(fGlobal->GetValue(tag));
2303 }
2304 Int_t AliEveEventManager::NewEventAvailable()
2305 {
2306   if (fIsNewEventAvaliable)
2307   {
2308     return 1;
2309   }
2310   else
2311   {
2312     return 0;
2313   }
2314 }