Online reconstruction simplified and prepared to be controlled by Storage Manager...
[u/mrichter/AliRoot.git] / EVE / EveBase / AliEveEventManager.cxx
1 // $Id: AliEveEventManager.cxx 64557 2013-10-16 20:03:08Z hristov $
2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
3
4 /**************************************************************************
5  * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
6  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
7  * full copyright notice.                                                 *
8  **************************************************************************/
9
10 #include "AliEveEventManager.h"
11 #include "AliEveEventSelector.h"
12 #include "AliEveMacroExecutor.h"
13 #include "AliEveConfigManager.h"
14 #include "AliEveVSDCreator.h"
15
16 #include <THashList.h>
17 #include <TEveElement.h>
18 #include <TEveManager.h>
19 #include <TEveViewer.h>
20
21 #include <AliLog.h>
22 #include <AliRunLoader.h>
23 #include <AliRun.h>
24 #include <AliESDRun.h>
25 #include <AliESDEvent.h>
26 #include <AliESDfriend.h>
27 #include <AliAODEvent.h>
28
29 #include <AliRecoParam.h>
30 #include <AliCentralTrigger.h>
31 #include <AliCDBEntry.h>
32 #include <AliTriggerClass.h>
33 #include <AliTriggerConfiguration.h>
34 #include <AliTriggerCluster.h>
35 #include <AliDetectorRecoParam.h>
36
37 #include <AliDAQ.h>
38 #include <AliRawEventHeaderBase.h>
39 #include <AliRawReaderRoot.h>
40 #include <AliRawReaderFile.h>
41 #include <AliRawReaderDate.h>
42 #include <AliMagF.h>
43 #include <AliCDBManager.h>
44 #include <AliCDBStorage.h>
45 #include <AliGRPObject.h>
46 #include <AliHeader.h>
47 #include <AliGeomManager.h>
48 #include <AliGRPManager.h>
49 #include <AliSysInfo.h>
50
51 #include <TFile.h>
52 #include <TTree.h>
53 #include <TGeoManager.h>
54 #include <TGeoGlobalMagField.h>
55 #include <TSystem.h>
56 #include <TTimeStamp.h>
57 #include <TPRegexp.h>
58 #include <TError.h>
59 #include <TEnv.h>
60 #include <TString.h>
61 #include <TMap.h>
62 #include <TROOT.h>
63
64 #ifdef ZMQ
65 #include "AliStorageEventManager.h"
66 #endif
67
68 using std::cout;
69 using std::endl;
70 using std::vector;
71 //==============================================================================
72 //==============================================================================
73 // AliEveEventManager
74 //==============================================================================
75
76 //______________________________________________________________________________
77 //
78 // Provides interface for loading and navigating standard AliRoot data
79 // (AliRunLoader), ESD, AOD and RAW.
80 //
81 // ESDfriend is attached automatically, if the file is found.
82 //
83 // AODfriends are not attached automatically as there are several
84 // possible files involved. To have a specific AODfriend attached, call
85 // static method
86 //   AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
87 // before initializing the event-manager.
88 //
89 // Also provides interface to magnetic-field and geometry. Mostly
90 // intended as wrappers over standard AliRoot functionality for
91 // convenient use from visualizateion macros.
92 //
93 // There can be a single main event-manger, it is stored in private
94 // data member fgMaster and can be accessed via static member function
95 // GetMaster().
96 //
97 // For event overlaying and embedding one can instantiate additional
98 // event-managers via static method AddDependentManager(const TString& path).
99 // This interface is under development.
100
101 ClassImp(AliEveEventManager)
102
103 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
104 Bool_t AliEveEventManager::fgAssertESD       = kFALSE;
105 Bool_t AliEveEventManager::fgAssertAOD       = kFALSE;
106 Bool_t AliEveEventManager::fgAssertRaw       = kFALSE;
107
108 TString  AliEveEventManager::fgESDFileName("AliESDs.root");
109 AliEveEventManager::EVisibleESDTrees  AliEveEventManager::fgESDvisibleTrees(AliEveEventManager::kOfflineTree);
110 TString  AliEveEventManager::fgESDfriendsFileName("AliESDfriends.root");
111 TString  AliEveEventManager::fgAODFileName("AliAOD.root");
112 TString  AliEveEventManager::fgGAliceFileName("galice.root");
113 TString  AliEveEventManager::fgRawFileName("raw.root");
114 TString  AliEveEventManager::fgCdbUri;
115
116 TList*   AliEveEventManager::fgAODfriends = 0;
117
118 Bool_t   AliEveEventManager::fgRawFromStandardLoc = kFALSE;
119
120 Bool_t   AliEveEventManager::fgGRPLoaded    = kFALSE;
121 AliMagF* AliEveEventManager::fgMagField     = 0;
122 AliRecoParam* AliEveEventManager::fgRecoParam = 0;
123 Bool_t   AliEveEventManager::fgUniformField = kFALSE;
124
125 AliEveEventManager* AliEveEventManager::fgMaster  = 0;
126 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
127
128 AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
129     TEveEventManager(name, ""),
130     fEventId(-1),
131     fRunLoader (0),
132     fESDFile   (0), fESDTree (0), fHLTESDTree(0), fESD (0),
133     fESDfriend (0), fESDfriendExists(kFALSE),
134     fAODFile   (0), fAODTree (0), fAOD (0),
135     fRawReader (0), fEventInfo(),
136     fAutoLoad  (kFALSE),fLoopMarked(kFALSE), fAutoLoadTime (5),      fAutoLoadTimer(0),
137     fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
138     fGlobal    (0), fGlobalReplace (kTRUE), fGlobalUpdate (kTRUE),
139     fExecutor    (0), fTransients(0), fTransientLists(0),
140     fPEventSelector(0),
141     fSubManagers (0),
142     fAutoLoadTimerRunning(kFALSE),
143     fMutex(new TMutex()),
144     fgSubSock(EVENTS_SERVER_SUB),
145     fEventInUse(1),
146     fWritingToEventIndex(0),
147     fIsNewEventAvaliable(false),
148     fStorageDown(false),
149     fFinished(false)
150 {
151     // Constructor with event-id.
152                 
153     InitInternals();
154
155     Open();
156     if (ev >= 0)
157     {
158         GotoEvent(ev);
159     }
160     
161     if (0 == name.CompareTo("online")) {
162       fOnlineMode = kTRUE;
163     }
164     else{
165       fOnlineMode = kFALSE;
166     }
167
168
169 #ifdef ZMQ
170     cout<<"ZMQ FOUND. Starting subscriber thread."<<endl;
171     fEventListenerThread = new TThread("fEventListenerThread",DispatchEventListener,(void*)this);
172     fEventListenerThread->Run();
173     
174     fStorageManagerWatcherThread = new TThread("fStorageManagerWatcherThread",DispatchStorageManagerWatcher,(void*)this);
175     fStorageManagerWatcherThread->Run();
176 #else
177     cout<<"NO ZMQ FOUND. Online events not avaliable."<<endl;
178 #endif
179 }
180
181 AliEveEventManager::~AliEveEventManager()
182 {
183     // Destructor.
184     
185     fFinished = true;
186     if(fEventListenerThread)
187     {
188         fEventListenerThread->Join();
189         fEventListenerThread->Kill();
190         delete fEventListenerThread;
191         cout<<"listener thread killed and deleted"<<endl;
192     }
193     if(fStorageManagerWatcherThread)
194     {
195         fStorageManagerWatcherThread->Join();
196         fStorageManagerWatcherThread->Kill();
197         delete fStorageManagerWatcherThread;
198         cout<<"storage watcher thread killed and deleted"<<endl;
199     }
200     
201     fAutoLoadTimer->Stop();
202     fAutoLoadTimer->Disconnect("Timeout");
203     fAutoLoadTimer->Disconnect("AutoLoadNextEvent");
204
205     if(fSubManagers){delete fSubManagers;}
206     if(fMutex){delete fMutex;}
207     if (fIsOpen){Close();}
208
209 //    fTransients->DecDenyDestroy();
210 //    fTransients->Destroy();
211
212 //    fTransientLists->DecDenyDestroy();
213 //    fTransientLists->Destroy();
214
215     //delete fExecutor;
216 }
217
218 void AliEveEventManager::GetNextEvent()
219 {
220 #ifdef ZMQ
221     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
222     eventManager->CreateSocket(EVENTS_SERVER_SUB);
223     eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
224     
225     fCurrentEvent[0]=0;
226     fCurrentEvent[1]=0;
227
228     AliESDEvent *tmpEvent = NULL;
229     
230     // get list of marked events:
231     struct listRequestStruct list;
232
233     list.runNumber[0]=0;
234     list.runNumber[1]=999999;
235     list.eventNumber[0]=0;
236     list.eventNumber[1]=999999;
237     list.marked[0]=1;
238     list.marked[1]=1;
239     list.multiplicity[0]=1;
240     list.multiplicity[1]=999999;
241     strcpy(list.system[0],"p-p");
242     strcpy(list.system[1],"A-A");
243     
244     struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
245     requestMessage->messageType = REQUEST_LIST_EVENTS;
246     requestMessage->list = list;
247     
248     eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
249     vector<serverListStruct> receivedList = eventManager->GetServerListVector(SERVER_COMMUNICATION_REQ);
250     
251     cout<<"EVENT DISPLAY -- received list of marked events"<<endl;
252     
253     for(int i=0;i<receivedList.size();i++)
254     {
255         cout<<"ev:"<<receivedList[i].eventNumber<<endl;
256     }
257     
258     int iter=0;
259     while(!fFinished)
260     {
261         if(!fLoopMarked || receivedList.size()<=0)
262         {
263             cout<<"taking event from reco server"<<endl;
264             tmpEvent = eventManager->GetEvent(EVENTS_SERVER_SUB,5000);
265             if(!tmpEvent){sleep(1);}
266         }
267         else
268         {
269             cout<<"taking event from storage manager"<<endl;
270             if(iter<receivedList.size())
271             {
272                 cout<<"i:"<<iter<<endl;
273                 struct eventStruct mark;
274                 mark.runNumber = receivedList[iter].runNumber;
275                 mark.eventNumber = receivedList[iter].eventNumber;
276              
277                 requestMessage->messageType = REQUEST_GET_EVENT;
278                 requestMessage->event = mark;
279                 
280                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
281                 tmpEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
282
283                 iter++;
284                 sleep(1);
285             }
286             else{iter=0;}
287         }
288         
289         if(tmpEvent)
290         {
291             cout<<"tmpEvent:"<<tmpEvent->GetRunNumber()<<endl;
292             if(tmpEvent->GetRunNumber()>=0)
293             {
294                 fMutex->Lock();
295                 if(fEventInUse == 0){fWritingToEventIndex = 1;}
296                 else if(fEventInUse == 1){fWritingToEventIndex = 0;}
297                 cout<<"Received new event:"<<tmpEvent->GetEventNumberInFile()<<endl;
298                 if(fCurrentEvent[fWritingToEventIndex])
299                 {
300                     delete fCurrentEvent[fWritingToEventIndex];
301                     fCurrentEvent[fWritingToEventIndex]=0;
302                 }
303                 fCurrentEvent[fWritingToEventIndex] = tmpEvent;
304                 fIsNewEventAvaliable = true;
305                 NewEventLoaded();
306                 fMutex->UnLock();
307             }
308         }
309         else{cout<<"didn't receive new event"<<endl;}
310     }
311     delete requestMessage;
312     
313 #endif
314 }
315
316 void AliEveEventManager::CheckStorageStatus()
317 {
318 #ifdef ZMQ
319     AliEveConfigManager *configManager = AliEveConfigManager::GetMaster();
320     configManager->ConnectEventManagerSignals();
321     
322     AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
323     eventManager->CreateSocket(CLIENT_COMMUNICATION_REQ);
324     
325     struct clientRequestStruct *request = new struct clientRequestStruct;
326     request->messageType = REQUEST_CONNECTION;
327     
328     while (!fFinished)
329     {
330         if(eventManager->Send(request,CLIENT_COMMUNICATION_REQ,5000))
331         {
332             StorageManagerOk();
333             long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
334             fStorageDown = kFALSE;
335         }
336         else
337         {
338             StorageManagerDown();
339             cout<<"WARNING -- Storage Manager is DOWN!!"<<endl;
340             fStorageDown = kTRUE;
341         }
342         sleep(1);
343     }
344     
345     AliEveEventManager *manager = AliEveEventManager::GetCurrent();
346     manager->Disconnect("StorageManagerOk");
347     manager->Disconnect("StorageManagerDown");
348     
349 #endif
350 }
351
352 void AliEveEventManager::InitInternals()
353 {
354     // Initialize internal members.
355     
356     static const TEveException kEH("AliEveEventManager::InitInternals ");
357     
358     if (fgCurrent != 0)
359     {
360         throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
361     }
362     
363     if (fgMaster == 0)
364     {
365         fgMaster = this;
366     }
367     
368     fgCurrent = this;
369     
370     fAutoLoadTimer = new TTimer;
371     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
372     fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "Timeout()");
373     
374     fExecutor = new AliEveMacroExecutor;
375     
376     fTransients = new TEveElementList("Transients", "Transient per-event elements.");
377     fTransients->IncDenyDestroy();
378     gEve->AddToListTree(fTransients, kFALSE);
379     
380     fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
381     fTransientLists->IncDenyDestroy();
382     gEve->AddToListTree(fTransientLists, kFALSE);
383     
384     fPEventSelector = new AliEveEventSelector(this);
385     
386     fGlobal = new TMap; fGlobal->SetOwnerKeyValue();
387 }
388
389 /******************************************************************************/
390
391 void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
392 {
393     fgESDvisibleTrees = shown;
394     // Set file-name for opening ESD, default "AliESDs.root".
395     if (esd.IsNull()) return;
396
397     fgESDFileName = esd;
398     if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
399
400 }
401
402 void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
403 {
404     // Set file-name for opening ESD friend, default "AliESDfriends.root".
405
406     if (esdf.IsNull()) return;
407     fgESDfriendsFileName = esdf;
408     
409     if (esdf.EndsWith(".zip")) fgESDfriendsFileName.Form("%s#AliESDfriends.root",esdf.Data());
410 }
411
412 void AliEveEventManager::SetAODFileName(const TString& aod)
413 {
414     // Set file-name for opening AOD, default "AliAOD.root".
415
416     if (aod.IsNull()) return;
417     fgAODFileName = aod;
418     
419     if (aod.EndsWith(".zip")) fgAODFileName.Form("%s#AliAOD.root",aod.Data());
420     
421 }
422
423 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
424 {
425     // Add new AOD friend file-name to be attached when opening AOD.
426     // This should include '.root', as in 'AliAOD.VertexingHF.root'.
427
428     if (fgAODfriends == 0)
429     {
430         fgAODfriends = new TList;
431         fgAODfriends->SetOwner(kTRUE);
432     }
433     if (fgAODfriends->FindObject(friendFileName) == 0)
434     {
435         fgAODfriends->Add(new TObjString(friendFileName));
436     }
437 }
438
439 void AliEveEventManager::SetRawFileName(const TString& raw)
440 {
441     // Set file-name for opening of raw-data, default "raw.root"
442     if (raw.IsNull()) return;
443     
444     fgRawFileName = raw;
445 }
446
447 void AliEveEventManager::SetCdbUri(const TString& cdb)
448 {
449     // Set path to CDB, there is no default.
450     if ( ! cdb.IsNull()) fgCdbUri = cdb;
451 }
452
453 void AliEveEventManager::SetGAliceFileName(const TString& galice)
454 {
455     // Set file-name for opening gAlice, default "galice.root".
456
457     if ( galice.IsNull()) return;
458     fgGAliceFileName = galice;
459     
460     if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
461 }
462
463 void AliEveEventManager::SetFilesPath(const TString& urlPath)
464 {
465     TString path = urlPath;
466     gSystem->ExpandPathName(path);
467     if (path.IsNull() || path == ".")
468     {
469         path = gSystem->WorkingDirectory();
470     }
471
472     TString sep;
473     if(path.EndsWith(".zip")) // if given a path to root_archive.zip
474         sep= "#";
475     else if(!path.EndsWith("/"))
476         sep = "/";
477     
478     SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
479     SetESDfriendFileName(  TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
480     SetAODFileName(  TString(Form("%s%sAliAOD.root", path.Data(), sep.Data())) );
481     AddAODfriend(  TString(Form("%s%sAliAOD.VertexingHF.root", path.Data(), sep.Data())) );
482     SetGAliceFileName( TString(Form("%s%sgalice.root", path.Data(), sep.Data())) );
483     SetRawFileName(TString(Form("%s%sraw.root", path.Data(), sep.Data())));
484 }
485
486 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
487                                            Bool_t assertAod, Bool_t assertRaw)
488 {
489     // Set global flags that detrmine which parts of the event-data must
490     // be present when the event is opened.
491
492     fgAssertRunLoader = assertRunloader;
493     fgAssertESD = assertEsd;
494     fgAssertAOD = assertAod;
495     fgAssertRaw = assertRaw;
496 }
497
498 void AliEveEventManager::SearchRawForCentralReconstruction()
499 {
500     // Enable searching of raw data in standard location. The path passed to
501     // Open() is expected to point to a centrally reconstructed run, e.g.:
502     // "alien:///alice/data/2009/LHC09c/000101134/ESDs/pass1/09000101134018.10".
503
504     fgRawFromStandardLoc = kTRUE;
505 }
506
507 /******************************************************************************/
508
509 void AliEveEventManager::Open()
510 {
511     // Open event-data from URL specified in path.
512     // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
513     // Warning is reported if run-loader or ESD is not found.
514     // Global data-members fgAssertRunLoader and fgAssertESD can be set
515     // to throw exceptions instead.
516
517     static const TEveException kEH("AliEveEventManager::Open ");
518
519     if (fExternalCtrl)
520     {
521         throw (kEH + "Event-loop is under external control.");
522     }
523     if (fIsOpen)
524     {
525         throw (kEH + "Event-files already opened.");
526     }
527
528     Int_t runNo = -1;
529
530     // Open ESD and ESDfriends
531     
532     if ((fESDFile = TFile::Open(fgESDFileName)))
533     {
534         fESD = new AliESDEvent();
535
536         switch(fgESDvisibleTrees){
537         case AliEveEventManager::kOfflineTree :
538             fESDTree = readESDTree("esdTree", runNo);
539             break;
540         case AliEveEventManager::kHLTTree :
541             fHLTESDTree = readESDTree("HLTesdTree", runNo);
542             break;
543         default:
544             fESDTree    = readESDTree("esdTree", runNo);
545             fHLTESDTree = readESDTree("HLTesdTree", runNo);
546         }
547
548         if(!fESDTree && !fHLTESDTree){
549             // both ESD trees are == 0
550             delete fESDFile; fESDFile = 0;
551             delete fESD; fESD = 0;
552         }
553
554
555     }
556     else // esd file not readable
557     {
558         Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
559     }
560     if (fESDTree == 0 && fHLTESDTree==0)
561     {
562         if (fgAssertESD)
563         {
564             throw (kEH + "ESD not initialized. Its precence was requested.");
565         } else {
566             Warning(kEH, "ESD not initialized.");
567         }
568     }
569
570     // Open AOD and registered friends
571     if ( (fAODFile = TFile::Open(fgAODFileName)) )
572     {
573         fAOD = new AliAODEvent();
574         fAODTree = (TTree*) fAODFile->Get("aodTree");
575         if (fAODTree != 0)
576         {
577             // Check if AODfriends exist and attach them.
578             TIter       friends(fgAODfriends);
579             TObjString *name;
580             while ((name = (TObjString*) friends()) != 0)
581             {
582                 TString p(Form("%s/%s", fgAODFileName.Data(), name->GetName()));
583                 if (fgAODFileName.EndsWith(".zip")) p.Form("%s#%s",fgAODFileName.Data(),name->GetName());
584                 if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
585                 {
586                     fAODTree->AddFriend("aodTree", name->GetName());
587                 }
588             }
589
590             fAOD->ReadFromTree(fAODTree);
591
592             if (fAODTree->GetEntry(0) <= 0)
593             {
594                 delete fAODFile; fAODFile = 0;
595                 delete fAOD;     fAOD     = 0;
596                 Warning(kEH, "failed getting the first entry from addTree.");
597             }
598             else
599             {
600                 if (runNo < 0)
601                     runNo = fAOD->GetRunNumber();
602             }
603         }
604         else // aodtree == 0
605         {
606             delete fAODFile; fAODFile = 0;
607             delete fAOD;     fAOD     = 0;
608             Warning(kEH, "failed getting the aodTree.");
609         }
610     }
611     else // aod not readable
612     {
613         Warning(kEH, "can not read AOD file '%s'.", fgAODFileName.Data());
614     }
615     if (fAODTree == 0)
616     {
617         if (fgAssertAOD)
618         {
619             throw (kEH + "AOD not initialized. Its precence was requested.");
620         } else {
621             Warning(kEH, "AOD not initialized.");
622         }
623     }
624
625     // Open RunLoader from galice.root
626 //    fgGAliceFileName = "/Users/Jerus/galice.root"; // temp
627     
628     TFile *gafile = TFile::Open(fgGAliceFileName);
629     cout<<"Opening galice"<<endl;
630     if (gafile)
631     {
632         gafile->Close();
633         delete gafile;
634         cout<<"SETTING RUN LOADER in Open()"<<endl;
635         fRunLoader = AliRunLoader::Open(fgGAliceFileName, GetName());
636         if (fRunLoader)
637         {
638             TString alicePath(gSystem->DirName(fgGAliceFileName));
639             alicePath.Append("/");
640             fRunLoader->SetDirName(alicePath);
641
642             if (fRunLoader->LoadgAlice() != 0)
643                 Warning(kEH, "failed loading gAlice via run-loader.");
644
645             if (fRunLoader->LoadHeader() == 0)
646             {
647                 if (runNo < 0)
648                     runNo = fRunLoader->GetHeader()->GetRun();
649             }
650             else
651             {
652                 Warning(kEH, "failed loading run-loader's header.");
653                 delete fRunLoader;
654                 fRunLoader = 0;
655             }
656         }
657         else // run-loader open failed
658         {
659             Warning(kEH, "failed opening ALICE run-loader from '%s'.", fgGAliceFileName.Data());
660         }
661         
662     }
663     else // galice not readable
664     {
665         Warning(kEH, "can not read '%s'.", fgGAliceFileName.Data());
666     }
667     if (fRunLoader == 0)
668     {
669         if (fgAssertRunLoader)
670             throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
671         else
672             Warning(kEH, "Bootstraping of run-loader failed.");
673     }
674
675     // Open raw-data file
676
677     TString rawPath;
678     if (fgRawFromStandardLoc)
679     {
680         if (!fgRawFileName.BeginsWith("alien:"))
681             throw kEH + "Standard raw search requested, but the directory is not in AliEn.";
682         if (!fgRawFileName.Contains("/ESDs/"))
683             throw kEH + "Standard raw search requested, but does not contain 'ESDs' directory.";
684
685         TPMERegexp chunk("/([\\d\\.])+/?$");
686         Int_t nm = chunk.Match(fgRawFileName);
687         if (nm != 2)
688             throw kEH + "Standard raw search requested, but the path does not end with chunk-id directory.";
689
690         TPMERegexp esdstrip("/ESDs/.*");
691         rawPath = fgRawFileName;
692         esdstrip.Substitute(rawPath, "/raw/");
693         rawPath += chunk[0];
694         rawPath += ".root";
695
696         Info(kEH, "Standard raw search requested, using the following path:\n  %s\n", rawPath.Data());
697     }
698     else
699     {
700         rawPath = fgRawFileName;
701     }
702     // If i use open directly, raw-reader reports an error but i have
703     // no way to detect it.
704     // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
705     AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
706     if (fgAssertRaw == kFALSE)
707     {
708         AliLog::SetGlobalLogLevel(AliLog::kFatal);
709     }
710     if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
711     {
712         fRawReader = AliRawReader::Create(rawPath);
713     }
714     else
715     {
716         fRawReader = AliRawReader::Create(fgRawFileName);
717     }
718     if (fgAssertRaw == kFALSE)
719     {
720         AliLog::SetGlobalLogLevel(oldLogLevel);
721     }
722
723     if (fRawReader == 0)
724     {
725         if (fgAssertRaw)
726         {
727             throw (kEH + "raw-data not initialized. Its precence was requested.");
728         }
729         else
730         {
731             Warning(kEH, "raw-data not initialized.");
732         }
733     }
734
735     if (runNo < 0)
736     {
737         if (fRawReader)
738         {
739             if ( ! fRawReader->NextEvent())
740             {
741                 throw (kEH + "can not go to first event in raw-reader to determine run-id.");
742             }
743             runNo = fRawReader->GetRunNumber();
744             Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
745             fRawReader->RewindEvents();
746         }
747         else
748         {
749             fExternalCtrl = kTRUE;
750              fEventId = 0;
751             return;
752         }
753     }
754
755     // Initialize OCDB ... only in master event-manager
756
757                 InitOCDB(runNo);
758
759
760     fIsOpen = kTRUE;
761 }
762
763 void AliEveEventManager::InitOCDB(int runNo)
764 {
765                 static const TEveException kEH("AliEveEventManager::InitOCDB ");
766     //if (this == fgMaster)
767     {
768         AliCDBManager* cdb = AliCDBManager::Instance();
769         if (cdb->IsDefaultStorageSet() == kTRUE)
770         {
771             Warning(kEH, "CDB already set - using the old storage:\n  '%s'",
772                     cdb->GetDefaultStorage()->GetURI().Data());
773         }
774         else
775         {
776             if (fgCdbUri.IsNull())
777             {
778                 gEnv->SetValue("Root.Stacktrace", "no");
779                 Fatal("Open()", "OCDB path was not specified.");
780             }
781
782             // Handle some special cases for MC (should be in OCDBManager).
783             if (fgCdbUri == "mcideal://")
784                 cdb->SetDefaultStorage("MC", "Ideal");
785             else if (fgCdbUri == "mcresidual://")
786                 cdb->SetDefaultStorage("MC", "Residual");
787             else if (fgCdbUri == "mcfull://")
788                 cdb->SetDefaultStorage("MC", "Full");
789             else if (fgCdbUri == "local://") {
790                 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
791                 cdb->SetDefaultStorage(fgCdbUri);
792             } else
793                 cdb->SetDefaultStorage(fgCdbUri);
794
795             cdb->SetRun(runNo);
796
797             if (cdb->IsDefaultStorageSet() == kFALSE)
798                 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
799         }
800
801         if (fgCdbUri.BeginsWith("local://"))
802         {
803             TString curPath = gSystem->WorkingDirectory();
804             TString grp     = "GRP/GRP/Data";
805             TString grppath = curPath + "/" + grp;
806             if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
807             {
808                 if (cdb->GetSpecificStorage(grp))
809                 {
810                     Warning(kEH, "Local GRP exists, but the specific storage is already set.");
811                 }
812                 else
813                 {
814                     Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
815                     TString lpath("local://");
816                     lpath += curPath;
817                     cdb->SetSpecificStorage(grp, lpath);
818                 }
819             }
820         }
821     }
822 }
823
824 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
825 {
826     // Set an event from an external source.
827     // The method is used in the online visualisation.
828     // AOD is not supported.
829
830     static const TEveException kEH("AliEveEventManager::SetEvent ");
831
832     if (fIsOpen)
833     {
834         Warning(kEH, "Event-files were open. Closing and switching to external control.");
835         Close();
836     }
837
838                         Info(kEH,"setting it!!! ============================");
839
840     fRunLoader = runLoader;
841     fRawReader = rawReader;
842     fESD       = esd;
843     fESDfriend = esdf;
844     fAOD       = 0;
845
846     fEventId++;
847     fHasEvent     = kTRUE;
848     fExternalCtrl = kTRUE;
849
850     SetTitle("Online event in memory");
851     SetName ("Online Event");
852     ElementChanged();
853
854     AfterNewEventLoaded();
855
856     if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
857     
858 }
859
860 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
861 {
862     // Returns maximum available event id.
863     // If under external control or event is not opened -1 is returned.
864     // If raw-data is the only data-source this can not be known
865     // and 10,000,000 is returned.
866     // If neither data-source is initialised an exception is thrown.
867     // If refresh_esd is true and ESD is the primary event-data source
868     // its header is re-read from disk.
869
870     static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
871
872     if (fExternalCtrl || fIsOpen == kFALSE)
873     {
874         return -1;
875     }
876
877     if ((fESDTree!=0) || (fHLTESDTree!=0))
878     {
879         if (refreshESD)
880         {
881             if(fESDTree!=0) fESDTree->Refresh();
882             if(fHLTESDTree!=0) fHLTESDTree->Refresh();
883             fPEventSelector->Update();
884         }
885
886         Int_t maxEventId=0;
887         switch(fgESDvisibleTrees){
888         default:
889         case AliEveEventManager::kOfflineTree :
890             maxEventId = fESDTree->GetEntries() - 1;
891             break;
892         case AliEveEventManager::kHLTTree :
893             maxEventId = fHLTESDTree->GetEntries() - 1;
894             break;
895        }
896
897         return maxEventId;
898     }
899     else if (fAODTree)
900     {
901         return fAODTree->GetEntries() - 1;
902     }
903     else if (fRunLoader)
904     {
905         return fRunLoader->GetNumberOfEvents() - 1;
906     }
907     else if (fRawReader)
908     {
909         Int_t n = fRawReader->GetNumberOfEvents() - 1;
910         return n > -1 ? n : 10000000;
911     }
912     else
913     {
914         throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
915     }
916 }
917
918 void AliEveEventManager::GotoEvent(Int_t event)
919 {
920     cout<<"Go to event:"<<event<<endl;
921     // Load data for specified event.
922     // If event is out of range an exception is thrown and old state
923     // is preserved.
924     // After successful loading of event, the virtual function
925     // AfterNewEventLoaded() is called. This executes commands that
926     // were registered via TEveEventManager::AddNewEventCommand().
927     //
928     // If event is negative, it is subtracted from the number of
929     // available events, thus passing -1 will load the last event.
930     // This is not supported when raw-data is the only data-source
931     // as the number of events is not known.
932
933     static const TEveException kEH("AliEveEventManager::GotoEvent ");
934
935     if (fAutoLoadTimerRunning)
936     {
937         throw (kEH + "Event auto-load timer is running.");
938     }
939     if (fExternalCtrl)
940     {
941       // throw (kEH + "Event-loop is under external control.");
942 #ifdef ZMQ
943       if (fStorageDown && -1 == event) 
944       {
945         NextEvent();
946         return;
947       }
948
949       if (fESD)
950       {
951           // create new server request:
952           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
953             
954           // set request type:
955           if (event == -1)      {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
956           else  if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
957           else  if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
958           else  if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
959             
960           // set event struct:
961           struct eventStruct eventToLoad;
962           eventToLoad.runNumber = fESD->GetRunNumber();
963           eventToLoad.eventNumber = fESD->GetEventNumberInFile();
964           requestMessage->event = eventToLoad;
965             
966           // create event manager:
967           AliStorageEventManager *eventManager =
968             AliStorageEventManager::GetEventManagerInstance();
969           AliESDEvent *resultEvent = NULL;
970             
971           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
972           fMutex->Lock();
973             
974           // send request and receive event:
975           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
976           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
977             
978           if(resultEvent)
979           {
980               DestroyElements();
981               InitOCDB(resultEvent->GetRunNumber());
982               SetEvent(0,0,resultEvent,0);
983           }
984           else
985           {
986               if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
987               if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
988               if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
989               if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
990           }
991             
992           fMutex->UnLock();
993         }
994       else
995       {
996           cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
997
998           struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
999           requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1000             
1001           AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1002           eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1003           AliESDEvent *resultEvent = NULL;
1004             
1005           fMutex->Lock();
1006           eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1007           resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1008             
1009           if(resultEvent)
1010           {
1011               fESD=resultEvent;
1012               DestroyElements();
1013               InitOCDB(resultEvent->GetRunNumber());
1014               SetEvent(0,0,resultEvent,0);
1015           }
1016           else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1017           fMutex->UnLock();
1018       }
1019 #endif  
1020
1021     }
1022     else if (!fIsOpen)
1023     {
1024         throw (kEH + "Event-files not opened.");
1025     }
1026
1027     fEventInfo.Reset();
1028
1029     fHasEvent = kFALSE;
1030
1031     Int_t maxEvent = 0;
1032     if ((fESDTree!=0) || (fHLTESDTree!=0))
1033     {
1034         if(fESDTree){
1035             if (event >= fESDTree->GetEntries())
1036                 fESDTree->Refresh();
1037             maxEvent = fESDTree->GetEntries() - 1;
1038             if (event < 0)
1039                 event = fESDTree->GetEntries() + event;
1040         }
1041
1042         if(fHLTESDTree){
1043             if (event >= fHLTESDTree->GetEntries())
1044                 fHLTESDTree->Refresh();
1045             maxEvent = fHLTESDTree->GetEntries() - 1;
1046             if (event < 0)
1047                 event = fHLTESDTree->GetEntries() + event;
1048
1049         }
1050     }
1051     else if (fAODTree)
1052     {
1053         maxEvent = fAODTree->GetEntries() - 1;
1054         if (event < 0)
1055             event = fAODTree->GetEntries() + event;
1056     }
1057     else if (fRunLoader)
1058     {
1059         maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1060         if (event < 0)
1061             event = fRunLoader->GetNumberOfEvents() + event;
1062     }
1063     else if (fRawReader)
1064     {
1065         maxEvent = fRawReader->GetNumberOfEvents() - 1;
1066         if (maxEvent < 0)
1067         {
1068             maxEvent = 10000000;
1069             if (event < 0) {
1070                 Error(kEH, "current raw-data source does not support direct event access.");
1071                 return;
1072             }
1073             Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1074         }
1075         else
1076         {
1077             if (event < 0)
1078                 event = fRawReader->GetNumberOfEvents() + event;
1079         }
1080     }
1081     else
1082     {
1083         throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1084     }
1085     if (event < 0 || event > maxEvent)
1086     {
1087         throw (kEH + Form("event %d not present, available range [%d, %d].",
1088                           event, 0, maxEvent));
1089     }
1090
1091     TString sysInfoHeader;
1092     sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1093     AliSysInfo::AddStamp(sysInfoHeader + "Start");
1094
1095     TEveManager::TRedrawDisabler rd(gEve);
1096     gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1097
1098     // !!! MT this is somewhat brutal; at least optionally, one could be
1099     // a bit gentler, checking for objs owning their external refs and having
1100     // additinal parents.
1101     gEve->GetViewers()->DeleteAnnotations();
1102     fTransients->DestroyElements();
1103     for (TEveElement::List_i i = fTransientLists->BeginChildren();
1104          i != fTransientLists->EndChildren(); ++i)
1105     {
1106         (*i)->DestroyElements();
1107     }
1108     DestroyElements();
1109
1110     AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1111
1112     if (fESDTree) {
1113         if (fESDTree->GetEntry(event) <= 0)
1114             throw (kEH + "failed getting required event from ESD.");
1115
1116         if (fESDfriendExists)
1117             fESD->SetESDfriend(fESDfriend);
1118     }
1119
1120     if (fHLTESDTree) {
1121         if (fHLTESDTree->GetEntry(event) <= 0)
1122             throw (kEH + "failed getting required event from HLT ESD.");
1123
1124         if (fESDfriendExists)
1125             fESD->SetESDfriend(fESDfriend);
1126     }
1127
1128     if (fAODTree) {
1129         if (fAODTree->GetEntry(event) <= 0)
1130             throw (kEH + "failed getting required event from AOD.");
1131     }
1132
1133     if (fRunLoader) {
1134         if (fRunLoader->GetEvent(event) != 0)
1135             throw (kEH + "failed getting required event.");
1136     }
1137
1138     if (fRawReader)
1139     {
1140         // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1141         if (fRawReader->GotoEvent(event) == kFALSE)
1142         {
1143             // Use fallback method - iteration with NextEvent().
1144             Int_t rawEv = fEventId;
1145             if (event < rawEv)
1146             {
1147                 fRawReader->RewindEvents();
1148                 rawEv = -1;
1149             }
1150
1151             while (rawEv < event)
1152             {
1153                 if ( ! fRawReader->NextEvent())
1154                 {
1155                     fRawReader->RewindEvents();
1156                     fEventId = -1;
1157                     throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1158                 }
1159                 ++rawEv;
1160             }
1161             Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1162         }
1163     }
1164
1165     fHasEvent = kTRUE;
1166     fEventId  = event;
1167     if (this == fgMaster)
1168     {
1169         SetName(Form("Event %d", fEventId));
1170         ElementChanged();
1171     }
1172
1173     AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1174
1175     AfterNewEventLoaded();
1176
1177     AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1178 }
1179
1180 void AliEveEventManager::Timeout()
1181 {
1182     Emit("Timeout()");
1183 }
1184
1185 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1186 {       
1187         DestroyElements();
1188         InitOCDB(event->GetRunNumber());
1189         printf("======================= setting event to %d\n", fEventId);
1190         SetEvent(0,0,event,0);
1191 }
1192
1193 void AliEveEventManager::NextEvent()
1194 {
1195     // Loads next event.
1196     // Does magick needed for online display when under external event control.
1197
1198     static const TEveException kEH("AliEveEventManager::NextEvent ");
1199
1200     if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1201     
1202     if (fExternalCtrl)
1203     {
1204 #ifdef ZMQ
1205         if(fIsNewEventAvaliable)
1206         {
1207             fMutex->Lock();
1208             if(fWritingToEventIndex == 0) fEventInUse = 0;
1209             else if(fWritingToEventIndex == 1) fEventInUse = 1;
1210             
1211             if(fCurrentEvent[fEventInUse])
1212             {
1213                 if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1214                 {
1215                     printf("======================= setting event to %d\n", fEventId);
1216                     
1217                     DestroyElements();
1218                     InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1219                     SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1220                     
1221                 }
1222             }
1223             fIsNewEventAvaliable = false;
1224             fMutex->UnLock();
1225         }
1226         else
1227         {
1228             cout<<"No new event is avaliable."<<endl;
1229             NoEventLoaded();
1230         }
1231 #endif
1232     }
1233     else if ((fESDTree!=0) || (fHLTESDTree!=0))
1234     {
1235       Int_t nextevent=0;
1236       if (fPEventSelector->FindNext(nextevent))
1237       {
1238         GotoEvent(nextevent);
1239       }
1240     }
1241     else if (fEventId < GetMaxEventId(kTRUE))
1242     {
1243       GotoEvent(fEventId + 1);
1244     }
1245     
1246     gSystem->ProcessEvents();
1247     
1248     /*
1249     cout<<"VSD"<<endl;
1250     AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1251     cout<<"contructor called"<<endl;
1252     vsdCreator->CreateVSD("myVSD.root");
1253     cout<<"PO"<<endl;
1254 */
1255     //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1256 }
1257
1258 void AliEveEventManager::PrevEvent()
1259 {
1260     // Loads previous event.
1261
1262     static const TEveException kEH("AliEveEventManager::PrevEvent ");
1263
1264     if (fAutoLoadTimerRunning)
1265     {
1266         throw (kEH + "Event auto-load timer is running.");
1267     }
1268     if (fExternalCtrl)
1269     {
1270         throw (kEH + "Event-loop is under external control.");
1271     }
1272
1273     if ((fESDTree!=0) || (fHLTESDTree!=0))
1274     {
1275         Int_t nextevent=0;
1276         if (fPEventSelector->FindPrev(nextevent))
1277         {
1278             GotoEvent(nextevent);
1279         }
1280     }
1281     else if (fEventId > 0)
1282     {
1283         GotoEvent(fEventId - 1);
1284     }
1285 }
1286
1287 void AliEveEventManager::MarkCurrentEvent()
1288 {
1289 #ifdef ZMQ
1290         struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1291         struct eventStruct mark;
1292         mark.runNumber = fESD->GetRunNumber();
1293         mark.eventNumber = fESD->GetEventNumberInFile();
1294         requestMessage->messageType = REQUEST_MARK_EVENT;
1295         requestMessage->event = mark;
1296
1297         AliStorageEventManager *eventManager =
1298                 AliStorageEventManager::GetEventManagerInstance();
1299         eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1300
1301         /*
1302         std::future<bool> unused = std::async([]()
1303         {
1304                 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1305                 bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1306
1307                 if(response)
1308                 {
1309                 //fStatusLabel->SetText("Event marked");
1310                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1311                 }
1312                 else
1313                 {
1314                 //fStatusLabel->SetText("Couldn't mark this event");
1315                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1316                 }
1317         });
1318         */
1319         
1320         eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1321         bool response =  eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1322         
1323         
1324         if(response)
1325         {
1326                 //fStatusLabel->SetText("Event marked");
1327                 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1328         }
1329         else
1330         {
1331                 //fStatusLabel->SetText("Couldn't mark this event");
1332                 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1333         }
1334         if(requestMessage){delete requestMessage;}
1335 #endif
1336 }
1337
1338 void AliEveEventManager::Close()
1339 {
1340     // Close the event data-files and delete ESD, ESDfriend, run-loader
1341     // and raw-reader.
1342
1343     cout<<"\n\n\nClose() called!!\n\n\n"<<endl;
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 }