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