Add using srd::...
[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                 struct eventStruct mark;
279                 mark.runNumber = receivedList[iter].runNumber;
280                 mark.eventNumber = receivedList[iter].eventNumber;
281              
282                 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
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                 delete requestMessage;
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
315         {
316             cout<<"didn't receive new event"<<endl;
317         }
318     }
319     delete requestMessage;
320     
321 #endif
322 }
323
324 void AliEveEventManager::CheckStorageStatus()
325 {
326 #ifdef ZMQ
327     AliEveConfigManager *configManager = AliEveConfigManager::GetMaster();
328     configManager->ConnectEventManagerSignals();
329     
330     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
331     eventManager->CreateSocket(CLIENT_COMMUNICATION_REQ);
332     
333     struct clientRequestStruct *request = new struct clientRequestStruct;
334     request->messageType = REQUEST_CONNECTION;
335     
336     while (!fFinished)
337     {
338         if(eventManager->Send(request,CLIENT_COMMUNICATION_REQ,5000))
339         {
340             StorageManagerOk();
341             long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
342             fStorageDown = kFALSE;
343         }
344         else
345         {
346             StorageManagerDown();
347             cout<<"WARNING -- Storage Manager is DOWN!!"<<endl;
348             fStorageDown = kTRUE;
349         }
350         sleep(1);
351     }
352 #endif
353 }
354
355 void AliEveEventManager::InitInternals()
356 {
357     // Initialize internal members.
358     
359     static const TEveException kEH("AliEveEventManager::InitInternals ");
360     
361     if (fgCurrent != 0)
362     {
363         throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
364     }
365     
366     if (fgMaster == 0)
367     {
368         fgMaster = this;
369     }
370     
371     fgCurrent = this;
372     
373     fAutoLoadTimer = new TTimer;
374     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
375     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "Timeout()");
376     
377     fExecutor = new AliEveMacroExecutor;
378     
379     fTransients = new TEveElementList("Transients", "Transient per-event elements.");
380     fTransients->IncDenyDestroy();
381     gEve->AddToListTree(fTransients, kFALSE);
382     
383     fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
384     fTransientLists->IncDenyDestroy();
385     gEve->AddToListTree(fTransientLists, kFALSE);
386     
387     fPEventSelector = new AliEveEventSelector(this);
388     
389     fGlobal = new TMap; fGlobal->SetOwnerKeyValue();
390 }
391
392 /******************************************************************************/
393
394 void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
395 {
396     fgESDvisibleTrees = shown;
397     // Set file-name for opening ESD, default "AliESDs.root".
398     if (esd.IsNull()) return;
399
400     fgESDFileName = esd;
401     if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
402
403 }
404
405 void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
406 {
407     // Set file-name for opening ESD friend, default "AliESDfriends.root".
408
409     if (esdf.IsNull()) return;
410     fgESDfriendsFileName = esdf;
411     
412     if (esdf.EndsWith(".zip")) fgESDfriendsFileName.Form("%s#AliESDfriends.root",esdf.Data());
413 }
414
415 void AliEveEventManager::SetAODFileName(const TString& aod)
416 {
417     // Set file-name for opening AOD, default "AliAOD.root".
418
419     if (aod.IsNull()) return;
420     fgAODFileName = aod;
421     
422     if (aod.EndsWith(".zip")) fgAODFileName.Form("%s#AliAOD.root",aod.Data());
423     
424 }
425
426 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
427 {
428     // Add new AOD friend file-name to be attached when opening AOD.
429     // This should include '.root', as in 'AliAOD.VertexingHF.root'.
430
431     if (fgAODfriends == 0)
432     {
433         fgAODfriends = new TList;
434         fgAODfriends->SetOwner(kTRUE);
435     }
436     if (fgAODfriends->FindObject(friendFileName) == 0)
437     {
438         fgAODfriends->Add(new TObjString(friendFileName));
439     }
440 }
441
442 void AliEveEventManager::SetRawFileName(const TString& raw)
443 {
444     // Set file-name for opening of raw-data, default "raw.root"
445     if (raw.IsNull()) return;
446     
447     fgRawFileName = raw;
448 }
449
450 void AliEveEventManager::SetCdbUri(const TString& cdb)
451 {
452     // Set path to CDB, there is no default.
453     if ( ! cdb.IsNull()) fgCdbUri = cdb;
454 }
455
456 void AliEveEventManager::SetGAliceFileName(const TString& galice)
457 {
458     // Set file-name for opening gAlice, default "galice.root".
459
460     if ( galice.IsNull()) return;
461     fgGAliceFileName = galice;
462     
463     if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
464 }
465
466 void AliEveEventManager::SetFilesPath(const TString& urlPath)
467 {
468     TString path = urlPath;
469     gSystem->ExpandPathName(path);
470     if (path.IsNull() || path == ".")
471     {
472         path = gSystem->WorkingDirectory();
473     }
474
475     TString sep;
476     if(path.EndsWith(".zip")) // if given a path to root_archive.zip
477         sep= "#";
478     else if(!path.EndsWith("/"))
479         sep = "/";
480     
481     SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
482     SetESDfriendFileName(  TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
483     SetAODFileName(  TString(Form("%s%sAliAOD.root", path.Data(), sep.Data())) );
484     AddAODfriend(  TString(Form("%s%sAliAOD.VertexingHF.root", path.Data(), sep.Data())) );
485     SetGAliceFileName( TString(Form("%s%sgalice.root", path.Data(), sep.Data())) );
486     SetRawFileName(TString(Form("%s%sraw.root", path.Data(), sep.Data())));
487 }
488
489 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
490                                            Bool_t assertAod, Bool_t assertRaw)
491 {
492     // Set global flags that detrmine which parts of the event-data must
493     // be present when the event is opened.
494
495     fgAssertRunLoader = assertRunloader;
496     fgAssertESD = assertEsd;
497     fgAssertAOD = assertAod;
498     fgAssertRaw = assertRaw;
499 }
500
501 void AliEveEventManager::SearchRawForCentralReconstruction()
502 {
503     // Enable searching of raw data in standard location. The path passed to
504     // Open() is expected to point to a centrally reconstructed run, e.g.:
505     // "alien:///alice/data/2009/LHC09c/000101134/ESDs/pass1/09000101134018.10".
506
507     fgRawFromStandardLoc = kTRUE;
508 }
509
510 /******************************************************************************/
511
512 void AliEveEventManager::Open()
513 {
514     // Open event-data from URL specified in path.
515     // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
516     // Warning is reported if run-loader or ESD is not found.
517     // Global data-members fgAssertRunLoader and fgAssertESD can be set
518     // to throw exceptions instead.
519
520     static const TEveException kEH("AliEveEventManager::Open ");
521
522     if (fExternalCtrl)
523     {
524         throw (kEH + "Event-loop is under external control.");
525     }
526     if (fIsOpen)
527     {
528         throw (kEH + "Event-files already opened.");
529     }
530
531     Int_t runNo = -1;
532
533     // Open ESD and ESDfriends
534     
535     if ((fESDFile = TFile::Open(fgESDFileName)))
536     {
537         fESD = new AliESDEvent();
538
539         switch(fgESDvisibleTrees){
540         case AliEveEventManager::kOfflineTree :
541             fESDTree = readESDTree("esdTree", runNo);
542             break;
543         case AliEveEventManager::kHLTTree :
544             fHLTESDTree = readESDTree("HLTesdTree", runNo);
545             break;
546         default:
547             fESDTree    = readESDTree("esdTree", runNo);
548             fHLTESDTree = readESDTree("HLTesdTree", runNo);
549         }
550
551         if(!fESDTree && !fHLTESDTree){
552             // both ESD trees are == 0
553             delete fESDFile; fESDFile = 0;
554             delete fESD; fESD = 0;
555         }
556
557
558     }
559     else // esd file not readable
560     {
561         Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
562     }
563     if (fESDTree == 0 && fHLTESDTree==0)
564     {
565         if (fgAssertESD)
566         {
567             throw (kEH + "ESD not initialized. Its precence was requested.");
568         } else {
569             Warning(kEH, "ESD not initialized.");
570         }
571     }
572
573     // Open AOD and registered friends
574     if ( (fAODFile = TFile::Open(fgAODFileName)) )
575     {
576         fAOD = new AliAODEvent();
577         fAODTree = (TTree*) fAODFile->Get("aodTree");
578         if (fAODTree != 0)
579         {
580             // Check if AODfriends exist and attach them.
581             TIter       friends(fgAODfriends);
582             TObjString *name;
583             while ((name = (TObjString*) friends()) != 0)
584             {
585                 TString p(Form("%s/%s", fgAODFileName.Data(), name->GetName()));
586                 if (fgAODFileName.EndsWith(".zip")) p.Form("%s#%s",fgAODFileName.Data(),name->GetName());
587                 if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
588                 {
589                     fAODTree->AddFriend("aodTree", name->GetName());
590                 }
591             }
592
593             fAOD->ReadFromTree(fAODTree);
594
595             if (fAODTree->GetEntry(0) <= 0)
596             {
597                 delete fAODFile; fAODFile = 0;
598                 delete fAOD;     fAOD     = 0;
599                 Warning(kEH, "failed getting the first entry from addTree.");
600             }
601             else
602             {
603                 if (runNo < 0)
604                     runNo = fAOD->GetRunNumber();
605             }
606         }
607         else // aodtree == 0
608         {
609             delete fAODFile; fAODFile = 0;
610             delete fAOD;     fAOD     = 0;
611             Warning(kEH, "failed getting the aodTree.");
612         }
613     }
614     else // aod not readable
615     {
616         Warning(kEH, "can not read AOD file '%s'.", fgAODFileName.Data());
617     }
618     if (fAODTree == 0)
619     {
620         if (fgAssertAOD)
621         {
622             throw (kEH + "AOD not initialized. Its precence was requested.");
623         } else {
624             Warning(kEH, "AOD not initialized.");
625         }
626     }
627
628     // Open RunLoader from galice.root
629 //    fgGAliceFileName = "/Users/Jerus/galice.root"; // temp
630     
631     TFile *gafile = TFile::Open(fgGAliceFileName);
632     cout<<"Opening galice"<<endl;
633     if (gafile)
634     {
635         gafile->Close();
636         delete gafile;
637         cout<<"SETTING RUN LOADER in Open()"<<endl;
638         fRunLoader = AliRunLoader::Open(fgGAliceFileName, GetName());
639         if (fRunLoader)
640         {
641             TString alicePath(gSystem->DirName(fgGAliceFileName));
642             alicePath.Append("/");
643             fRunLoader->SetDirName(alicePath);
644
645             if (fRunLoader->LoadgAlice() != 0)
646                 Warning(kEH, "failed loading gAlice via run-loader.");
647
648             if (fRunLoader->LoadHeader() == 0)
649             {
650                 if (runNo < 0)
651                     runNo = fRunLoader->GetHeader()->GetRun();
652             }
653             else
654             {
655                 Warning(kEH, "failed loading run-loader's header.");
656                 delete fRunLoader;
657                 fRunLoader = 0;
658             }
659         }
660         else // run-loader open failed
661         {
662             Warning(kEH, "failed opening ALICE run-loader from '%s'.", fgGAliceFileName.Data());
663         }
664         
665     }
666     else // galice not readable
667     {
668         Warning(kEH, "can not read '%s'.", fgGAliceFileName.Data());
669     }
670     if (fRunLoader == 0)
671     {
672         if (fgAssertRunLoader)
673             throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
674         else
675             Warning(kEH, "Bootstraping of run-loader failed.");
676     }
677
678     // Open raw-data file
679
680     TString rawPath;
681     if (fgRawFromStandardLoc)
682     {
683         if (!fgRawFileName.BeginsWith("alien:"))
684             throw kEH + "Standard raw search requested, but the directory is not in AliEn.";
685         if (!fgRawFileName.Contains("/ESDs/"))
686             throw kEH + "Standard raw search requested, but does not contain 'ESDs' directory.";
687
688         TPMERegexp chunk("/([\\d\\.])+/?$");
689         Int_t nm = chunk.Match(fgRawFileName);
690         if (nm != 2)
691             throw kEH + "Standard raw search requested, but the path does not end with chunk-id directory.";
692
693         TPMERegexp esdstrip("/ESDs/.*");
694         rawPath = fgRawFileName;
695         esdstrip.Substitute(rawPath, "/raw/");
696         rawPath += chunk[0];
697         rawPath += ".root";
698
699         Info(kEH, "Standard raw search requested, using the following path:\n  %s\n", rawPath.Data());
700     }
701     else
702     {
703         rawPath = fgRawFileName;
704     }
705     // If i use open directly, raw-reader reports an error but i have
706     // no way to detect it.
707     // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
708     AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
709     if (fgAssertRaw == kFALSE)
710     {
711         AliLog::SetGlobalLogLevel(AliLog::kFatal);
712     }
713     if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
714     {
715         fRawReader = AliRawReader::Create(rawPath);
716     }
717     else
718     {
719         fRawReader = AliRawReader::Create(fgRawFileName);
720     }
721     if (fgAssertRaw == kFALSE)
722     {
723         AliLog::SetGlobalLogLevel(oldLogLevel);
724     }
725
726     if (fRawReader == 0)
727     {
728         if (fgAssertRaw)
729         {
730             throw (kEH + "raw-data not initialized. Its precence was requested.");
731         }
732         else
733         {
734             Warning(kEH, "raw-data not initialized.");
735         }
736     }
737
738     if (runNo < 0)
739     {
740         if (fRawReader)
741         {
742             if ( ! fRawReader->NextEvent())
743             {
744                 throw (kEH + "can not go to first event in raw-reader to determine run-id.");
745             }
746             runNo = fRawReader->GetRunNumber();
747             Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
748             fRawReader->RewindEvents();
749         }
750         else
751         {
752             fExternalCtrl = kTRUE;
753              fEventId = 0;
754             return;
755         }
756     }
757
758     // Initialize OCDB ... only in master event-manager
759
760                 InitOCDB(runNo);
761
762
763     fIsOpen = kTRUE;
764 }
765
766 void AliEveEventManager::InitOCDB(int runNo)
767 {
768                 static const TEveException kEH("AliEveEventManager::InitOCDB ");
769     //if (this == fgMaster)
770     {
771         AliCDBManager* cdb = AliCDBManager::Instance();
772         if (cdb->IsDefaultStorageSet() == kTRUE)
773         {
774             Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
775                     cdb->GetDefaultStorage()->GetURI().Data());
776         }
777         else
778         {
779             if (fgCdbUri.IsNull())
780             {
781                 gEnv->SetValue("Root.Stacktrace", "no");
782                 Fatal("Open()", "OCDB path was not specified.");
783             }
784
785             // Handle some special cases for MC (should be in OCDBManager).
786             if (fgCdbUri == "mcideal://")
787                 cdb->SetDefaultStorage("MC", "Ideal");
788             else if (fgCdbUri == "mcresidual://")
789                 cdb->SetDefaultStorage("MC", "Residual");
790             else if (fgCdbUri == "mcfull://")
791                 cdb->SetDefaultStorage("MC", "Full");
792             else if (fgCdbUri == "local://") {
793                 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
794                 cdb->SetDefaultStorage(fgCdbUri);
795             } else
796                 cdb->SetDefaultStorage(fgCdbUri);
797
798             cdb->SetRun(runNo);
799
800             if (cdb->IsDefaultStorageSet() == kFALSE)
801                 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
802         }
803
804         if (fgCdbUri.BeginsWith("local://"))
805         {
806             TString curPath = gSystem->WorkingDirectory();
807             TString grp     = "GRP/GRP/Data";
808             TString grppath = curPath + "/" + grp;
809             if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
810             {
811                 if (cdb->GetSpecificStorage(grp))
812                 {
813                     Warning(kEH, "Local GRP exists, but the specific storage is already set.");
814                 }
815                 else
816                 {
817                     Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
818                     TString lpath("local://");
819                     lpath += curPath;
820                     cdb->SetSpecificStorage(grp, lpath);
821                 }
822             }
823         }
824     }
825 }
826
827 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
828 {
829     // Set an event from an external source.
830     // The method is used in the online visualisation.
831     // AOD is not supported.
832
833     static const TEveException kEH("AliEveEventManager::SetEvent ");
834
835     if (fIsOpen)
836     {
837         Warning(kEH, "Event-files were open. Closing and switching to external control.");
838         Close();
839     }
840
841                         Info(kEH,"setting it!!! ============================");
842
843     fRunLoader = runLoader;
844     fRawReader = rawReader;
845     fESD       = esd;
846     fESDfriend = esdf;
847     fAOD       = 0;
848
849     fEventId++;
850     fHasEvent     = kTRUE;
851     fExternalCtrl = kTRUE;
852
853     SetTitle("Online event in memory");
854     SetName ("Online Event");
855     ElementChanged();
856
857     AfterNewEventLoaded();
858
859     if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
860     
861 }
862
863 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
864 {
865     // Returns maximum available event id.
866     // If under external control or event is not opened -1 is returned.
867     // If raw-data is the only data-source this can not be known
868     // and 10,000,000 is returned.
869     // If neither data-source is initialised an exception is thrown.
870     // If refresh_esd is true and ESD is the primary event-data source
871     // its header is re-read from disk.
872
873     static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
874
875     if (fExternalCtrl || fIsOpen == kFALSE)
876     {
877         return -1;
878     }
879
880     if ((fESDTree!=0) || (fHLTESDTree!=0))
881     {
882         if (refreshESD)
883         {
884             if(fESDTree!=0) fESDTree->Refresh();
885             if(fHLTESDTree!=0) fHLTESDTree->Refresh();
886             fPEventSelector->Update();
887         }
888
889         Int_t maxEventId=0;
890         switch(fgESDvisibleTrees){
891         default:
892         case AliEveEventManager::kOfflineTree :
893             maxEventId = fESDTree->GetEntries() - 1;
894             break;
895         case AliEveEventManager::kHLTTree :
896             maxEventId = fHLTESDTree->GetEntries() - 1;
897             break;
898        }
899
900         return maxEventId;
901     }
902     else if (fAODTree)
903     {
904         return fAODTree->GetEntries() - 1;
905     }
906     else if (fRunLoader)
907     {
908         return fRunLoader->GetNumberOfEvents() - 1;
909     }
910     else if (fRawReader)
911     {
912         Int_t n = fRawReader->GetNumberOfEvents() - 1;
913         return n > -1 ? n : 10000000;
914     }
915     else
916     {
917         throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
918     }
919 }
920
921 void AliEveEventManager::GotoEvent(Int_t event)
922 {
923     cout<<"Go to event:"<<event<<endl;
924     // Load data for specified event.
925     // If event is out of range an exception is thrown and old state
926     // is preserved.
927     // After successful loading of event, the virtual function
928     // AfterNewEventLoaded() is called. This executes commands that
929     // were registered via TEveEventManager::AddNewEventCommand().
930     //
931     // If event is negative, it is subtracted from the number of
932     // available events, thus passing -1 will load the last event.
933     // This is not supported when raw-data is the only data-source
934     // as the number of events is not known.
935
936     static const TEveException kEH("AliEveEventManager::GotoEvent ");
937
938     if (fAutoLoadTimerRunning)
939     {
940         throw (kEH + "Event auto-load timer is running.");
941     }
942     if (fExternalCtrl)
943     {
944       // throw (kEH + "Event-loop is under external control.");
945 #ifdef ZMQ
946       if (fStorageDown && -1 == event) 
947       {
948         NextEvent();
949         return;
950       }
951
952       if (fESD)
953       {
954           // create new server request:
955           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
956             
957           // set request type:
958           if (event == -1)      {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
959           else  if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
960           else  if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
961           else  if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
962             
963           // set event struct:
964           struct eventStruct eventToLoad;
965           eventToLoad.runNumber = fESD->GetRunNumber();
966           eventToLoad.eventNumber = fESD->GetEventNumberInFile();
967           requestMessage->event = eventToLoad;
968             
969           // create event manager:
970           AliStorageEventManager *eventManager =
971             AliStorageEventManager::GetEventManagerInstance();
972           AliESDEvent *resultEvent = NULL;
973             
974           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
975           fMutex->Lock();
976             
977           // send request and receive event:
978           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
979           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
980             
981           if(resultEvent)
982           {
983               DestroyElements();
984               InitOCDB(resultEvent->GetRunNumber());
985               SetEvent(0,0,resultEvent,0);
986           }
987           else
988           {
989               if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
990               if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
991               if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
992               if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
993           }
994             
995           fMutex->UnLock();
996         }
997       else
998       {
999           cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
1000
1001           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1002           requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1003             
1004           AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1005           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1006           AliESDEvent *resultEvent = NULL;
1007             
1008           fMutex->Lock();
1009           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1010           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1011             
1012           if(resultEvent)
1013           {
1014               fESD=resultEvent;
1015               DestroyElements();
1016               InitOCDB(resultEvent->GetRunNumber());
1017               SetEvent(0,0,resultEvent,0);
1018           }
1019           else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1020           fMutex->UnLock();
1021       }
1022 #endif  
1023
1024     }
1025     else if (!fIsOpen)
1026     {
1027         throw (kEH + "Event-files not opened.");
1028     }
1029
1030     fEventInfo.Reset();
1031
1032     fHasEvent = kFALSE;
1033
1034     Int_t maxEvent = 0;
1035     if ((fESDTree!=0) || (fHLTESDTree!=0))
1036     {
1037         if(fESDTree){
1038             if (event >= fESDTree->GetEntries())
1039                 fESDTree->Refresh();
1040             maxEvent = fESDTree->GetEntries() - 1;
1041             if (event < 0)
1042                 event = fESDTree->GetEntries() + event;
1043         }
1044
1045         if(fHLTESDTree){
1046             if (event >= fHLTESDTree->GetEntries())
1047                 fHLTESDTree->Refresh();
1048             maxEvent = fHLTESDTree->GetEntries() - 1;
1049             if (event < 0)
1050                 event = fHLTESDTree->GetEntries() + event;
1051
1052         }
1053     }
1054     else if (fAODTree)
1055     {
1056         maxEvent = fAODTree->GetEntries() - 1;
1057         if (event < 0)
1058             event = fAODTree->GetEntries() + event;
1059     }
1060     else if (fRunLoader)
1061     {
1062         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1063         if (event < 0)
1064             event = fRunLoader->GetNumberOfEvents() + event;
1065     }
1066     else if (fRawReader)
1067     {
1068         maxEvent = fRawReader->GetNumberOfEvents() - 1;
1069         if (maxEvent < 0)
1070         {
1071             maxEvent = 10000000;
1072             if (event < 0) {
1073                 Error(kEH, "current raw-data source does not support direct event access.");
1074                 return;
1075             }
1076             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1077         }
1078         else
1079         {
1080             if (event < 0)
1081                 event = fRawReader->GetNumberOfEvents() + event;
1082         }
1083     }
1084     else
1085     {
1086         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1087     }
1088     if (event < 0 || event > maxEvent)
1089     {
1090         throw (kEH + Form("event %d not present, available range [%d, %d].",
1091                           event, 0, maxEvent));
1092     }
1093
1094     TString sysInfoHeader;
1095     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1096     AliSysInfo::AddStamp(sysInfoHeader + "Start");
1097
1098     TEveManager::TRedrawDisabler rd(gEve);
1099     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1100
1101     // !!! MT this is somewhat brutal; at least optionally, one could be
1102     // a bit gentler, checking for objs owning their external refs and having
1103     // additinal parents.
1104     gEve->GetViewers()->DeleteAnnotations();
1105     fTransients->DestroyElements();
1106     for (TEveElement::List_i i = fTransientLists->BeginChildren();
1107          i != fTransientLists->EndChildren(); ++i)
1108     {
1109         (*i)->DestroyElements();
1110     }
1111     DestroyElements();
1112
1113     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1114
1115     if (fESDTree) {
1116         if (fESDTree->GetEntry(event) <= 0)
1117             throw (kEH + "failed getting required event from ESD.");
1118
1119         if (fESDfriendExists)
1120             fESD->SetESDfriend(fESDfriend);
1121     }
1122
1123     if (fHLTESDTree) {
1124         if (fHLTESDTree->GetEntry(event) <= 0)
1125             throw (kEH + "failed getting required event from HLT ESD.");
1126
1127         if (fESDfriendExists)
1128             fESD->SetESDfriend(fESDfriend);
1129     }
1130
1131     if (fAODTree) {
1132         if (fAODTree->GetEntry(event) <= 0)
1133             throw (kEH + "failed getting required event from AOD.");
1134     }
1135
1136     if (fRunLoader) {
1137         if (fRunLoader->GetEvent(event) != 0)
1138             throw (kEH + "failed getting required event.");
1139     }
1140
1141     if (fRawReader)
1142     {
1143         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1144         if (fRawReader->GotoEvent(event) == kFALSE)
1145         {
1146             // Use fallback method - iteration with NextEvent().
1147             Int_t rawEv = fEventId;
1148             if (event < rawEv)
1149             {
1150                 fRawReader->RewindEvents();
1151                 rawEv = -1;
1152             }
1153
1154             while (rawEv < event)
1155             {
1156                 if ( ! fRawReader->NextEvent())
1157                 {
1158                     fRawReader->RewindEvents();
1159                     fEventId = -1;
1160                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1161                 }
1162                 ++rawEv;
1163             }
1164             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1165         }
1166     }
1167
1168     fHasEvent = kTRUE;
1169     fEventId  = event;
1170     if (this == fgMaster)
1171     {
1172         SetName(Form("Event %d", fEventId));
1173         ElementChanged();
1174     }
1175
1176     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1177
1178     AfterNewEventLoaded();
1179
1180     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1181 }
1182
1183 void AliEveEventManager::Timeout()
1184 {
1185     Emit("Timeout()");
1186 }
1187
1188 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1189 {       
1190         DestroyElements();
1191         InitOCDB(event->GetRunNumber());
1192         printf("======================= setting event to %d\n", fEventId);
1193         SetEvent(0,0,event,0);
1194 }
1195
1196 void AliEveEventManager::NextEvent()
1197 {
1198     // Loads next event.
1199     // Does magick needed for online display when under external event control.
1200
1201     static const TEveException kEH("AliEveEventManager::NextEvent ");
1202
1203     if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1204     
1205     if (fExternalCtrl)
1206     {
1207 #ifdef ZMQ
1208         if(fIsNewEventAvaliable)
1209         {
1210             fMutex->Lock();
1211             if(fWritingToEventIndex == 0) fEventInUse = 0;
1212             else if(fWritingToEventIndex == 1) fEventInUse = 1;
1213             
1214             if(fCurrentEvent[fEventInUse])
1215             {
1216                 if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1217                 {
1218                     printf("======================= setting event to %d\n", fEventId);
1219                     
1220                     DestroyElements();
1221                     InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1222                     SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1223                     
1224                 }
1225             }
1226             fIsNewEventAvaliable = false;
1227             fMutex->UnLock();
1228         }
1229         else
1230         {
1231             cout<<"No new event is avaliable."<<endl;
1232             NoEventLoaded();
1233         }
1234 #endif
1235     }
1236     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1237     {
1238       Int_t nextevent=0;
1239       if (fPEventSelector->FindNext(nextevent))
1240       {
1241         GotoEvent(nextevent);
1242       }
1243     }
1244     else if (fEventId < GetMaxEventId(kTRUE))
1245     {
1246       GotoEvent(fEventId + 1);
1247     }
1248     
1249     gSystem->ProcessEvents();
1250     
1251     /*
1252     cout<<"VSD"<<endl;
1253     AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1254     cout<<"contructor called"<<endl;
1255     vsdCreator->CreateVSD("myVSD.root");
1256     cout<<"PO"<<endl;
1257 */
1258     //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1259 }
1260
1261 void AliEveEventManager::PrevEvent()
1262 {
1263     // Loads previous event.
1264
1265     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1266
1267     if (fAutoLoadTimerRunning)
1268     {
1269         throw (kEH + "Event auto-load timer is running.");
1270     }
1271     if (fExternalCtrl)
1272     {
1273         throw (kEH + "Event-loop is under external control.");
1274     }
1275
1276     if ((fESDTree!=0) || (fHLTESDTree!=0))
1277     {
1278         Int_t nextevent=0;
1279         if (fPEventSelector->FindPrev(nextevent))
1280         {
1281             GotoEvent(nextevent);
1282         }
1283     }
1284     else if (fEventId > 0)
1285     {
1286         GotoEvent(fEventId - 1);
1287     }
1288 }
1289
1290 void AliEveEventManager::MarkCurrentEvent()
1291 {
1292 #ifdef ZMQ
1293         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1294         struct eventStruct mark;
1295         mark.runNumber = fESD->GetRunNumber();
1296         mark.eventNumber = fESD->GetEventNumberInFile();
1297         requestMessage->messageType = REQUEST_MARK_EVENT;
1298         requestMessage->event = mark;
1299
1300         AliStorageEventManager *eventManager =
1301                 AliStorageEventManager::GetEventManagerInstance();
1302         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1303
1304         /*
1305         std::future<bool> unused = std::async([]()
1306         {
1307                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1308                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1309
1310                 if(response)
1311                 {
1312                 //fStatusLabel->SetText("Event marked");
1313                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1314                 }
1315                 else
1316                 {
1317                 //fStatusLabel->SetText("Couldn't mark this event");
1318                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1319                 }
1320         });
1321         */
1322         
1323         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1324         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1325         
1326         
1327         if(response)
1328         {
1329                 //fStatusLabel->SetText("Event marked");
1330                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1331         }
1332         else
1333         {
1334                 //fStatusLabel->SetText("Couldn't mark this event");
1335                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1336         }
1337         if(requestMessage){delete requestMessage;}
1338 #endif
1339 }
1340
1341 void AliEveEventManager::Close()
1342 {
1343     // Close the event data-files and delete ESD, ESDfriend, run-loader
1344     // and raw-reader.
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 }