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