1 // $Id: AliEveEventManager.cxx 64557 2013-10-16 20:03:08Z hristov $
2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
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 **************************************************************************/
10 #include "AliEveEventManager.h"
11 #include "AliEveEventSelector.h"
12 #include "AliEveMacroExecutor.h"
13 #include "AliEveConfigManager.h"
14 #include "AliEveVSDCreator.h"
16 #include <THashList.h>
17 #include <TEveElement.h>
18 #include <TEveManager.h>
19 #include <TEveViewer.h>
22 #include <AliRunLoader.h>
24 #include <AliESDRun.h>
25 #include <AliESDEvent.h>
26 #include <AliESDfriend.h>
27 #include <AliAODEvent.h>
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>
38 #include <AliRawEventHeaderBase.h>
39 #include <AliRawReaderRoot.h>
40 #include <AliRawReaderFile.h>
41 #include <AliRawReaderDate.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>
53 #include <TGeoManager.h>
54 #include <TGeoGlobalMagField.h>
56 #include <TTimeStamp.h>
65 #include "AliStorageEventManager.h"
70 //==============================================================================
71 //==============================================================================
73 //==============================================================================
75 //______________________________________________________________________________
77 // Provides interface for loading and navigating standard AliRoot data
78 // (AliRunLoader), ESD, AOD and RAW.
80 // ESDfriend is attached automatically, if the file is found.
82 // AODfriends are not attached automatically as there are several
83 // possible files involved. To have a specific AODfriend attached, call
85 // AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
86 // before initializing the event-manager.
88 // Also provides interface to magnetic-field and geometry. Mostly
89 // intended as wrappers over standard AliRoot functionality for
90 // convenient use from visualizateion macros.
92 // There can be a single main event-manger, it is stored in private
93 // data member fgMaster and can be accessed via static member function
96 // For event overlaying and embedding one can instantiate additional
97 // event-managers via static method AddDependentManager(const TString& path).
98 // This interface is under development.
100 ClassImp(AliEveEventManager)
102 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
103 Bool_t AliEveEventManager::fgAssertESD = kFALSE;
104 Bool_t AliEveEventManager::fgAssertAOD = kFALSE;
105 Bool_t AliEveEventManager::fgAssertRaw = kFALSE;
107 TString AliEveEventManager::fgESDFileName("AliESDs.root");
108 AliEveEventManager::EVisibleESDTrees AliEveEventManager::fgESDvisibleTrees(AliEveEventManager::kOfflineTree);
109 TString AliEveEventManager::fgESDfriendsFileName("AliESDfriends.root");
110 TString AliEveEventManager::fgAODFileName("AliAOD.root");
111 TString AliEveEventManager::fgGAliceFileName("galice.root");
112 TString AliEveEventManager::fgRawFileName("raw.root");
113 TString AliEveEventManager::fgCdbUri;
115 TList* AliEveEventManager::fgAODfriends = 0;
117 Bool_t AliEveEventManager::fgRawFromStandardLoc = kFALSE;
119 Bool_t AliEveEventManager::fgGRPLoaded = kFALSE;
120 AliMagF* AliEveEventManager::fgMagField = 0;
121 AliRecoParam* AliEveEventManager::fgRecoParam = 0;
122 Bool_t AliEveEventManager::fgUniformField = kFALSE;
124 AliEveEventManager* AliEveEventManager::fgMaster = 0;
125 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
127 AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
128 TEveEventManager(name, ""),
131 fESDFile (0), fESDTree (0), fHLTESDTree(0), fESD (0),
132 fESDfriend (0), fESDfriendExists(kFALSE),
133 fAODFile (0), fAODTree (0), fAOD (0),
134 fRawReader (0), fEventInfo(),
135 fAutoLoad (kFALSE),fLoopMarked(kFALSE), fAutoLoadTime (5), fAutoLoadTimer(0),
136 fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
137 fGlobal (0), fGlobalReplace (kTRUE), fGlobalUpdate (kTRUE),
138 fExecutor (0), fTransients(0), fTransientLists(0),
141 fAutoLoadTimerRunning(kFALSE),
142 fMutex(new TMutex()),
143 fgSubSock(EVENTS_SERVER_SUB),
145 fWritingToEventIndex(0),
146 fIsNewEventAvaliable(false),
150 // Constructor with event-id.
160 if (0 == name.CompareTo("online")) {
164 fOnlineMode = kFALSE;
169 cout<<"ZMQ FOUND. Starting subscriber thread."<<endl;
170 fEventListenerThread = new TThread("fEventListenerThread",DispatchEventListener,(void*)this);
171 fEventListenerThread->Run();
173 fStorageManagerWatcherThread = new TThread("fStorageManagerWatcherThread",DispatchStorageManagerWatcher,(void*)this);
174 fStorageManagerWatcherThread->Run();
176 cout<<"NO ZMQ FOUND. Online events not avaliable."<<endl;
180 AliEveEventManager::~AliEveEventManager()
186 if(fEventListenerThread)
188 fEventListenerThread->Kill();
189 delete fEventListenerThread;
191 if(fStorageManagerWatcherThread)
193 fStorageManagerWatcherThread->Kill();
194 delete fStorageManagerWatcherThread;
198 fAutoLoadTimer->Stop();
199 fAutoLoadTimer->Disconnect("Timeout");
200 fAutoLoadTimer->Disconnect("AutoLoadNextEvent");
202 AliEveEventManager *manager = AliEveEventManager::GetCurrent();
203 manager->Disconnect("StorageManagerOk");
204 manager->Disconnect("StorageManagerDown");
206 if(fSubManagers){delete fSubManagers;}
207 if(fMutex){delete fMutex;}
214 // fTransients->DecDenyDestroy();
215 // fTransients->Destroy();
217 // fTransientLists->DecDenyDestroy();
218 // fTransientLists->Destroy();
223 void AliEveEventManager::GetNextEvent()
226 AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
227 eventManager->CreateSocket(EVENTS_SERVER_SUB);
228 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
233 AliESDEvent *tmpEvent = NULL;
235 // get list of marked events:
236 struct listRequestStruct list;
239 list.runNumber[1]=999999;
240 list.eventNumber[0]=0;
241 list.eventNumber[1]=999999;
244 list.multiplicity[0]=1;
245 list.multiplicity[1]=999999;
246 strcpy(list.system[0],"p-p");
247 strcpy(list.system[1],"A-A");
249 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
250 requestMessage->messageType = REQUEST_LIST_EVENTS;
251 requestMessage->list = list;
253 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
254 vector<serverListStruct> receivedList = eventManager->GetServerListVector(SERVER_COMMUNICATION_REQ);
256 cout<<"EVENT DISPLAY -- received list of marked events"<<endl;
258 for(int i=0;i<receivedList.size();i++)
260 cout<<"ev:"<<receivedList[i].eventNumber<<endl;
268 cout<<"taking event from reco server"<<endl;
269 tmpEvent = eventManager->GetEvent(EVENTS_SERVER_SUB,5);
270 if(!tmpEvent){sleep(1);}
274 cout<<"taking event from storage manager"<<endl;
275 if(iter<receivedList.size())
277 struct eventStruct mark;
278 mark.runNumber = receivedList[iter].runNumber;
279 mark.eventNumber = receivedList[iter].eventNumber;
281 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
282 requestMessage->messageType = REQUEST_GET_EVENT;
283 requestMessage->event = mark;
285 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
286 tmpEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
296 if(tmpEvent->GetRunNumber()>=0)
299 if(fEventInUse == 0){fWritingToEventIndex = 1;}
300 else if(fEventInUse == 1){fWritingToEventIndex = 0;}
301 cout<<"Received new event:"<<tmpEvent->GetEventNumberInFile()<<endl;
302 if(fCurrentEvent[fWritingToEventIndex])
304 delete fCurrentEvent[fWritingToEventIndex];
305 fCurrentEvent[fWritingToEventIndex]=0;
307 fCurrentEvent[fWritingToEventIndex] = tmpEvent;
308 fIsNewEventAvaliable = true;
315 cout<<"didn't receive new event"<<endl;
318 delete requestMessage;
323 void AliEveEventManager::CheckStorageStatus()
326 AliEveConfigManager *configManager = AliEveConfigManager::GetMaster();
327 configManager->ConnectEventManagerSignals();
329 AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
330 eventManager->CreateSocket(CLIENT_COMMUNICATION_REQ);
332 struct clientRequestStruct *request = new struct clientRequestStruct;
333 request->messageType = REQUEST_CONNECTION;
337 if(eventManager->Send(request,CLIENT_COMMUNICATION_REQ,5000))
340 long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
341 fStorageDown = kFALSE;
345 StorageManagerDown();
346 cout<<"WARNING -- Storage Manager is DOWN!!"<<endl;
347 fStorageDown = kTRUE;
354 void AliEveEventManager::InitInternals()
356 // Initialize internal members.
358 static const TEveException kEH("AliEveEventManager::InitInternals ");
362 throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
372 fAutoLoadTimer = new TTimer;
373 fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
374 fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "Timeout()");
376 fExecutor = new AliEveMacroExecutor;
378 fTransients = new TEveElementList("Transients", "Transient per-event elements.");
379 fTransients->IncDenyDestroy();
380 gEve->AddToListTree(fTransients, kFALSE);
382 fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
383 fTransientLists->IncDenyDestroy();
384 gEve->AddToListTree(fTransientLists, kFALSE);
386 fPEventSelector = new AliEveEventSelector(this);
388 fGlobal = new TMap; fGlobal->SetOwnerKeyValue();
391 /******************************************************************************/
393 void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
395 fgESDvisibleTrees = shown;
396 // Set file-name for opening ESD, default "AliESDs.root".
397 if (esd.IsNull()) return;
400 if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
404 void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
406 // Set file-name for opening ESD friend, default "AliESDfriends.root".
408 if (esdf.IsNull()) return;
409 fgESDfriendsFileName = esdf;
411 if (esdf.EndsWith(".zip")) fgESDfriendsFileName.Form("%s#AliESDfriends.root",esdf.Data());
414 void AliEveEventManager::SetAODFileName(const TString& aod)
416 // Set file-name for opening AOD, default "AliAOD.root".
418 if (aod.IsNull()) return;
421 if (aod.EndsWith(".zip")) fgAODFileName.Form("%s#AliAOD.root",aod.Data());
425 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
427 // Add new AOD friend file-name to be attached when opening AOD.
428 // This should include '.root', as in 'AliAOD.VertexingHF.root'.
430 if (fgAODfriends == 0)
432 fgAODfriends = new TList;
433 fgAODfriends->SetOwner(kTRUE);
435 if (fgAODfriends->FindObject(friendFileName) == 0)
437 fgAODfriends->Add(new TObjString(friendFileName));
441 void AliEveEventManager::SetRawFileName(const TString& raw)
443 // Set file-name for opening of raw-data, default "raw.root"
444 if (raw.IsNull()) return;
449 void AliEveEventManager::SetCdbUri(const TString& cdb)
451 // Set path to CDB, there is no default.
452 if ( ! cdb.IsNull()) fgCdbUri = cdb;
455 void AliEveEventManager::SetGAliceFileName(const TString& galice)
457 // Set file-name for opening gAlice, default "galice.root".
459 if ( galice.IsNull()) return;
460 fgGAliceFileName = galice;
462 if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
465 void AliEveEventManager::SetFilesPath(const TString& urlPath)
467 TString path = urlPath;
468 gSystem->ExpandPathName(path);
469 if (path.IsNull() || path == ".")
471 path = gSystem->WorkingDirectory();
475 if(path.EndsWith(".zip")) // if given a path to root_archive.zip
477 else if(!path.EndsWith("/"))
480 SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
481 SetESDfriendFileName( TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
482 SetAODFileName( TString(Form("%s%sAliAOD.root", path.Data(), sep.Data())) );
483 AddAODfriend( TString(Form("%s%sAliAOD.VertexingHF.root", path.Data(), sep.Data())) );
484 SetGAliceFileName( TString(Form("%s%sgalice.root", path.Data(), sep.Data())) );
485 SetRawFileName(TString(Form("%s%sraw.root", path.Data(), sep.Data())));
488 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
489 Bool_t assertAod, Bool_t assertRaw)
491 // Set global flags that detrmine which parts of the event-data must
492 // be present when the event is opened.
494 fgAssertRunLoader = assertRunloader;
495 fgAssertESD = assertEsd;
496 fgAssertAOD = assertAod;
497 fgAssertRaw = assertRaw;
500 void AliEveEventManager::SearchRawForCentralReconstruction()
502 // Enable searching of raw data in standard location. The path passed to
503 // Open() is expected to point to a centrally reconstructed run, e.g.:
504 // "alien:///alice/data/2009/LHC09c/000101134/ESDs/pass1/09000101134018.10".
506 fgRawFromStandardLoc = kTRUE;
509 /******************************************************************************/
511 void AliEveEventManager::Open()
513 // Open event-data from URL specified in path.
514 // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
515 // Warning is reported if run-loader or ESD is not found.
516 // Global data-members fgAssertRunLoader and fgAssertESD can be set
517 // to throw exceptions instead.
519 static const TEveException kEH("AliEveEventManager::Open ");
523 throw (kEH + "Event-loop is under external control.");
527 throw (kEH + "Event-files already opened.");
532 // Open ESD and ESDfriends
534 if ((fESDFile = TFile::Open(fgESDFileName)))
536 fESD = new AliESDEvent();
538 switch(fgESDvisibleTrees){
539 case AliEveEventManager::kOfflineTree :
540 fESDTree = readESDTree("esdTree", runNo);
542 case AliEveEventManager::kHLTTree :
543 fHLTESDTree = readESDTree("HLTesdTree", runNo);
546 fESDTree = readESDTree("esdTree", runNo);
547 fHLTESDTree = readESDTree("HLTesdTree", runNo);
550 if(!fESDTree && !fHLTESDTree){
551 // both ESD trees are == 0
552 delete fESDFile; fESDFile = 0;
553 delete fESD; fESD = 0;
558 else // esd file not readable
560 Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
562 if (fESDTree == 0 && fHLTESDTree==0)
566 throw (kEH + "ESD not initialized. Its precence was requested.");
568 Warning(kEH, "ESD not initialized.");
572 // Open AOD and registered friends
573 if ( (fAODFile = TFile::Open(fgAODFileName)) )
575 fAOD = new AliAODEvent();
576 fAODTree = (TTree*) fAODFile->Get("aodTree");
579 // Check if AODfriends exist and attach them.
580 TIter friends(fgAODfriends);
582 while ((name = (TObjString*) friends()) != 0)
584 TString p(Form("%s/%s", fgAODFileName.Data(), name->GetName()));
585 if (fgAODFileName.EndsWith(".zip")) p.Form("%s#%s",fgAODFileName.Data(),name->GetName());
586 if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
588 fAODTree->AddFriend("aodTree", name->GetName());
592 fAOD->ReadFromTree(fAODTree);
594 if (fAODTree->GetEntry(0) <= 0)
596 delete fAODFile; fAODFile = 0;
597 delete fAOD; fAOD = 0;
598 Warning(kEH, "failed getting the first entry from addTree.");
603 runNo = fAOD->GetRunNumber();
608 delete fAODFile; fAODFile = 0;
609 delete fAOD; fAOD = 0;
610 Warning(kEH, "failed getting the aodTree.");
613 else // aod not readable
615 Warning(kEH, "can not read AOD file '%s'.", fgAODFileName.Data());
621 throw (kEH + "AOD not initialized. Its precence was requested.");
623 Warning(kEH, "AOD not initialized.");
627 // Open RunLoader from galice.root
628 // fgGAliceFileName = "/Users/Jerus/galice.root"; // temp
630 TFile *gafile = TFile::Open(fgGAliceFileName);
631 cout<<"Opening galice"<<endl;
636 cout<<"SETTING RUN LOADER in Open()"<<endl;
637 fRunLoader = AliRunLoader::Open(fgGAliceFileName, GetName());
640 TString alicePath(gSystem->DirName(fgGAliceFileName));
641 alicePath.Append("/");
642 fRunLoader->SetDirName(alicePath);
644 if (fRunLoader->LoadgAlice() != 0)
645 Warning(kEH, "failed loading gAlice via run-loader.");
647 if (fRunLoader->LoadHeader() == 0)
650 runNo = fRunLoader->GetHeader()->GetRun();
654 Warning(kEH, "failed loading run-loader's header.");
659 else // run-loader open failed
661 Warning(kEH, "failed opening ALICE run-loader from '%s'.", fgGAliceFileName.Data());
665 else // galice not readable
667 Warning(kEH, "can not read '%s'.", fgGAliceFileName.Data());
671 if (fgAssertRunLoader)
672 throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
674 Warning(kEH, "Bootstraping of run-loader failed.");
677 // Open raw-data file
680 if (fgRawFromStandardLoc)
682 if (!fgRawFileName.BeginsWith("alien:"))
683 throw kEH + "Standard raw search requested, but the directory is not in AliEn.";
684 if (!fgRawFileName.Contains("/ESDs/"))
685 throw kEH + "Standard raw search requested, but does not contain 'ESDs' directory.";
687 TPMERegexp chunk("/([\\d\\.])+/?$");
688 Int_t nm = chunk.Match(fgRawFileName);
690 throw kEH + "Standard raw search requested, but the path does not end with chunk-id directory.";
692 TPMERegexp esdstrip("/ESDs/.*");
693 rawPath = fgRawFileName;
694 esdstrip.Substitute(rawPath, "/raw/");
698 Info(kEH, "Standard raw search requested, using the following path:\n %s\n", rawPath.Data());
702 rawPath = fgRawFileName;
704 // If i use open directly, raw-reader reports an error but i have
705 // no way to detect it.
706 // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
707 AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
708 if (fgAssertRaw == kFALSE)
710 AliLog::SetGlobalLogLevel(AliLog::kFatal);
712 if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
714 fRawReader = AliRawReader::Create(rawPath);
718 fRawReader = AliRawReader::Create(fgRawFileName);
720 if (fgAssertRaw == kFALSE)
722 AliLog::SetGlobalLogLevel(oldLogLevel);
729 throw (kEH + "raw-data not initialized. Its precence was requested.");
733 Warning(kEH, "raw-data not initialized.");
741 if ( ! fRawReader->NextEvent())
743 throw (kEH + "can not go to first event in raw-reader to determine run-id.");
745 runNo = fRawReader->GetRunNumber();
746 Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
747 fRawReader->RewindEvents();
751 fExternalCtrl = kTRUE;
757 // Initialize OCDB ... only in master event-manager
765 void AliEveEventManager::InitOCDB(int runNo)
767 static const TEveException kEH("AliEveEventManager::InitOCDB ");
768 //if (this == fgMaster)
770 AliCDBManager* cdb = AliCDBManager::Instance();
771 if (cdb->IsDefaultStorageSet() == kTRUE)
773 Warning(kEH, "CDB already set - using the old storage:\n '%s'",
774 cdb->GetDefaultStorage()->GetURI().Data());
778 if (fgCdbUri.IsNull())
780 gEnv->SetValue("Root.Stacktrace", "no");
781 Fatal("Open()", "OCDB path was not specified.");
784 // Handle some special cases for MC (should be in OCDBManager).
785 if (fgCdbUri == "mcideal://")
786 cdb->SetDefaultStorage("MC", "Ideal");
787 else if (fgCdbUri == "mcresidual://")
788 cdb->SetDefaultStorage("MC", "Residual");
789 else if (fgCdbUri == "mcfull://")
790 cdb->SetDefaultStorage("MC", "Full");
791 else if (fgCdbUri == "local://") {
792 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
793 cdb->SetDefaultStorage(fgCdbUri);
795 cdb->SetDefaultStorage(fgCdbUri);
799 if (cdb->IsDefaultStorageSet() == kFALSE)
800 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
803 if (fgCdbUri.BeginsWith("local://"))
805 TString curPath = gSystem->WorkingDirectory();
806 TString grp = "GRP/GRP/Data";
807 TString grppath = curPath + "/" + grp;
808 if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
810 if (cdb->GetSpecificStorage(grp))
812 Warning(kEH, "Local GRP exists, but the specific storage is already set.");
816 Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
817 TString lpath("local://");
819 cdb->SetSpecificStorage(grp, lpath);
826 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
828 // Set an event from an external source.
829 // The method is used in the online visualisation.
830 // AOD is not supported.
832 static const TEveException kEH("AliEveEventManager::SetEvent ");
836 Warning(kEH, "Event-files were open. Closing and switching to external control.");
840 Info(kEH,"setting it!!! ============================");
842 fRunLoader = runLoader;
843 fRawReader = rawReader;
850 fExternalCtrl = kTRUE;
852 SetTitle("Online event in memory");
853 SetName ("Online Event");
856 AfterNewEventLoaded();
858 if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
862 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
864 // Returns maximum available event id.
865 // If under external control or event is not opened -1 is returned.
866 // If raw-data is the only data-source this can not be known
867 // and 10,000,000 is returned.
868 // If neither data-source is initialised an exception is thrown.
869 // If refresh_esd is true and ESD is the primary event-data source
870 // its header is re-read from disk.
872 static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
874 if (fExternalCtrl || fIsOpen == kFALSE)
879 if ((fESDTree!=0) || (fHLTESDTree!=0))
883 if(fESDTree!=0) fESDTree->Refresh();
884 if(fHLTESDTree!=0) fHLTESDTree->Refresh();
885 fPEventSelector->Update();
889 switch(fgESDvisibleTrees){
891 case AliEveEventManager::kOfflineTree :
892 maxEventId = fESDTree->GetEntries() - 1;
894 case AliEveEventManager::kHLTTree :
895 maxEventId = fHLTESDTree->GetEntries() - 1;
903 return fAODTree->GetEntries() - 1;
907 return fRunLoader->GetNumberOfEvents() - 1;
911 Int_t n = fRawReader->GetNumberOfEvents() - 1;
912 return n > -1 ? n : 10000000;
916 throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
920 void AliEveEventManager::GotoEvent(Int_t event)
922 cout<<"Go to event:"<<event<<endl;
923 // Load data for specified event.
924 // If event is out of range an exception is thrown and old state
926 // After successful loading of event, the virtual function
927 // AfterNewEventLoaded() is called. This executes commands that
928 // were registered via TEveEventManager::AddNewEventCommand().
930 // If event is negative, it is subtracted from the number of
931 // available events, thus passing -1 will load the last event.
932 // This is not supported when raw-data is the only data-source
933 // as the number of events is not known.
935 static const TEveException kEH("AliEveEventManager::GotoEvent ");
937 if (fAutoLoadTimerRunning)
939 throw (kEH + "Event auto-load timer is running.");
943 // throw (kEH + "Event-loop is under external control.");
945 if (fStorageDown && -1 == event)
953 // create new server request:
954 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
957 if (event == -1) {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
958 else if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
959 else if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
960 else if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
963 struct eventStruct eventToLoad;
964 eventToLoad.runNumber = fESD->GetRunNumber();
965 eventToLoad.eventNumber = fESD->GetEventNumberInFile();
966 requestMessage->event = eventToLoad;
968 // create event manager:
969 AliStorageEventManager *eventManager =
970 AliStorageEventManager::GetEventManagerInstance();
971 AliESDEvent *resultEvent = NULL;
973 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
976 // send request and receive event:
977 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
978 resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
983 InitOCDB(resultEvent->GetRunNumber());
984 SetEvent(0,0,resultEvent,0);
988 if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
989 if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
990 if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
991 if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
998 cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
1000 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1001 requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1003 AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1004 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1005 AliESDEvent *resultEvent = NULL;
1008 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1009 resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1015 InitOCDB(resultEvent->GetRunNumber());
1016 SetEvent(0,0,resultEvent,0);
1018 else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1026 throw (kEH + "Event-files not opened.");
1034 if ((fESDTree!=0) || (fHLTESDTree!=0))
1037 if (event >= fESDTree->GetEntries())
1038 fESDTree->Refresh();
1039 maxEvent = fESDTree->GetEntries() - 1;
1041 event = fESDTree->GetEntries() + event;
1045 if (event >= fHLTESDTree->GetEntries())
1046 fHLTESDTree->Refresh();
1047 maxEvent = fHLTESDTree->GetEntries() - 1;
1049 event = fHLTESDTree->GetEntries() + event;
1055 maxEvent = fAODTree->GetEntries() - 1;
1057 event = fAODTree->GetEntries() + event;
1059 else if (fRunLoader)
1061 maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1063 event = fRunLoader->GetNumberOfEvents() + event;
1065 else if (fRawReader)
1067 maxEvent = fRawReader->GetNumberOfEvents() - 1;
1070 maxEvent = 10000000;
1072 Error(kEH, "current raw-data source does not support direct event access.");
1075 Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1080 event = fRawReader->GetNumberOfEvents() + event;
1085 throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1087 if (event < 0 || event > maxEvent)
1089 throw (kEH + Form("event %d not present, available range [%d, %d].",
1090 event, 0, maxEvent));
1093 TString sysInfoHeader;
1094 sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1095 AliSysInfo::AddStamp(sysInfoHeader + "Start");
1097 TEveManager::TRedrawDisabler rd(gEve);
1098 gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1100 // !!! MT this is somewhat brutal; at least optionally, one could be
1101 // a bit gentler, checking for objs owning their external refs and having
1102 // additinal parents.
1103 gEve->GetViewers()->DeleteAnnotations();
1104 fTransients->DestroyElements();
1105 for (TEveElement::List_i i = fTransientLists->BeginChildren();
1106 i != fTransientLists->EndChildren(); ++i)
1108 (*i)->DestroyElements();
1112 AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1115 if (fESDTree->GetEntry(event) <= 0)
1116 throw (kEH + "failed getting required event from ESD.");
1118 if (fESDfriendExists)
1119 fESD->SetESDfriend(fESDfriend);
1123 if (fHLTESDTree->GetEntry(event) <= 0)
1124 throw (kEH + "failed getting required event from HLT ESD.");
1126 if (fESDfriendExists)
1127 fESD->SetESDfriend(fESDfriend);
1131 if (fAODTree->GetEntry(event) <= 0)
1132 throw (kEH + "failed getting required event from AOD.");
1136 if (fRunLoader->GetEvent(event) != 0)
1137 throw (kEH + "failed getting required event.");
1142 // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1143 if (fRawReader->GotoEvent(event) == kFALSE)
1145 // Use fallback method - iteration with NextEvent().
1146 Int_t rawEv = fEventId;
1149 fRawReader->RewindEvents();
1153 while (rawEv < event)
1155 if ( ! fRawReader->NextEvent())
1157 fRawReader->RewindEvents();
1159 throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1163 Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1169 if (this == fgMaster)
1171 SetName(Form("Event %d", fEventId));
1175 AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1177 AfterNewEventLoaded();
1179 AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1182 void AliEveEventManager::Timeout()
1187 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1190 InitOCDB(event->GetRunNumber());
1191 printf("======================= setting event to %d\n", fEventId);
1192 SetEvent(0,0,event,0);
1195 void AliEveEventManager::NextEvent()
1197 // Loads next event.
1198 // Does magick needed for online display when under external event control.
1200 static const TEveException kEH("AliEveEventManager::NextEvent ");
1202 if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1207 if(fIsNewEventAvaliable)
1210 if(fWritingToEventIndex == 0) fEventInUse = 0;
1211 else if(fWritingToEventIndex == 1) fEventInUse = 1;
1213 if(fCurrentEvent[fEventInUse])
1215 if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1217 printf("======================= setting event to %d\n", fEventId);
1220 InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1221 SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1225 fIsNewEventAvaliable = false;
1230 cout<<"No new event is avaliable."<<endl;
1235 else if ((fESDTree!=0) || (fHLTESDTree!=0))
1238 if (fPEventSelector->FindNext(nextevent))
1240 GotoEvent(nextevent);
1243 else if (fEventId < GetMaxEventId(kTRUE))
1245 GotoEvent(fEventId + 1);
1248 gSystem->ProcessEvents();
1252 AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1253 cout<<"contructor called"<<endl;
1254 vsdCreator->CreateVSD("myVSD.root");
1257 //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1260 void AliEveEventManager::PrevEvent()
1262 // Loads previous event.
1264 static const TEveException kEH("AliEveEventManager::PrevEvent ");
1266 if (fAutoLoadTimerRunning)
1268 throw (kEH + "Event auto-load timer is running.");
1272 throw (kEH + "Event-loop is under external control.");
1275 if ((fESDTree!=0) || (fHLTESDTree!=0))
1278 if (fPEventSelector->FindPrev(nextevent))
1280 GotoEvent(nextevent);
1283 else if (fEventId > 0)
1285 GotoEvent(fEventId - 1);
1289 void AliEveEventManager::MarkCurrentEvent()
1292 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1293 struct eventStruct mark;
1294 mark.runNumber = fESD->GetRunNumber();
1295 mark.eventNumber = fESD->GetEventNumberInFile();
1296 requestMessage->messageType = REQUEST_MARK_EVENT;
1297 requestMessage->event = mark;
1299 AliStorageEventManager *eventManager =
1300 AliStorageEventManager::GetEventManagerInstance();
1301 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1304 std::future<bool> unused = std::async([]()
1306 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1307 bool response = eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1311 //fStatusLabel->SetText("Event marked");
1312 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1316 //fStatusLabel->SetText("Couldn't mark this event");
1317 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1322 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1323 bool response = eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1328 //fStatusLabel->SetText("Event marked");
1329 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1333 //fStatusLabel->SetText("Couldn't mark this event");
1334 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1336 if(requestMessage){delete requestMessage;}
1340 void AliEveEventManager::Close()
1342 // Close the event data-files and delete ESD, ESDfriend, run-loader
1345 static const TEveException kEH("AliEveEventManager::Close ");
1349 throw (kEH + "Event-files not opened.");
1352 if (fAutoLoadTimerRunning)
1353 StopAutoLoadTimer();
1355 if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1356 delete fESD; fESD = 0;
1357 // delete fESDfriend; // friend tree is deleted with the tree
1359 fESDfriendExists = kFALSE;
1361 if(fESDTree) { delete fESDTree; fESDTree = 0; }
1362 if(fHLTESDTree) { delete fHLTESDTree; fHLTESDTree = 0; }
1363 delete fESDFile; fESDFile = 0;
1367 delete fAOD; fAOD = 0;
1369 delete fAODTree; fAODTree = 0;
1370 delete fAODFile; fAODFile = 0;
1374 delete fRunLoader; fRunLoader = 0;
1378 delete fRawReader; fRawReader = 0;
1387 //------------------------------------------------------------------------------
1388 // Static convenience functions, mainly used from macros.
1389 //------------------------------------------------------------------------------
1391 Int_t AliEveEventManager::CurrentEventId()
1393 // Return current event-id.
1395 static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1397 if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1398 throw (kEH + "ALICE event not ready.");
1399 return fgCurrent->GetEventId();
1402 Bool_t AliEveEventManager::HasRunLoader()
1404 // Check if AliRunLoader is initialized.
1406 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1409 Bool_t AliEveEventManager::HasESD()
1411 // Check if AliESDEvent is initialized.
1413 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1416 Bool_t AliEveEventManager::HasESDfriend()
1418 // Check if AliESDfriend is initialized.
1420 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1423 Bool_t AliEveEventManager::HasAOD()
1425 // Check if AliESDEvent is initialized.
1427 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1430 Bool_t AliEveEventManager::HasRawReader()
1432 // Check if raw-reader is initialized.
1434 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1437 AliRunLoader* AliEveEventManager::AssertRunLoader()
1439 // Make sure AliRunLoader is initialized and return it.
1440 // Throws exception in case run-loader is not available.
1441 // Static utility for macros.
1443 static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
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;
1452 AliESDEvent* AliEveEventManager::AssertESD()
1454 // Make sure AliESDEvent is initialized and return it.
1455 // Throws exception in case ESD is not available.
1456 // Static utility for macros.
1458 static const TEveException kEH("AliEveEventManager::AssertESD ");
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;
1467 AliESDfriend* AliEveEventManager::AssertESDfriend()
1469 // Make sure AliESDfriend is initialized and return it.
1470 // Throws exception in case ESDfriend-loader is not available.
1471 // Static utility for macros.
1473 static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
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;
1482 AliAODEvent* AliEveEventManager::AssertAOD()
1484 // Make sure AliAODEvent is initialized and return it.
1485 // Throws exception in case AOD is not available.
1486 // Static utility for macros.
1488 static const TEveException kEH("AliEveEventManager::AssertAOD ");
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;
1497 AliRawReader* AliEveEventManager::AssertRawReader()
1499 // Make sure raw-reader is initialized and return it.
1501 static const TEveException kEH("AliEveEventManager::AssertRawReader ");
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.");
1508 return fgCurrent->fRawReader;
1511 //==============================================================================
1513 AliMagF* AliEveEventManager::AssertMagField()
1515 // Make sure AliMagF is initialized and returns it.
1516 // Throws exception in case magnetic field is not available.
1517 // Static utility for macros.
1519 static const TEveException kEH("AliEveEventManager::AssertMagField ");
1524 if (TGeoGlobalMagField::Instance()->GetField())
1526 fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1527 if (fgMagField == 0)
1528 throw kEH + "Global field set, but it is not AliMagF.";
1537 if (TGeoGlobalMagField::Instance()->GetField())
1539 fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1540 if (fgMagField == 0)
1541 throw kEH + "Global field set, but it is not AliMagF.";
1545 throw kEH + "Could not initialize magnetic field.";
1551 TGeoManager* AliEveEventManager::AssertGeometry()
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.
1560 static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1562 if (AliGeomManager::GetGeometry() == 0)
1564 if (TGeoManager::IsLocked())
1565 throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1568 AliGeomManager::LoadGeometry();
1569 if ( ! AliGeomManager::GetGeometry())
1571 throw (kEH + "can not load geometry.");
1573 if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1575 ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1576 // throw (kEH + "could not apply align objs.");
1578 AliGeomManager::GetGeometry()->DefaultColors();
1581 gGeoManager = AliGeomManager::GetGeometry();
1585 AliRecoParam* AliEveEventManager::AssertRecoParams()
1593 Bool_t AliEveEventManager::InitRecoParam()
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.
1599 fgRecoParam = new AliRecoParam;
1600 const Int_t kNDetectors = 14;
1602 static const TEveException kEH("AliEveEventManager::InitRecoParam");
1604 Bool_t isOK = kTRUE;
1606 if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1607 ::Info(kEH, "Using custom GRP reconstruction parameters");
1610 ::Info(kEH, "Loading GRP reconstruction parameter objects");
1612 AliCDBPath path("GRP","Calib","RecoParam");
1613 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1615 ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
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));
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));
1633 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1640 const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1643 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1645 if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1646 ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1650 ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1652 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1653 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1655 ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
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));
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));
1673 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1689 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1691 if(!fESDFile && !fESD) return 0;
1693 static const TEveException kEH("AliEveEventManager::readESDTree ");
1695 TTree* tempTree = 0;
1697 tempTree =(TTree*) fESDFile->Get(treeName);
1700 TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1703 if (!esdFriendFile->IsZombie())
1705 esdFriendFile->Close();
1706 fESDfriendExists = kTRUE;
1707 tempTree->SetBranchStatus ("ESDfriend*", 1);
1709 delete esdFriendFile;
1712 fESD->ReadFromTree(tempTree);
1713 if (fESDfriendExists)
1715 fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1716 Info(kEH, "found and attached ESD friend.");
1720 Warning(kEH, "ESDfriend not found.");
1723 if (tempTree->GetEntry(0) <= 0)
1725 Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1730 runNo = fESD->GetESDRun()->GetRunNumber();
1735 Warning(kEH, "failed getting the tree:%s", treeName);
1742 //------------------------------------------------------------------------------
1744 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1746 // Create and attach a dependent event-manager.
1747 // It is not added into eve list tree.
1749 static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1752 throw(kEH + "Master event-manager must be instantiated first.");
1754 if (fgMaster->fSubManagers == 0)
1756 fgMaster->fSubManagers = new TList;
1757 fgMaster->fSubManagers->SetOwner(kTRUE);
1760 AliEveEventManager* new_mgr = 0;
1764 new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1765 new_mgr->SetFilesPath(path);
1766 fgMaster->fSubManagers->Add(new_mgr);
1768 catch (TEveException& exc)
1770 ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1772 fgCurrent = fgMaster;
1777 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1779 // Get a dependant manager by name.
1780 // This will not change the current manager, use helper class
1781 // AliEveEventManager::CurrentChanger for that.
1783 static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1786 throw(kEH + "Master event-manager must be instantiated first.");
1788 if (fgMaster->fSubManagers == 0)
1791 return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1794 AliEveEventManager* AliEveEventManager::GetMaster()
1796 // Get master event-manager.
1801 AliEveEventManager* AliEveEventManager::GetCurrent()
1803 // Get current event-manager.
1808 void AliEveEventManager::RegisterTransient(TEveElement* element)
1810 GetCurrent()->fTransients->AddElement(element);
1813 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1815 GetCurrent()->fTransientLists->AddElement(element);
1818 //------------------------------------------------------------------------------
1819 // Autoloading of events
1820 //------------------------------------------------------------------------------
1822 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1824 // Set the auto-load time in seconds
1826 fAutoLoadTime = time;
1829 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1831 // Set the automatic event loading mode
1833 static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1835 if (fAutoLoad == autoLoad)
1837 Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1841 fAutoLoad = autoLoad;
1844 StartAutoLoadTimer();
1848 StopAutoLoadTimer();
1852 void AliEveEventManager::SetLoopMarked(Bool_t loopMarked)
1854 // Set the automatic event loading mode
1855 fLoopMarked = loopMarked;
1856 if (fLoopMarked){StartAutoLoadTimer();}
1857 else{StopAutoLoadTimer();}
1860 void AliEveEventManager::SetTrigSel(Int_t trig)
1862 static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1866 Warning(kEH, "No Raw-reader exists. Ignoring the call.");
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);
1878 void AliEveEventManager::StartAutoLoadTimer()
1880 // Start the auto-load timer.
1882 fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1883 fAutoLoadTimer->Reset();
1884 fAutoLoadTimer->TurnOn();
1885 fAutoLoadTimerRunning = kTRUE;
1888 void AliEveEventManager::StopAutoLoadTimer()
1890 // Stop the auto-load timer.
1892 fAutoLoadTimerRunning = kFALSE;
1893 fAutoLoadTimer->TurnOff();
1896 void AliEveEventManager::AutoLoadNextEvent()
1898 // Called from auto-load timer, so it has to be public.
1899 // Do NOT call it directly.
1901 static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1903 Info(kEH, "called!");
1905 if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1907 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1911 StopAutoLoadTimer();
1913 if (fAutoLoad || fLoopMarked)
1914 StartAutoLoadTimer();
1917 //------------------------------------------------------------------------------
1918 // Post event-loading functions
1919 //------------------------------------------------------------------------------
1921 void AliEveEventManager::AfterNewEventLoaded()
1923 // Execute registered macros and commands.
1924 // At the end emit NewEventLoaded signal.
1926 // Virtual from TEveEventManager.
1928 static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1930 Info(kEH, "------------------!!!------------");
1932 NewEventDataLoaded();
1933 if (fExecutor) fExecutor->ExecMacros();
1935 TEveEventManager::AfterNewEventLoaded();
1938 if (this == fgMaster && fSubManagers != 0)
1940 TIter next(fSubManagers);
1941 while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1943 gEve->SetCurrentEvent(fgCurrent);
1946 fgCurrent->GotoEvent(fEventId);
1948 catch (TEveException& exc)
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());
1954 Info(kEH, "------------------!!! while() gEve->SetCurrentEvent() ------------");
1956 fgCurrent = fgMaster;
1957 Info(kEH, "------------------!!! while() gEve->SetCurrentEvent(MASTER) ------------");
1958 gEve->SetCurrentEvent(fgMaster);
1962 void AliEveEventManager::NewEventDataLoaded()
1964 // Emit NewEventDataLoaded signal.
1965 Emit("NewEventDataLoaded()");
1967 void AliEveEventManager::NewEventLoaded()
1969 // Emit NewEventLoaded signal.
1970 Emit("NewEventLoaded()");
1972 void AliEveEventManager::NoEventLoaded()
1974 // Emit NoEventLoaded signal.
1975 Emit("NoEventLoaded()");
1977 void AliEveEventManager::StorageManagerOk()
1979 // Emit StorageManagerOk signal.
1980 Emit("StorageManagerOk()");
1982 void AliEveEventManager::StorageManagerDown()
1984 // Emit StorageManagerOk signal.
1985 Emit("StorageManagerDown()");
1989 //------------------------------------------------------------------------------
1990 // Event info dumpers
1991 //------------------------------------------------------------------------------
1993 const AliEventInfo* AliEveEventManager::GetEventInfo()
1995 // Fill the event info object
1997 AliCentralTrigger *aCTP = NULL;
1999 fEventInfo.SetEventType(fRawReader->GetType());
2001 ULong64_t mask = fRawReader->GetClassMask();
2002 fEventInfo.SetTriggerMask(mask);
2003 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2004 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
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!");
2013 aCTP->SetClassMask(mask);
2014 aCTP->SetClusterMask(clmask);
2017 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
2019 rlCTP->SetClassMask(mask);
2020 rlCTP->SetClusterMask(clmask);
2025 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
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()));
2038 AliWarning("No trigger can be loaded! The trigger information will not be used!");
2043 AliTriggerConfiguration *config = aCTP->GetConfiguration();
2045 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
2046 if (fRawReader) delete aCTP;
2050 TString declTriggerClasses;
2052 // Load trigger aliases and declare the trigger classes included in aliases
2053 AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
2055 THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
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
2062 while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
2063 declTriggerClasses += " ";
2064 declTriggerClasses += nmd->GetName();
2068 AliError("Cannot cast the object with trigger aliases to THashList!");
2072 AliError("No OCDB entry for the trigger aliases!");
2075 // Load trigger classes for this run
2076 UChar_t clustmask = 0;
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)) {
2089 trclasses += trclass->GetName();
2091 clustmask |= trclass->GetCluster()->GetClusterMask();
2095 fEventInfo.SetTriggerClasses(trclasses);
2097 if (!aCTP->CheckTriggeredDetectors()) {
2098 if (fRawReader) delete aCTP;
2102 if (fRawReader) delete aCTP;
2104 // everything went ok, return pointer
2105 return (&fEventInfo);
2109 TString AliEveEventManager::GetEventInfoHorizontal() const
2111 // Dumps the event-header contents in vertical formatting.
2113 TString rawInfo, esdInfo;
2117 rawInfo = "No raw-data event info is available!\n";
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"));
2134 esdInfo = "No ESD event info is available!";
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());
2151 return rawInfo + esdInfo;
2154 TString AliEveEventManager::GetEventInfoVertical() const
2156 // Dumps the event-header contents in vertical formatting.
2158 TString rawInfo, esdInfo;
2162 rawInfo = "No raw-data event info is available!\n";
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());
2178 esdInfo = "No ESD event info is available!\n";
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());
2194 return rawInfo + "\n" + esdInfo;
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 //==============================================================================
2204 Bool_t AliEveEventManager::InitGRP()
2206 //------------------------------------
2207 // Initialization of the GRP entry
2208 //------------------------------------
2210 static const TEveException kEH("AliEveEventManager::InitGRP ");
2212 AliGRPManager grpMgr;
2213 if (!grpMgr.ReadGRPEntry()) {
2216 fgGRPLoaded = kTRUE;
2217 if (!grpMgr.SetMagField()) {
2218 throw kEH + "Setting of field failed!";
2221 //*** Get the diamond profiles from OCDB
2222 // Eventually useful.
2225 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
2227 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
2229 ::Error(kEH, "No SPD diamond profile found in OCDB!");
2232 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
2234 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
2236 ::Error(kEH, "No diamond profile found in OCDB!");
2239 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
2241 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
2243 ::Error(kEH, "No TPC diamond profile found in OCDB!");
2250 //------------------------------------
2251 // Global variables management
2252 //------------------------------------
2254 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model)
2256 // Insert a new visualization-parameter database entry with the default
2257 return InsertGlobal(tag, model, fGlobalReplace, fGlobalUpdate);
2260 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model,
2261 Bool_t replace, Bool_t update)
2263 TPair* pair = (TPair*) fGlobal->FindObject(tag);
2268 model->IncDenyDestroy();
2269 model->SetRnrChildren(kFALSE);
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())
2275 TEveElement *el = old_model->FirstChild();
2276 el->SetVizModel(model);
2279 el->CopyVizParams(model);
2280 el->PropagateVizParamsToProjecteds();
2283 old_model->DecDenyDestroy();
2285 pair->SetValue(dynamic_cast<TObject*>(model));
2295 model->IncDenyDestroy();
2296 model->SetRnrChildren(kFALSE);
2297 fGlobal->Add(new TObjString(tag), dynamic_cast<TObject*>(model));
2302 TEveElement* AliEveEventManager::FindGlobal(const TString& tag)
2304 return dynamic_cast<TEveElement*>(fGlobal->GetValue(tag));
2306 Int_t AliEveEventManager::NewEventAvailable()
2308 if (fIsNewEventAvaliable)