Loop over marked events added to Event Display.
[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 //==============================================================================
71 //==============================================================================
72 // AliEveEventManager
73 //==============================================================================
74
75 //______________________________________________________________________________
76 //
77 // Provides interface for loading and navigating standard AliRoot data
78 // (AliRunLoader), ESD, AOD and RAW.
79 //
80 // ESDfriend is attached automatically, if the file is found.
81 //
82 // AODfriends are not attached automatically as there are several
83 // possible files involved. To have a specific AODfriend attached, call
84 // static method
85 //   AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
86 // before initializing the event-manager.
87 //
88 // Also provides interface to magnetic-field and geometry. Mostly
89 // intended as wrappers over standard AliRoot functionality for
90 // convenient use from visualizateion macros.
91 //
92 // There can be a single main event-manger, it is stored in private
93 // data member fgMaster and can be accessed via static member function
94 // GetMaster().
95 //
96 // For event overlaying and embedding one can instantiate additional
97 // event-managers via static method AddDependentManager(const TString& path).
98 // This interface is under development.
99
100 ClassImp(AliEveEventManager)
101
102 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
103 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
104 Bool_t AliEveEventManager::fgAssertAOD       = kFALSE;
105 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
106
107 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
108 AliEveEventManager::EVisibleESDTrees  AliEveEventManager::fgESDvisibleTrees(AliEveEventManager::kOfflineTree);
109 TString  AliEveEventManager::fgESDfriendsFileName("AliESDfriends.root");
110 TString  AliEveEventManager::fgAODFileName("AliAOD.root");
111 TString  AliEveEventManager::fgGAliceFileName("galice.root");
112 TString  AliEveEventManager::fgRawFileName("raw.root");
113 TString  AliEveEventManager::fgCdbUri;
114
115 TList*   AliEveEventManager::fgAODfriends = 0;
116
117 Bool_t   AliEveEventManager::fgRawFromStandardLoc = kFALSE;
118
119 Bool_t   AliEveEventManager::fgGRPLoaded    = kFALSE;
120 AliMagF* AliEveEventManager::fgMagField     = 0;
121 AliRecoParam* AliEveEventManager::fgRecoParam = 0;
122 Bool_t   AliEveEventManager::fgUniformField = kFALSE;
123
124 AliEveEventManager* AliEveEventManager::fgMaster  = 0;
125 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
126
127 AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
128     TEveEventManager(name, ""),
129     fEventId(-1),
130     fRunLoader (0),
131     fESDFile   (0), fESDTree (0), fHLTESDTree(0), fESD (0),
132     fESDfriend (0), fESDfriendExists(kFALSE),
133     fAODFile   (0), fAODTree (0), fAOD (0),
134     fRawReader (0), fEventInfo(),
135     fAutoLoad  (kFALSE),fLoopMarked(kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
136     fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
137     fGlobal    (0), fGlobalReplace (kTRUE), fGlobalUpdate (kTRUE),
138     fExecutor    (0), fTransients(0), fTransientLists(0),
139     fPEventSelector(0),
140     fSubManagers (0),
141     fAutoLoadTimerRunning(kFALSE),
142     fMutex(new TMutex()),
143     fgSubSock(EVENTS_SERVER_SUB),
144     fEventInUse(1),
145     fWritingToEventIndex(0),
146     fIsNewEventAvaliable(false),
147     fStorageDown(false),
148     fFinished(false)
149 {
150     // Constructor with event-id.
151                 
152     InitInternals();
153
154     Open();
155     if (ev >= 0)
156     {
157         GotoEvent(ev);
158     }
159     
160     if (0 == name.CompareTo("online")) {
161       fOnlineMode = kTRUE;
162     }
163     else{
164       fOnlineMode = kFALSE;
165     }
166
167
168 #ifdef ZMQ
169     cout<<"ZMQ FOUND. Starting subscriber thread."<<endl;
170     fEventListenerThread = new TThread("fEventListenerThread",DispatchEventListener,(void*)this);
171     fEventListenerThread->Run();
172     
173     fStorageManagerWatcherThread = new TThread("fStorageManagerWatcherThread",DispatchStorageManagerWatcher,(void*)this);
174     fStorageManagerWatcherThread->Run();
175 #else
176     cout<<"NO ZMQ FOUND. Online events not avaliable."<<endl;
177 #endif
178 }
179
180 AliEveEventManager::~AliEveEventManager()
181 {
182     // Destructor.
183     
184     fFinished = true;
185     
186     if(fEventListenerThread)
187     {
188         fEventListenerThread->Kill();
189         delete fEventListenerThread;
190     }
191     if(fStorageManagerWatcherThread)
192     {
193         fStorageManagerWatcherThread->Kill();
194         delete fStorageManagerWatcherThread;
195     }
196     
197     
198     fAutoLoadTimer->Stop();
199     fAutoLoadTimer->Disconnect("Timeout");
200     fAutoLoadTimer->Disconnect("AutoLoadNextEvent");
201
202     AliEveEventManager *manager = AliEveEventManager::GetCurrent();
203     manager->Disconnect("StorageManagerOk");
204     manager->Disconnect("StorageManagerDown");
205
206     if(fSubManagers){delete fSubManagers;}
207     if(fMutex){delete fMutex;}
208     
209     if (fIsOpen)
210     {
211         Close();
212     }
213
214 //    fTransients->DecDenyDestroy();
215 //    fTransients->Destroy();
216
217 //    fTransientLists->DecDenyDestroy();
218 //    fTransientLists->Destroy();
219
220     //delete fExecutor;
221 }
222
223 void AliEveEventManager::GetNextEvent()
224 {
225 #ifdef ZMQ
226     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
227     eventManager->CreateSocket(EVENTS_SERVER_SUB);
228     eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
229     
230     fCurrentEvent[0]=0;
231     fCurrentEvent[1]=0;
232
233     AliESDEvent *tmpEvent = NULL;
234     
235     // get list of marked events:
236     struct listRequestStruct list;
237
238     list.runNumber[0]=0;
239     list.runNumber[1]=999999;
240     list.eventNumber[0]=0;
241     list.eventNumber[1]=999999;
242     list.marked[0]=1;
243     list.marked[1]=1;
244     list.multiplicity[0]=1;
245     list.multiplicity[1]=999999;
246     strcpy(list.system[0],"p-p");
247     strcpy(list.system[1],"A-A");
248     
249     struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
250     requestMessage->messageType = REQUEST_LIST_EVENTS;
251     requestMessage->list = list;
252     
253     eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
254     vector<serverListStruct> receivedList = eventManager->GetServerListVector(SERVER_COMMUNICATION_REQ);
255     
256     cout<<"EVENT DISPLAY -- received list of marked events"<<endl;
257     
258     for(int i=0;i<receivedList.size();i++)
259     {
260         cout<<"ev:"<<receivedList[i].eventNumber<<endl;
261     }
262     
263     int iter=0;
264     while(!fFinished)
265     {
266         if(!fLoopMarked)
267         {
268             cout<<"taking event from reco server"<<endl;
269             tmpEvent = eventManager->GetEvent(EVENTS_SERVER_SUB,5);
270             if(!tmpEvent){sleep(1);}
271         }
272         else
273         {
274             cout<<"taking event from storage manager"<<endl;
275             if(iter<receivedList.size())
276             {
277                 struct eventStruct mark;
278                 mark.runNumber = receivedList[iter].runNumber;
279                 mark.eventNumber = receivedList[iter].eventNumber;
280              
281                 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
282                 requestMessage->messageType = REQUEST_GET_EVENT;
283                 requestMessage->event = mark;
284                 
285                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
286                 tmpEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
287                 
288                 iter++;
289                 sleep(1);
290             }
291             else{iter=0;}
292         }
293         
294         if(tmpEvent)
295         {
296             if(tmpEvent->GetRunNumber()>=0)
297             {
298                 fMutex->Lock();
299                 if(fEventInUse == 0){fWritingToEventIndex = 1;}
300                 else if(fEventInUse == 1){fWritingToEventIndex = 0;}
301                 cout<<"Received new event:"<<tmpEvent->GetEventNumberInFile()<<endl;
302                 if(fCurrentEvent[fWritingToEventIndex])
303                 {
304                     delete fCurrentEvent[fWritingToEventIndex];
305                     fCurrentEvent[fWritingToEventIndex]=0;
306                 }
307                 fCurrentEvent[fWritingToEventIndex] = tmpEvent;
308                 fIsNewEventAvaliable = true;
309                 NewEventLoaded();
310                 fMutex->UnLock();
311             }
312         }
313         else
314         {
315             cout<<"didn't receive new event"<<endl;
316         }
317     }
318     delete requestMessage;
319     
320 #endif
321 }
322
323 void AliEveEventManager::CheckStorageStatus()
324 {
325 #ifdef ZMQ
326     AliEveConfigManager *configManager = AliEveConfigManager::GetMaster();
327     configManager->ConnectEventManagerSignals();
328     
329     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
330     eventManager->CreateSocket(CLIENT_COMMUNICATION_REQ);
331     
332     struct clientRequestStruct *request = new struct clientRequestStruct;
333     request->messageType = REQUEST_CONNECTION;
334     
335     while (!fFinished)
336     {
337         if(eventManager->Send(request,CLIENT_COMMUNICATION_REQ,5000))
338         {
339             StorageManagerOk();
340             long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
341             fStorageDown = kFALSE;
342         }
343         else
344         {
345             StorageManagerDown();
346             cout<<"WARNING -- Storage Manager is DOWN!!"<<endl;
347             fStorageDown = kTRUE;
348         }
349         sleep(1);
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
803         if (fgCdbUri.BeginsWith("local://"))
804         {
805             TString curPath = gSystem->WorkingDirectory();
806             TString grp     = "GRP/GRP/Data";
807             TString grppath = curPath + "/" + grp;
808             if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
809             {
810                 if (cdb->GetSpecificStorage(grp))
811                 {
812                     Warning(kEH, "Local GRP exists, but the specific storage is already set.");
813                 }
814                 else
815                 {
816                     Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
817                     TString lpath("local://");
818                     lpath += curPath;
819                     cdb->SetSpecificStorage(grp, lpath);
820                 }
821             }
822         }
823     }
824 }
825
826 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
827 {
828     // Set an event from an external source.
829     // The method is used in the online visualisation.
830     // AOD is not supported.
831
832     static const TEveException kEH("AliEveEventManager::SetEvent ");
833
834     if (fIsOpen)
835     {
836         Warning(kEH, "Event-files were open. Closing and switching to external control.");
837         Close();
838     }
839
840                         Info(kEH,"setting it!!! ============================");
841
842     fRunLoader = runLoader;
843     fRawReader = rawReader;
844     fESD       = esd;
845     fESDfriend = esdf;
846     fAOD       = 0;
847
848     fEventId++;
849     fHasEvent     = kTRUE;
850     fExternalCtrl = kTRUE;
851
852     SetTitle("Online event in memory");
853     SetName ("Online Event");
854     ElementChanged();
855
856     AfterNewEventLoaded();
857
858     if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
859     
860 }
861
862 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
863 {
864     // Returns maximum available event id.
865     // If under external control or event is not opened -1 is returned.
866     // If raw-data is the only data-source this can not be known
867     // and 10,000,000 is returned.
868     // If neither data-source is initialised an exception is thrown.
869     // If refresh_esd is true and ESD is the primary event-data source
870     // its header is re-read from disk.
871
872     static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
873
874     if (fExternalCtrl || fIsOpen == kFALSE)
875     {
876         return -1;
877     }
878
879     if ((fESDTree!=0) || (fHLTESDTree!=0))
880     {
881         if (refreshESD)
882         {
883             if(fESDTree!=0) fESDTree->Refresh();
884             if(fHLTESDTree!=0) fHLTESDTree->Refresh();
885             fPEventSelector->Update();
886         }
887
888         Int_t maxEventId=0;
889         switch(fgESDvisibleTrees){
890         default:
891         case AliEveEventManager::kOfflineTree :
892             maxEventId = fESDTree->GetEntries() - 1;
893             break;
894         case AliEveEventManager::kHLTTree :
895             maxEventId = fHLTESDTree->GetEntries() - 1;
896             break;
897        }
898
899         return maxEventId;
900     }
901     else if (fAODTree)
902     {
903         return fAODTree->GetEntries() - 1;
904     }
905     else if (fRunLoader)
906     {
907         return fRunLoader->GetNumberOfEvents() - 1;
908     }
909     else if (fRawReader)
910     {
911         Int_t n = fRawReader->GetNumberOfEvents() - 1;
912         return n > -1 ? n : 10000000;
913     }
914     else
915     {
916         throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
917     }
918 }
919
920 void AliEveEventManager::GotoEvent(Int_t event)
921 {
922     cout<<"Go to event:"<<event<<endl;
923     // Load data for specified event.
924     // If event is out of range an exception is thrown and old state
925     // is preserved.
926     // After successful loading of event, the virtual function
927     // AfterNewEventLoaded() is called. This executes commands that
928     // were registered via TEveEventManager::AddNewEventCommand().
929     //
930     // If event is negative, it is subtracted from the number of
931     // available events, thus passing -1 will load the last event.
932     // This is not supported when raw-data is the only data-source
933     // as the number of events is not known.
934
935     static const TEveException kEH("AliEveEventManager::GotoEvent ");
936
937     if (fAutoLoadTimerRunning)
938     {
939         throw (kEH + "Event auto-load timer is running.");
940     }
941     if (fExternalCtrl)
942     {
943       // throw (kEH + "Event-loop is under external control.");
944 #ifdef ZMQ
945       if (fStorageDown && -1 == event) 
946       {
947         NextEvent();
948         return;
949       }
950
951       if (fESD)
952       {
953           // create new server request:
954           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
955             
956           // set request type:
957           if (event == -1)      {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
958           else  if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
959           else  if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
960           else  if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
961             
962           // set event struct:
963           struct eventStruct eventToLoad;
964           eventToLoad.runNumber = fESD->GetRunNumber();
965           eventToLoad.eventNumber = fESD->GetEventNumberInFile();
966           requestMessage->event = eventToLoad;
967             
968           // create event manager:
969           AliStorageEventManager *eventManager =
970             AliStorageEventManager::GetEventManagerInstance();
971           AliESDEvent *resultEvent = NULL;
972             
973           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
974           fMutex->Lock();
975             
976           // send request and receive event:
977           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
978           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
979             
980           if(resultEvent)
981           {
982               DestroyElements();
983               InitOCDB(resultEvent->GetRunNumber());
984               SetEvent(0,0,resultEvent,0);
985           }
986           else
987           {
988               if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
989               if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
990               if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
991               if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
992           }
993             
994           fMutex->UnLock();
995         }
996       else
997       {
998           cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
999
1000           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1001           requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1002             
1003           AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1004           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1005           AliESDEvent *resultEvent = NULL;
1006             
1007           fMutex->Lock();
1008           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1009           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1010             
1011           if(resultEvent)
1012           {
1013               fESD=resultEvent;
1014               DestroyElements();
1015               InitOCDB(resultEvent->GetRunNumber());
1016               SetEvent(0,0,resultEvent,0);
1017           }
1018           else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1019           fMutex->UnLock();
1020       }
1021 #endif  
1022
1023     }
1024     else if (!fIsOpen)
1025     {
1026         throw (kEH + "Event-files not opened.");
1027     }
1028
1029     fEventInfo.Reset();
1030
1031     fHasEvent = kFALSE;
1032
1033     Int_t maxEvent = 0;
1034     if ((fESDTree!=0) || (fHLTESDTree!=0))
1035     {
1036         if(fESDTree){
1037             if (event >= fESDTree->GetEntries())
1038                 fESDTree->Refresh();
1039             maxEvent = fESDTree->GetEntries() - 1;
1040             if (event < 0)
1041                 event = fESDTree->GetEntries() + event;
1042         }
1043
1044         if(fHLTESDTree){
1045             if (event >= fHLTESDTree->GetEntries())
1046                 fHLTESDTree->Refresh();
1047             maxEvent = fHLTESDTree->GetEntries() - 1;
1048             if (event < 0)
1049                 event = fHLTESDTree->GetEntries() + event;
1050
1051         }
1052     }
1053     else if (fAODTree)
1054     {
1055         maxEvent = fAODTree->GetEntries() - 1;
1056         if (event < 0)
1057             event = fAODTree->GetEntries() + event;
1058     }
1059     else if (fRunLoader)
1060     {
1061         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1062         if (event < 0)
1063             event = fRunLoader->GetNumberOfEvents() + event;
1064     }
1065     else if (fRawReader)
1066     {
1067         maxEvent = fRawReader->GetNumberOfEvents() - 1;
1068         if (maxEvent < 0)
1069         {
1070             maxEvent = 10000000;
1071             if (event < 0) {
1072                 Error(kEH, "current raw-data source does not support direct event access.");
1073                 return;
1074             }
1075             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1076         }
1077         else
1078         {
1079             if (event < 0)
1080                 event = fRawReader->GetNumberOfEvents() + event;
1081         }
1082     }
1083     else
1084     {
1085         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1086     }
1087     if (event < 0 || event > maxEvent)
1088     {
1089         throw (kEH + Form("event %d not present, available range [%d, %d].",
1090                           event, 0, maxEvent));
1091     }
1092
1093     TString sysInfoHeader;
1094     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1095     AliSysInfo::AddStamp(sysInfoHeader + "Start");
1096
1097     TEveManager::TRedrawDisabler rd(gEve);
1098     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1099
1100     // !!! MT this is somewhat brutal; at least optionally, one could be
1101     // a bit gentler, checking for objs owning their external refs and having
1102     // additinal parents.
1103     gEve->GetViewers()->DeleteAnnotations();
1104     fTransients->DestroyElements();
1105     for (TEveElement::List_i i = fTransientLists->BeginChildren();
1106          i != fTransientLists->EndChildren(); ++i)
1107     {
1108         (*i)->DestroyElements();
1109     }
1110     DestroyElements();
1111
1112     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1113
1114     if (fESDTree) {
1115         if (fESDTree->GetEntry(event) <= 0)
1116             throw (kEH + "failed getting required event from ESD.");
1117
1118         if (fESDfriendExists)
1119             fESD->SetESDfriend(fESDfriend);
1120     }
1121
1122     if (fHLTESDTree) {
1123         if (fHLTESDTree->GetEntry(event) <= 0)
1124             throw (kEH + "failed getting required event from HLT ESD.");
1125
1126         if (fESDfriendExists)
1127             fESD->SetESDfriend(fESDfriend);
1128     }
1129
1130     if (fAODTree) {
1131         if (fAODTree->GetEntry(event) <= 0)
1132             throw (kEH + "failed getting required event from AOD.");
1133     }
1134
1135     if (fRunLoader) {
1136         if (fRunLoader->GetEvent(event) != 0)
1137             throw (kEH + "failed getting required event.");
1138     }
1139
1140     if (fRawReader)
1141     {
1142         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1143         if (fRawReader->GotoEvent(event) == kFALSE)
1144         {
1145             // Use fallback method - iteration with NextEvent().
1146             Int_t rawEv = fEventId;
1147             if (event < rawEv)
1148             {
1149                 fRawReader->RewindEvents();
1150                 rawEv = -1;
1151             }
1152
1153             while (rawEv < event)
1154             {
1155                 if ( ! fRawReader->NextEvent())
1156                 {
1157                     fRawReader->RewindEvents();
1158                     fEventId = -1;
1159                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1160                 }
1161                 ++rawEv;
1162             }
1163             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1164         }
1165     }
1166
1167     fHasEvent = kTRUE;
1168     fEventId  = event;
1169     if (this == fgMaster)
1170     {
1171         SetName(Form("Event %d", fEventId));
1172         ElementChanged();
1173     }
1174
1175     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1176
1177     AfterNewEventLoaded();
1178
1179     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1180 }
1181
1182 void AliEveEventManager::Timeout()
1183 {
1184     Emit("Timeout()");
1185 }
1186
1187 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1188 {       
1189         DestroyElements();
1190         InitOCDB(event->GetRunNumber());
1191         printf("======================= setting event to %d\n", fEventId);
1192         SetEvent(0,0,event,0);
1193 }
1194
1195 void AliEveEventManager::NextEvent()
1196 {
1197     // Loads next event.
1198     // Does magick needed for online display when under external event control.
1199
1200     static const TEveException kEH("AliEveEventManager::NextEvent ");
1201
1202     if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1203     
1204     if (fExternalCtrl)
1205     {
1206 #ifdef ZMQ
1207         if(fIsNewEventAvaliable)
1208         {
1209             fMutex->Lock();
1210             if(fWritingToEventIndex == 0) fEventInUse = 0;
1211             else if(fWritingToEventIndex == 1) fEventInUse = 1;
1212             
1213             if(fCurrentEvent[fEventInUse])
1214             {
1215                 if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1216                 {
1217                     printf("======================= setting event to %d\n", fEventId);
1218                     
1219                     DestroyElements();
1220                     InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1221                     SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1222                     
1223                 }
1224             }
1225             fIsNewEventAvaliable = false;
1226             fMutex->UnLock();
1227         }
1228         else
1229         {
1230             cout<<"No new event is avaliable."<<endl;
1231             NoEventLoaded();
1232         }
1233 #endif
1234     }
1235     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1236     {
1237       Int_t nextevent=0;
1238       if (fPEventSelector->FindNext(nextevent))
1239       {
1240         GotoEvent(nextevent);
1241       }
1242     }
1243     else if (fEventId < GetMaxEventId(kTRUE))
1244     {
1245       GotoEvent(fEventId + 1);
1246     }
1247     
1248     gSystem->ProcessEvents();
1249     
1250     /*
1251     cout<<"VSD"<<endl;
1252     AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1253     cout<<"contructor called"<<endl;
1254     vsdCreator->CreateVSD("myVSD.root");
1255     cout<<"PO"<<endl;
1256 */
1257     //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1258 }
1259
1260 void AliEveEventManager::PrevEvent()
1261 {
1262     // Loads previous event.
1263
1264     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1265
1266     if (fAutoLoadTimerRunning)
1267     {
1268         throw (kEH + "Event auto-load timer is running.");
1269     }
1270     if (fExternalCtrl)
1271     {
1272         throw (kEH + "Event-loop is under external control.");
1273     }
1274
1275     if ((fESDTree!=0) || (fHLTESDTree!=0))
1276     {
1277         Int_t nextevent=0;
1278         if (fPEventSelector->FindPrev(nextevent))
1279         {
1280             GotoEvent(nextevent);
1281         }
1282     }
1283     else if (fEventId > 0)
1284     {
1285         GotoEvent(fEventId - 1);
1286     }
1287 }
1288
1289 void AliEveEventManager::MarkCurrentEvent()
1290 {
1291 #ifdef ZMQ
1292         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1293         struct eventStruct mark;
1294         mark.runNumber = fESD->GetRunNumber();
1295         mark.eventNumber = fESD->GetEventNumberInFile();
1296         requestMessage->messageType = REQUEST_MARK_EVENT;
1297         requestMessage->event = mark;
1298
1299         AliStorageEventManager *eventManager =
1300                 AliStorageEventManager::GetEventManagerInstance();
1301         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1302
1303         /*
1304         std::future<bool> unused = std::async([]()
1305         {
1306                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1307                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1308
1309                 if(response)
1310                 {
1311                 //fStatusLabel->SetText("Event marked");
1312                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1313                 }
1314                 else
1315                 {
1316                 //fStatusLabel->SetText("Couldn't mark this event");
1317                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1318                 }
1319         });
1320         */
1321         
1322         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1323         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1324         
1325         
1326         if(response)
1327         {
1328                 //fStatusLabel->SetText("Event marked");
1329                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1330         }
1331         else
1332         {
1333                 //fStatusLabel->SetText("Couldn't mark this event");
1334                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1335         }
1336         if(requestMessage){delete requestMessage;}
1337 #endif
1338 }
1339
1340 void AliEveEventManager::Close()
1341 {
1342     // Close the event data-files and delete ESD, ESDfriend, run-loader
1343     // and raw-reader.
1344
1345     static const TEveException kEH("AliEveEventManager::Close ");
1346
1347     if (!fIsOpen)
1348     {
1349         throw (kEH + "Event-files not opened.");
1350     }
1351
1352     if (fAutoLoadTimerRunning)
1353         StopAutoLoadTimer();
1354
1355     if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1356         delete fESD;       fESD       = 0;
1357         // delete fESDfriend; // friend tree is deleted with the tree
1358         fESDfriend = 0;
1359         fESDfriendExists = kFALSE;
1360
1361         if(fESDTree) { delete fESDTree;   fESDTree = 0; }
1362         if(fHLTESDTree) { delete fHLTESDTree;   fHLTESDTree = 0; }
1363         delete fESDFile;   fESDFile = 0;
1364     }
1365
1366     if (fAODTree) {
1367         delete fAOD;       fAOD       = 0;
1368
1369         delete fAODTree;   fAODTree = 0;
1370         delete fAODFile;   fAODFile = 0;
1371     }
1372
1373     if (fRunLoader) {
1374         delete fRunLoader; fRunLoader = 0;
1375     }
1376
1377     if (fRawReader) {
1378         delete fRawReader; fRawReader = 0;
1379     }
1380
1381     fEventId  = -1;
1382     fIsOpen   = kFALSE;
1383     fHasEvent = kFALSE;
1384 }
1385
1386
1387 //------------------------------------------------------------------------------
1388 // Static convenience functions, mainly used from macros.
1389 //------------------------------------------------------------------------------
1390
1391 Int_t AliEveEventManager::CurrentEventId()
1392 {
1393     // Return current event-id.
1394
1395     static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1396
1397     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1398         throw (kEH + "ALICE event not ready.");
1399     return fgCurrent->GetEventId();
1400 }
1401
1402 Bool_t AliEveEventManager::HasRunLoader()
1403 {
1404     // Check if AliRunLoader is initialized.
1405
1406     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1407 }
1408
1409 Bool_t AliEveEventManager::HasESD()
1410 {
1411     // Check if AliESDEvent is initialized.
1412
1413     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1414 }
1415
1416 Bool_t AliEveEventManager::HasESDfriend()
1417 {
1418     // Check if AliESDfriend is initialized.
1419
1420     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1421 }
1422
1423 Bool_t AliEveEventManager::HasAOD()
1424 {
1425     // Check if AliESDEvent is initialized.
1426
1427     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1428 }
1429
1430 Bool_t AliEveEventManager::HasRawReader()
1431 {
1432     // Check if raw-reader is initialized.
1433
1434     return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1435 }
1436
1437 AliRunLoader* AliEveEventManager::AssertRunLoader()
1438 {
1439     // Make sure AliRunLoader is initialized and return it.
1440     // Throws exception in case run-loader is not available.
1441     // Static utility for macros.
1442
1443     static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
1444
1445     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1446         throw (kEH + "ALICE event not ready.");
1447     if (fgCurrent->fRunLoader == 0)
1448         throw (kEH + "AliRunLoader not initialised.");
1449     return fgCurrent->fRunLoader;
1450 }
1451
1452 AliESDEvent* AliEveEventManager::AssertESD()
1453 {
1454     // Make sure AliESDEvent is initialized and return it.
1455     // Throws exception in case ESD is not available.
1456     // Static utility for macros.
1457
1458     static const TEveException kEH("AliEveEventManager::AssertESD ");
1459
1460     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1461         throw (kEH + "ALICE event not ready.");
1462     if (fgCurrent->fESD == 0)
1463         throw (kEH + "AliESD not initialised.");
1464     return fgCurrent->fESD;
1465 }
1466
1467 AliESDfriend* AliEveEventManager::AssertESDfriend()
1468 {
1469     // Make sure AliESDfriend is initialized and return it.
1470     // Throws exception in case ESDfriend-loader is not available.
1471     // Static utility for macros.
1472
1473     static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1474
1475     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1476         throw (kEH + "ALICE event not ready.");
1477     if (fgCurrent->fESDfriend == 0)
1478         throw (kEH + "AliESDfriend not initialised.");
1479     return fgCurrent->fESDfriend;
1480 }
1481
1482 AliAODEvent* AliEveEventManager::AssertAOD()
1483 {
1484     // Make sure AliAODEvent is initialized and return it.
1485     // Throws exception in case AOD is not available.
1486     // Static utility for macros.
1487
1488     static const TEveException kEH("AliEveEventManager::AssertAOD ");
1489
1490     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1491         throw (kEH + "ALICE event not ready.");
1492     if (fgCurrent->fAOD == 0)
1493         throw (kEH + "AliAOD not initialised.");
1494     return fgCurrent->fAOD;
1495 }
1496
1497 AliRawReader* AliEveEventManager::AssertRawReader()
1498 {
1499     // Make sure raw-reader is initialized and return it.
1500
1501     static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1502
1503     if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1504         throw (kEH + "ALICE event not ready.");
1505     if (fgCurrent->fRawReader == 0)
1506         throw (kEH + "RawReader not ready.");
1507
1508     return fgCurrent->fRawReader;
1509 }
1510
1511 //==============================================================================
1512
1513 AliMagF* AliEveEventManager::AssertMagField()    
1514 {        
1515     // Make sure AliMagF is initialized and returns it.
1516     // Throws exception in case magnetic field is not available.
1517     // Static utility for macros.
1518
1519     static const TEveException kEH("AliEveEventManager::AssertMagField ");
1520
1521     if (fgMagField)
1522         return fgMagField;
1523
1524     if (TGeoGlobalMagField::Instance()->GetField())
1525     {
1526         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1527         if (fgMagField == 0)
1528             throw kEH + "Global field set, but it is not AliMagF.";
1529         return fgMagField;
1530     }
1531
1532     if (!fgGRPLoaded)
1533     {
1534         InitGRP();
1535     }
1536
1537     if (TGeoGlobalMagField::Instance()->GetField())
1538     {
1539         fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1540         if (fgMagField == 0)
1541             throw kEH + "Global field set, but it is not AliMagF.";
1542     }
1543     else
1544     {
1545         throw kEH + "Could not initialize magnetic field.";
1546     }
1547
1548     return fgMagField;
1549 }
1550
1551 TGeoManager* AliEveEventManager::AssertGeometry()
1552 {
1553     // Make sure AliGeomManager is initialized and returns the
1554     // corresponding TGeoManger.
1555     // gGeoManager is set to the return value.
1556     // Throws exception if geometry can not be loaded or if it is not
1557     // available and the TGeoManager is locked.
1558     // Static utility for macros.
1559
1560     static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1561
1562     if (AliGeomManager::GetGeometry() == 0)
1563     {
1564         if (TGeoManager::IsLocked())
1565             throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1566
1567         gGeoManager = 0;
1568         AliGeomManager::LoadGeometry();
1569         if ( ! AliGeomManager::GetGeometry())
1570         {
1571             throw (kEH + "can not load geometry.");
1572         }
1573         if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1574         {
1575             ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1576             // throw (kEH + "could not apply align objs.");
1577         }
1578         AliGeomManager::GetGeometry()->DefaultColors();
1579     }
1580
1581     gGeoManager = AliGeomManager::GetGeometry();
1582     return gGeoManager;
1583 }
1584
1585 AliRecoParam* AliEveEventManager::AssertRecoParams()
1586 {
1587     if(!fgRecoParam)
1588         InitRecoParam();
1589
1590     return fgRecoParam;
1591 }
1592
1593 Bool_t AliEveEventManager::InitRecoParam()
1594 {
1595     // This is mostly a reap-off from reconstruction
1596     // The method accesses OCDB and retrieves all
1597     // the available reco-param objects from there.
1598
1599     fgRecoParam = new AliRecoParam;
1600     const Int_t  kNDetectors = 14;
1601
1602     static const TEveException kEH("AliEveEventManager::InitRecoParam");
1603
1604     Bool_t isOK = kTRUE;
1605
1606     if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1607         ::Info(kEH, "Using custom GRP reconstruction parameters");
1608     }
1609     else {
1610         ::Info(kEH, "Loading GRP reconstruction parameter objects");
1611
1612         AliCDBPath path("GRP","Calib","RecoParam");
1613         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1614         if(!entry){
1615             ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
1616             isOK = kFALSE;
1617         }
1618         else {
1619             TObject *recoParamObj = entry->GetObject();
1620             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1621                 // GRP has a normal TobjArray of AliDetectorRecoParam objects
1622                 // Registering them in AliRecoParam
1623                 fgRecoParam->AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
1624             }
1625             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1626                 // GRP has only onse set of reco parameters
1627                 // Registering it in AliRecoParam
1628                 ::Info(kEH, "Single set of GRP reconstruction parameters found");
1629                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1630                 fgRecoParam->AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1631             }
1632             else {
1633                 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1634                 isOK = kFALSE;
1635             }
1636             entry->SetOwner(0);
1637         }
1638     }
1639
1640     const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1641
1642
1643     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1644
1645         if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1646             ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1647             continue;
1648         }
1649
1650         ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1651
1652         AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1653         AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1654         if(!entry){
1655             ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
1656             isOK = kFALSE;
1657         }
1658         else {
1659             TObject *recoParamObj = entry->GetObject();
1660             if (dynamic_cast<TObjArray*>(recoParamObj)) {
1661                 // The detector has a normal TobjArray of AliDetectorRecoParam objects
1662                 // Registering them in AliRecoParam
1663                 fgRecoParam->AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
1664             }
1665             else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1666                 // The detector has only onse set of reco parameters
1667                 // Registering it in AliRecoParam
1668                 ::Info(kEH, "Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]);
1669                 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1670                 fgRecoParam->AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1671             }
1672             else {
1673                 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1674                 isOK = kFALSE;
1675             }
1676             entry->SetOwner(0);
1677
1678         }
1679     }
1680
1681     if(!isOK) {
1682         delete fgRecoParam;
1683         fgRecoParam = 0;
1684     }
1685
1686     return isOK;
1687 }
1688
1689 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1690 {
1691     if(!fESDFile && !fESD) return 0;
1692
1693     static const TEveException kEH("AliEveEventManager::readESDTree ");
1694
1695     TTree* tempTree = 0;
1696
1697     tempTree =(TTree*) fESDFile->Get(treeName);
1698     if (tempTree != 0)
1699     {
1700         TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1701         if (esdFriendFile)
1702         {
1703             if (!esdFriendFile->IsZombie())
1704             {
1705                 esdFriendFile->Close();
1706                 fESDfriendExists = kTRUE;
1707                 tempTree->SetBranchStatus ("ESDfriend*", 1);
1708             }
1709             delete esdFriendFile;
1710         }
1711
1712         fESD->ReadFromTree(tempTree);
1713         if (fESDfriendExists)
1714         {
1715             fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1716             Info(kEH, "found and attached ESD friend.");
1717         }
1718         else
1719         {
1720             Warning(kEH, "ESDfriend not found.");
1721         }
1722
1723         if (tempTree->GetEntry(0) <= 0)
1724         {
1725             Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1726         }
1727         else
1728         {
1729             if (runNo < 0)
1730                 runNo = fESD->GetESDRun()->GetRunNumber();
1731         }
1732     }
1733     else // tree == 0
1734     {
1735         Warning(kEH, "failed getting the tree:%s", treeName);
1736     }
1737
1738     return tempTree;
1739 }
1740
1741
1742 //------------------------------------------------------------------------------
1743
1744 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1745 {
1746     // Create and attach a dependent event-manager.
1747     // It is not added into eve list tree.
1748
1749     static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1750
1751     if (fgMaster == 0)
1752         throw(kEH + "Master event-manager must be instantiated first.");
1753
1754     if (fgMaster->fSubManagers == 0)
1755     {
1756         fgMaster->fSubManagers = new TList;
1757         fgMaster->fSubManagers->SetOwner(kTRUE);
1758     }
1759
1760     AliEveEventManager* new_mgr = 0;
1761     fgCurrent = 0;
1762     try
1763     {
1764         new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1765         new_mgr->SetFilesPath(path);
1766         fgMaster->fSubManagers->Add(new_mgr);
1767     }
1768     catch (TEveException& exc)
1769     {
1770         ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1771     }
1772     fgCurrent = fgMaster;
1773
1774     return new_mgr;
1775 }
1776
1777 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1778 {
1779     // Get a dependant manager by name.
1780     // This will not change the current manager, use helper class
1781     // AliEveEventManager::CurrentChanger for that.
1782
1783     static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1784
1785     if (fgMaster == 0)
1786         throw(kEH + "Master event-manager must be instantiated first.");
1787
1788     if (fgMaster->fSubManagers == 0)
1789         return 0;
1790
1791     return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1792 }
1793
1794 AliEveEventManager* AliEveEventManager::GetMaster()
1795 {
1796     // Get master event-manager.
1797
1798     return fgMaster;
1799 }
1800
1801 AliEveEventManager* AliEveEventManager::GetCurrent()
1802 {
1803     // Get current event-manager.
1804
1805     return fgCurrent;
1806 }
1807
1808 void AliEveEventManager::RegisterTransient(TEveElement* element)
1809 {
1810     GetCurrent()->fTransients->AddElement(element);
1811 }
1812
1813 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1814 {
1815     GetCurrent()->fTransientLists->AddElement(element);
1816 }
1817
1818 //------------------------------------------------------------------------------
1819 // Autoloading of events
1820 //------------------------------------------------------------------------------
1821
1822 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1823 {
1824     // Set the auto-load time in seconds
1825
1826     fAutoLoadTime = time;
1827 }
1828
1829 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1830 {
1831     // Set the automatic event loading mode
1832
1833     static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1834
1835     if (fAutoLoad == autoLoad)
1836     {
1837         Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1838         return;
1839     }
1840
1841     fAutoLoad = autoLoad;
1842     if (fAutoLoad)
1843     {
1844         StartAutoLoadTimer();
1845     }
1846     else
1847     {
1848         StopAutoLoadTimer();
1849     }
1850 }
1851
1852 void AliEveEventManager::SetLoopMarked(Bool_t loopMarked)
1853 {
1854     // Set the automatic event loading mode
1855     fLoopMarked = loopMarked;
1856     if (fLoopMarked){StartAutoLoadTimer();}
1857     else{StopAutoLoadTimer();}
1858 }
1859
1860 void AliEveEventManager::SetTrigSel(Int_t trig)
1861 {
1862     static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1863
1864     if (!fRawReader)
1865     {
1866         Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1867         return;
1868     }
1869     else
1870     {
1871         ULong64_t trigMask = 0;
1872         if (trig >= 0) trigMask = (1ull << trig);
1873         Info(kEH,"Trigger selection: 0x%llx",trigMask);
1874         fRawReader->SelectEvents(-1,trigMask,NULL);
1875     }
1876 }
1877
1878 void AliEveEventManager::StartAutoLoadTimer()
1879 {
1880     // Start the auto-load timer.
1881
1882     fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1883     fAutoLoadTimer->Reset();
1884     fAutoLoadTimer->TurnOn();
1885     fAutoLoadTimerRunning = kTRUE;
1886 }
1887
1888 void AliEveEventManager::StopAutoLoadTimer()
1889 {
1890     // Stop the auto-load timer.
1891
1892     fAutoLoadTimerRunning = kFALSE;
1893     fAutoLoadTimer->TurnOff();
1894 }
1895
1896 void AliEveEventManager::AutoLoadNextEvent()
1897 {
1898         // Called from auto-load timer, so it has to be public.
1899         // Do NOT call it directly.
1900
1901         static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1902           
1903         Info(kEH, "called!");
1904
1905         if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1906         {
1907                 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1908                 return;
1909         }
1910
1911         StopAutoLoadTimer();
1912         NextEvent();
1913         if (fAutoLoad || fLoopMarked)
1914                 StartAutoLoadTimer();
1915 }
1916
1917 //------------------------------------------------------------------------------
1918 // Post event-loading functions
1919 //------------------------------------------------------------------------------
1920
1921 void AliEveEventManager::AfterNewEventLoaded()
1922 {
1923   // Execute registered macros and commands.
1924   // At the end emit NewEventLoaded signal.
1925   //
1926   // Virtual from TEveEventManager.
1927
1928   static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1929
1930   Info(kEH, "------------------!!!------------");
1931                       
1932   NewEventDataLoaded();
1933   if (fExecutor) fExecutor->ExecMacros();
1934
1935   TEveEventManager::AfterNewEventLoaded();
1936   NewEventLoaded();
1937
1938   if (this == fgMaster && fSubManagers != 0)
1939   {
1940     TIter next(fSubManagers);
1941     while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1942     {
1943       gEve->SetCurrentEvent(fgCurrent);
1944       try
1945       {
1946         fgCurrent->GotoEvent(fEventId);
1947       }
1948       catch (TEveException& exc)
1949       {
1950         // !!! Should somehow tag / disable / remove it?
1951         Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1952               fEventId, fgCurrent->GetName(), exc.Data());
1953       }
1954       Info(kEH, "------------------!!! while() gEve->SetCurrentEvent() ------------");
1955     }
1956     fgCurrent = fgMaster;
1957     Info(kEH, "------------------!!! while() gEve->SetCurrentEvent(MASTER) ------------");
1958     gEve->SetCurrentEvent(fgMaster);
1959   }
1960 }
1961
1962 void AliEveEventManager::NewEventDataLoaded()
1963 {
1964     // Emit NewEventDataLoaded signal.
1965     Emit("NewEventDataLoaded()");
1966 }
1967 void AliEveEventManager::NewEventLoaded()
1968 {
1969     // Emit NewEventLoaded signal.
1970     Emit("NewEventLoaded()");
1971 }
1972 void AliEveEventManager::NoEventLoaded()
1973 {
1974     // Emit NoEventLoaded signal.
1975     Emit("NoEventLoaded()");
1976 }
1977 void AliEveEventManager::StorageManagerOk()
1978 {
1979     // Emit StorageManagerOk signal.
1980     Emit("StorageManagerOk()");
1981 }
1982 void AliEveEventManager::StorageManagerDown()
1983 {
1984     // Emit StorageManagerOk signal.
1985     Emit("StorageManagerDown()");
1986 }
1987
1988
1989 //------------------------------------------------------------------------------
1990 // Event info dumpers
1991 //------------------------------------------------------------------------------
1992
1993 const AliEventInfo* AliEveEventManager::GetEventInfo() 
1994 {
1995     // Fill the event info object
1996
1997     AliCentralTrigger *aCTP = NULL;
1998     if (fRawReader) {
1999         fEventInfo.SetEventType(fRawReader->GetType());
2000
2001         ULong64_t mask = fRawReader->GetClassMask();
2002         fEventInfo.SetTriggerMask(mask);
2003         UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2004         fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
2005
2006         aCTP = new AliCentralTrigger();
2007         TString configstr("");
2008         if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
2009             AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
2010             delete aCTP;
2011             return 0;
2012         }
2013         aCTP->SetClassMask(mask);
2014         aCTP->SetClusterMask(clmask);
2015
2016         if (fRunLoader) {
2017             AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
2018             if (rlCTP) {
2019                 rlCTP->SetClassMask(mask);
2020                 rlCTP->SetClusterMask(clmask);
2021             }
2022         }
2023     }
2024     else {
2025         fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
2026
2027         if (fRunLoader && (!fRunLoader->LoadTrigger())) {
2028             aCTP = fRunLoader->GetTrigger();
2029             fEventInfo.SetTriggerMask(aCTP->GetClassMask());
2030             // get inputs from actp - just get
2031             AliESDHeader* esdheader = fESD->GetHeader();
2032             esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
2033             esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
2034             esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
2035             fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
2036         }
2037         else {
2038             AliWarning("No trigger can be loaded! The trigger information will not be used!");
2039             return 0;
2040         }
2041     }
2042
2043     AliTriggerConfiguration *config = aCTP->GetConfiguration();
2044     if (!config) {
2045         AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
2046         if (fRawReader) delete aCTP;
2047         return 0;
2048     }
2049
2050     TString declTriggerClasses;
2051
2052     // Load trigger aliases and declare the trigger classes included in aliases
2053     AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
2054     if (entry) {
2055         THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
2056         if (lst) {
2057             lst->Sort(kSortDescending); // to avoid problems with substrings
2058             if (fRawReader) fRawReader->LoadTriggerAlias(lst);
2059             // Now declare all the triggers present in the aliases
2060             TIter iter(lst);
2061             TNamed *nmd = 0;
2062             while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
2063                 declTriggerClasses += " ";
2064                 declTriggerClasses += nmd->GetName();
2065             }
2066         }
2067         else {
2068             AliError("Cannot cast the object with trigger aliases to THashList!");
2069         }
2070     }
2071     else {
2072         AliError("No OCDB entry for the trigger aliases!");
2073     }
2074
2075     // Load trigger classes for this run
2076     UChar_t clustmask = 0;
2077     TString trclasses;
2078     ULong64_t trmask = fEventInfo.GetTriggerMask();
2079     const TObjArray& classesArray = config->GetClasses();
2080     Int_t nclasses = classesArray.GetEntriesFast();
2081     for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
2082         AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
2083         if (trclass && trclass->GetMask()>0) {
2084             Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
2085             if (fESD) fESD->SetTriggerClass(trclass->GetName(),trindex);
2086             if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
2087             if (trmask & (1ull << trindex)) {
2088                 trclasses += " ";
2089                 trclasses += trclass->GetName();
2090                 trclasses += " ";
2091                 clustmask |= trclass->GetCluster()->GetClusterMask();
2092             }
2093         }
2094     }
2095     fEventInfo.SetTriggerClasses(trclasses);
2096
2097     if (!aCTP->CheckTriggeredDetectors()) {
2098         if (fRawReader) delete aCTP;
2099         return 0;
2100     }
2101
2102     if (fRawReader) delete aCTP;
2103
2104     // everything went ok, return pointer
2105     return (&fEventInfo);
2106 }
2107
2108
2109 TString AliEveEventManager::GetEventInfoHorizontal() const
2110 {
2111     // Dumps the event-header contents in vertical formatting.
2112
2113     TString rawInfo, esdInfo;
2114
2115     if (!fRawReader)
2116     {
2117         rawInfo = "No raw-data event info is available!\n";
2118     }
2119     else
2120     {
2121         const UInt_t* attr = fRawReader->GetAttributes();
2122         TTimeStamp ts(fRawReader->GetTimestamp());
2123         rawInfo.Form("RAW event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2124                      "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x  Timestamp: %s\n",
2125                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2126                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2127                      fRawReader->GetClassMask(),
2128                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2129                      attr[0],attr[1],attr[2], ts.AsString("s"));
2130     }
2131
2132     if (!fESD)
2133     {
2134         esdInfo = "No ESD event info is available!";
2135     }
2136     else
2137     {
2138         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2139         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2140         TTimeStamp ts(fESD->GetTimeStamp());
2141         esdInfo.Form("ESD event info: Run#: %d  Event type: %d (%s)  Period: %x  Orbit: %x  BC: %x\n"
2142                      "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d  Timestamp: %s, MagField: %.2e",
2143                      fESD->GetRunNumber(),
2144                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2145                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2146                      acttrclasses.Data(),
2147                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2148                      fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
2149     }
2150
2151     return rawInfo + esdInfo;
2152 }
2153
2154 TString AliEveEventManager::GetEventInfoVertical() const
2155 {
2156     // Dumps the event-header contents in vertical formatting.
2157
2158     TString rawInfo, esdInfo;
2159
2160     if (!fRawReader)
2161     {
2162         rawInfo = "No raw-data event info is available!\n";
2163     }
2164     else
2165     {
2166         const UInt_t* attr = fRawReader->GetAttributes();
2167         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",
2168                      fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2169                      fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2170                      fRawReader->GetClassMask(),
2171                      *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2172                      attr[0],attr[1],attr[2],
2173                      fRawReader->GetTimestamp());
2174     }
2175
2176     if (!fESD)
2177     {
2178         esdInfo = "No ESD event info is available!\n";
2179     }
2180     else
2181     {
2182         TString acttrclasses   = fESD->GetESDRun()->GetActiveTriggerClasses();
2183         TString firedtrclasses = fESD->GetFiredTriggerClasses();
2184         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",
2185                      fESD->GetRunNumber(),
2186                      acttrclasses.Data(),
2187                      fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2188                      fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2189                      fESD->GetTriggerMask(),firedtrclasses.Data(),
2190                      fESD->GetEventNumberInFile(),
2191                      fESD->GetTimeStamp());
2192     }
2193
2194     return rawInfo + "\n" + esdInfo;
2195 }
2196
2197
2198 //==============================================================================
2199 // Reading of GRP and MagneticField.
2200 // This is a reap-off from reconstruction ... should really be a common
2201 // code to do this somewhere in STEER.
2202 //==============================================================================
2203
2204 Bool_t AliEveEventManager::InitGRP()
2205 {
2206     //------------------------------------
2207     // Initialization of the GRP entry
2208     //------------------------------------
2209
2210     static const TEveException kEH("AliEveEventManager::InitGRP ");
2211
2212     AliGRPManager grpMgr;
2213     if (!grpMgr.ReadGRPEntry()) {
2214         return kFALSE;
2215     }
2216     fgGRPLoaded = kTRUE;
2217     if (!grpMgr.SetMagField()) {
2218         throw kEH + "Setting of field failed!";
2219     }
2220
2221     //*** Get the diamond profiles from OCDB
2222     // Eventually useful.
2223
2224     /*
2225     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
2226     if (entry) {
2227     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
2228     } else {
2229     ::Error(kEH, "No SPD diamond profile found in OCDB!");
2230     }
2231
2232     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
2233     if (entry) {
2234     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
2235     } else {
2236     ::Error(kEH, "No diamond profile found in OCDB!");
2237     }
2238
2239     entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
2240     if (entry) {
2241     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
2242     } else {
2243     ::Error(kEH, "No TPC diamond profile found in OCDB!");
2244     }
2245   */
2246
2247     return kTRUE;
2248
2249
2250 //------------------------------------
2251 // Global variables management
2252 //------------------------------------
2253
2254 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model)
2255 {
2256     // Insert a new visualization-parameter database entry with the default
2257     return InsertGlobal(tag, model, fGlobalReplace, fGlobalUpdate);
2258 }
2259
2260 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model,
2261                                         Bool_t replace, Bool_t update)
2262 {
2263     TPair* pair = (TPair*) fGlobal->FindObject(tag);
2264     if (pair)
2265     {
2266         if (replace)
2267         {
2268             model->IncDenyDestroy();
2269             model->SetRnrChildren(kFALSE);
2270
2271             TEveElement* old_model = dynamic_cast<TEveElement*>(pair->Value());
2272             if(!old_model) AliFatal("old_model == 0, dynamic cast failed\n");
2273             while (old_model->HasChildren())
2274             {
2275                 TEveElement *el = old_model->FirstChild();
2276                 el->SetVizModel(model);
2277                 if (update)
2278                 {
2279                     el->CopyVizParams(model);
2280                     el->PropagateVizParamsToProjecteds();
2281                 }
2282             }
2283             old_model->DecDenyDestroy();
2284
2285             pair->SetValue(dynamic_cast<TObject*>(model));
2286             return kTRUE;
2287         }
2288         else
2289         {
2290             return kFALSE;
2291         }
2292     }
2293     else
2294     {
2295         model->IncDenyDestroy();
2296         model->SetRnrChildren(kFALSE);
2297         fGlobal->Add(new TObjString(tag), dynamic_cast<TObject*>(model));
2298         return kTRUE;
2299     }
2300 }
2301
2302 TEveElement* AliEveEventManager::FindGlobal(const TString& tag)
2303 {
2304     return dynamic_cast<TEveElement*>(fGlobal->GetValue(tag));
2305 }
2306 Int_t AliEveEventManager::NewEventAvailable()
2307 {
2308   if (fIsNewEventAvaliable)
2309   {
2310     return 1;
2311   }
2312   else
2313   {
2314     return 0;
2315   }
2316 }