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"
71 //==============================================================================
72 //==============================================================================
74 //==============================================================================
76 //______________________________________________________________________________
78 // Provides interface for loading and navigating standard AliRoot data
79 // (AliRunLoader), ESD, AOD and RAW.
81 // ESDfriend is attached automatically, if the file is found.
83 // AODfriends are not attached automatically as there are several
84 // possible files involved. To have a specific AODfriend attached, call
86 // AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
87 // before initializing the event-manager.
89 // Also provides interface to magnetic-field and geometry. Mostly
90 // intended as wrappers over standard AliRoot functionality for
91 // convenient use from visualizateion macros.
93 // There can be a single main event-manger, it is stored in private
94 // data member fgMaster and can be accessed via static member function
97 // For event overlaying and embedding one can instantiate additional
98 // event-managers via static method AddDependentManager(const TString& path).
99 // This interface is under development.
101 ClassImp(AliEveEventManager)
103 Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
104 Bool_t AliEveEventManager::fgAssertESD = kFALSE;
105 Bool_t AliEveEventManager::fgAssertAOD = kFALSE;
106 Bool_t AliEveEventManager::fgAssertRaw = kFALSE;
108 TString AliEveEventManager::fgESDFileName("AliESDs.root");
109 AliEveEventManager::EVisibleESDTrees AliEveEventManager::fgESDvisibleTrees(AliEveEventManager::kOfflineTree);
110 TString AliEveEventManager::fgESDfriendsFileName("AliESDfriends.root");
111 TString AliEveEventManager::fgAODFileName("AliAOD.root");
112 TString AliEveEventManager::fgGAliceFileName("galice.root");
113 TString AliEveEventManager::fgRawFileName("raw.root");
114 TString AliEveEventManager::fgCdbUri;
116 TList* AliEveEventManager::fgAODfriends = 0;
118 Bool_t AliEveEventManager::fgRawFromStandardLoc = kFALSE;
120 Bool_t AliEveEventManager::fgGRPLoaded = kFALSE;
121 AliMagF* AliEveEventManager::fgMagField = 0;
122 AliRecoParam* AliEveEventManager::fgRecoParam = 0;
123 Bool_t AliEveEventManager::fgUniformField = kFALSE;
125 AliEveEventManager* AliEveEventManager::fgMaster = 0;
126 AliEveEventManager* AliEveEventManager::fgCurrent = 0;
128 AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
129 TEveEventManager(name, ""),
132 fESDFile (0), fESDTree (0), fHLTESDTree(0), fESD (0),
133 fESDfriend (0), fESDfriendExists(kFALSE),
134 fAODFile (0), fAODTree (0), fAOD (0),
135 fRawReader (0), fEventInfo(),
136 fAutoLoad (kFALSE),fLoopMarked(kFALSE), fAutoLoadTime (5), fAutoLoadTimer(0),
137 fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
138 fGlobal (0), fGlobalReplace (kTRUE), fGlobalUpdate (kTRUE),
139 fExecutor (0), fTransients(0), fTransientLists(0),
142 fAutoLoadTimerRunning(kFALSE),
143 fMutex(new TMutex()),
144 fgSubSock(EVENTS_SERVER_SUB),
146 fWritingToEventIndex(0),
147 fIsNewEventAvaliable(false),
151 // Constructor with event-id.
161 if (0 == name.CompareTo("online")) {
165 fOnlineMode = kFALSE;
170 cout<<"ZMQ FOUND. Starting subscriber thread."<<endl;
171 fEventListenerThread = new TThread("fEventListenerThread",DispatchEventListener,(void*)this);
172 fEventListenerThread->Run();
174 fStorageManagerWatcherThread = new TThread("fStorageManagerWatcherThread",DispatchStorageManagerWatcher,(void*)this);
175 fStorageManagerWatcherThread->Run();
177 cout<<"NO ZMQ FOUND. Online events not avaliable."<<endl;
181 AliEveEventManager::~AliEveEventManager()
187 if(fEventListenerThread)
189 fEventListenerThread->Kill();
190 delete fEventListenerThread;
192 if(fStorageManagerWatcherThread)
194 fStorageManagerWatcherThread->Kill();
195 delete fStorageManagerWatcherThread;
199 fAutoLoadTimer->Stop();
200 fAutoLoadTimer->Disconnect("Timeout");
201 fAutoLoadTimer->Disconnect("AutoLoadNextEvent");
203 AliEveEventManager *manager = AliEveEventManager::GetCurrent();
204 manager->Disconnect("StorageManagerOk");
205 manager->Disconnect("StorageManagerDown");
207 if(fSubManagers){delete fSubManagers;}
208 if(fMutex){delete fMutex;}
215 // fTransients->DecDenyDestroy();
216 // fTransients->Destroy();
218 // fTransientLists->DecDenyDestroy();
219 // fTransientLists->Destroy();
224 void AliEveEventManager::GetNextEvent()
227 AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
228 eventManager->CreateSocket(EVENTS_SERVER_SUB);
229 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
234 AliESDEvent *tmpEvent = NULL;
236 // get list of marked events:
237 struct listRequestStruct list;
240 list.runNumber[1]=999999;
241 list.eventNumber[0]=0;
242 list.eventNumber[1]=999999;
245 list.multiplicity[0]=1;
246 list.multiplicity[1]=999999;
247 strcpy(list.system[0],"p-p");
248 strcpy(list.system[1],"A-A");
250 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
251 requestMessage->messageType = REQUEST_LIST_EVENTS;
252 requestMessage->list = list;
254 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
255 vector<serverListStruct> receivedList = eventManager->GetServerListVector(SERVER_COMMUNICATION_REQ);
257 cout<<"EVENT DISPLAY -- received list of marked events"<<endl;
259 for(int i=0;i<receivedList.size();i++)
261 cout<<"ev:"<<receivedList[i].eventNumber<<endl;
269 cout<<"taking event from reco server"<<endl;
270 tmpEvent = eventManager->GetEvent(EVENTS_SERVER_SUB,5);
271 if(!tmpEvent){sleep(1);}
275 cout<<"taking event from storage manager"<<endl;
276 if(iter<receivedList.size())
278 cout<<"i:"<<iter<<endl;
279 struct eventStruct mark;
280 mark.runNumber = receivedList[iter].runNumber;
281 mark.eventNumber = receivedList[iter].eventNumber;
283 requestMessage->messageType = REQUEST_GET_EVENT;
284 requestMessage->event = mark;
286 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
287 tmpEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
297 if(tmpEvent->GetRunNumber()>=0)
300 if(fEventInUse == 0){fWritingToEventIndex = 1;}
301 else if(fEventInUse == 1){fWritingToEventIndex = 0;}
302 cout<<"Received new event:"<<tmpEvent->GetEventNumberInFile()<<endl;
303 if(fCurrentEvent[fWritingToEventIndex])
305 delete fCurrentEvent[fWritingToEventIndex];
306 fCurrentEvent[fWritingToEventIndex]=0;
308 fCurrentEvent[fWritingToEventIndex] = tmpEvent;
309 fIsNewEventAvaliable = true;
314 else{cout<<"didn't receive new event"<<endl;}
316 delete requestMessage;
321 void AliEveEventManager::CheckStorageStatus()
324 AliEveConfigManager *configManager = AliEveConfigManager::GetMaster();
325 configManager->ConnectEventManagerSignals();
327 AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
328 eventManager->CreateSocket(CLIENT_COMMUNICATION_REQ);
330 struct clientRequestStruct *request = new struct clientRequestStruct;
331 request->messageType = REQUEST_CONNECTION;
335 if(eventManager->Send(request,CLIENT_COMMUNICATION_REQ,5000))
338 long response = eventManager->GetLong(CLIENT_COMMUNICATION_REQ);
339 fStorageDown = kFALSE;
343 StorageManagerDown();
344 cout<<"WARNING -- Storage Manager is DOWN!!"<<endl;
345 fStorageDown = kTRUE;
352 void AliEveEventManager::InitInternals()
354 // Initialize internal members.
356 static const TEveException kEH("AliEveEventManager::InitInternals ");
360 throw(kEH + "Dependent event-managers should be created via static method AddDependentManager().");
370 fAutoLoadTimer = new TTimer;
371 fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
372 fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "Timeout()");
374 fExecutor = new AliEveMacroExecutor;
376 fTransients = new TEveElementList("Transients", "Transient per-event elements.");
377 fTransients->IncDenyDestroy();
378 gEve->AddToListTree(fTransients, kFALSE);
380 fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
381 fTransientLists->IncDenyDestroy();
382 gEve->AddToListTree(fTransientLists, kFALSE);
384 fPEventSelector = new AliEveEventSelector(this);
386 fGlobal = new TMap; fGlobal->SetOwnerKeyValue();
389 /******************************************************************************/
391 void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
393 fgESDvisibleTrees = shown;
394 // Set file-name for opening ESD, default "AliESDs.root".
395 if (esd.IsNull()) return;
398 if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
402 void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
404 // Set file-name for opening ESD friend, default "AliESDfriends.root".
406 if (esdf.IsNull()) return;
407 fgESDfriendsFileName = esdf;
409 if (esdf.EndsWith(".zip")) fgESDfriendsFileName.Form("%s#AliESDfriends.root",esdf.Data());
412 void AliEveEventManager::SetAODFileName(const TString& aod)
414 // Set file-name for opening AOD, default "AliAOD.root".
416 if (aod.IsNull()) return;
419 if (aod.EndsWith(".zip")) fgAODFileName.Form("%s#AliAOD.root",aod.Data());
423 void AliEveEventManager::AddAODfriend(const TString& friendFileName)
425 // Add new AOD friend file-name to be attached when opening AOD.
426 // This should include '.root', as in 'AliAOD.VertexingHF.root'.
428 if (fgAODfriends == 0)
430 fgAODfriends = new TList;
431 fgAODfriends->SetOwner(kTRUE);
433 if (fgAODfriends->FindObject(friendFileName) == 0)
435 fgAODfriends->Add(new TObjString(friendFileName));
439 void AliEveEventManager::SetRawFileName(const TString& raw)
441 // Set file-name for opening of raw-data, default "raw.root"
442 if (raw.IsNull()) return;
447 void AliEveEventManager::SetCdbUri(const TString& cdb)
449 // Set path to CDB, there is no default.
450 if ( ! cdb.IsNull()) fgCdbUri = cdb;
453 void AliEveEventManager::SetGAliceFileName(const TString& galice)
455 // Set file-name for opening gAlice, default "galice.root".
457 if ( galice.IsNull()) return;
458 fgGAliceFileName = galice;
460 if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
463 void AliEveEventManager::SetFilesPath(const TString& urlPath)
465 TString path = urlPath;
466 gSystem->ExpandPathName(path);
467 if (path.IsNull() || path == ".")
469 path = gSystem->WorkingDirectory();
473 if(path.EndsWith(".zip")) // if given a path to root_archive.zip
475 else if(!path.EndsWith("/"))
478 SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
479 SetESDfriendFileName( TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
480 SetAODFileName( TString(Form("%s%sAliAOD.root", path.Data(), sep.Data())) );
481 AddAODfriend( TString(Form("%s%sAliAOD.VertexingHF.root", path.Data(), sep.Data())) );
482 SetGAliceFileName( TString(Form("%s%sgalice.root", path.Data(), sep.Data())) );
483 SetRawFileName(TString(Form("%s%sraw.root", path.Data(), sep.Data())));
486 void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
487 Bool_t assertAod, Bool_t assertRaw)
489 // Set global flags that detrmine which parts of the event-data must
490 // be present when the event is opened.
492 fgAssertRunLoader = assertRunloader;
493 fgAssertESD = assertEsd;
494 fgAssertAOD = assertAod;
495 fgAssertRaw = assertRaw;
498 void AliEveEventManager::SearchRawForCentralReconstruction()
500 // Enable searching of raw data in standard location. The path passed to
501 // Open() is expected to point to a centrally reconstructed run, e.g.:
502 // "alien:///alice/data/2009/LHC09c/000101134/ESDs/pass1/09000101134018.10".
504 fgRawFromStandardLoc = kTRUE;
507 /******************************************************************************/
509 void AliEveEventManager::Open()
511 // Open event-data from URL specified in path.
512 // Attempts to create AliRunLoader() and to open ESD with ESDfriends.
513 // Warning is reported if run-loader or ESD is not found.
514 // Global data-members fgAssertRunLoader and fgAssertESD can be set
515 // to throw exceptions instead.
517 static const TEveException kEH("AliEveEventManager::Open ");
521 throw (kEH + "Event-loop is under external control.");
525 throw (kEH + "Event-files already opened.");
530 // Open ESD and ESDfriends
532 if ((fESDFile = TFile::Open(fgESDFileName)))
534 fESD = new AliESDEvent();
536 switch(fgESDvisibleTrees){
537 case AliEveEventManager::kOfflineTree :
538 fESDTree = readESDTree("esdTree", runNo);
540 case AliEveEventManager::kHLTTree :
541 fHLTESDTree = readESDTree("HLTesdTree", runNo);
544 fESDTree = readESDTree("esdTree", runNo);
545 fHLTESDTree = readESDTree("HLTesdTree", runNo);
548 if(!fESDTree && !fHLTESDTree){
549 // both ESD trees are == 0
550 delete fESDFile; fESDFile = 0;
551 delete fESD; fESD = 0;
556 else // esd file not readable
558 Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
560 if (fESDTree == 0 && fHLTESDTree==0)
564 throw (kEH + "ESD not initialized. Its precence was requested.");
566 Warning(kEH, "ESD not initialized.");
570 // Open AOD and registered friends
571 if ( (fAODFile = TFile::Open(fgAODFileName)) )
573 fAOD = new AliAODEvent();
574 fAODTree = (TTree*) fAODFile->Get("aodTree");
577 // Check if AODfriends exist and attach them.
578 TIter friends(fgAODfriends);
580 while ((name = (TObjString*) friends()) != 0)
582 TString p(Form("%s/%s", fgAODFileName.Data(), name->GetName()));
583 if (fgAODFileName.EndsWith(".zip")) p.Form("%s#%s",fgAODFileName.Data(),name->GetName());
584 if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
586 fAODTree->AddFriend("aodTree", name->GetName());
590 fAOD->ReadFromTree(fAODTree);
592 if (fAODTree->GetEntry(0) <= 0)
594 delete fAODFile; fAODFile = 0;
595 delete fAOD; fAOD = 0;
596 Warning(kEH, "failed getting the first entry from addTree.");
601 runNo = fAOD->GetRunNumber();
606 delete fAODFile; fAODFile = 0;
607 delete fAOD; fAOD = 0;
608 Warning(kEH, "failed getting the aodTree.");
611 else // aod not readable
613 Warning(kEH, "can not read AOD file '%s'.", fgAODFileName.Data());
619 throw (kEH + "AOD not initialized. Its precence was requested.");
621 Warning(kEH, "AOD not initialized.");
625 // Open RunLoader from galice.root
626 // fgGAliceFileName = "/Users/Jerus/galice.root"; // temp
628 TFile *gafile = TFile::Open(fgGAliceFileName);
629 cout<<"Opening galice"<<endl;
634 cout<<"SETTING RUN LOADER in Open()"<<endl;
635 fRunLoader = AliRunLoader::Open(fgGAliceFileName, GetName());
638 TString alicePath(gSystem->DirName(fgGAliceFileName));
639 alicePath.Append("/");
640 fRunLoader->SetDirName(alicePath);
642 if (fRunLoader->LoadgAlice() != 0)
643 Warning(kEH, "failed loading gAlice via run-loader.");
645 if (fRunLoader->LoadHeader() == 0)
648 runNo = fRunLoader->GetHeader()->GetRun();
652 Warning(kEH, "failed loading run-loader's header.");
657 else // run-loader open failed
659 Warning(kEH, "failed opening ALICE run-loader from '%s'.", fgGAliceFileName.Data());
663 else // galice not readable
665 Warning(kEH, "can not read '%s'.", fgGAliceFileName.Data());
669 if (fgAssertRunLoader)
670 throw (kEH + "Bootstraping of run-loader failed. Its precence was requested.");
672 Warning(kEH, "Bootstraping of run-loader failed.");
675 // Open raw-data file
678 if (fgRawFromStandardLoc)
680 if (!fgRawFileName.BeginsWith("alien:"))
681 throw kEH + "Standard raw search requested, but the directory is not in AliEn.";
682 if (!fgRawFileName.Contains("/ESDs/"))
683 throw kEH + "Standard raw search requested, but does not contain 'ESDs' directory.";
685 TPMERegexp chunk("/([\\d\\.])+/?$");
686 Int_t nm = chunk.Match(fgRawFileName);
688 throw kEH + "Standard raw search requested, but the path does not end with chunk-id directory.";
690 TPMERegexp esdstrip("/ESDs/.*");
691 rawPath = fgRawFileName;
692 esdstrip.Substitute(rawPath, "/raw/");
696 Info(kEH, "Standard raw search requested, using the following path:\n %s\n", rawPath.Data());
700 rawPath = fgRawFileName;
702 // If i use open directly, raw-reader reports an error but i have
703 // no way to detect it.
704 // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
705 AliLog::EType_t oldLogLevel = (AliLog::EType_t) AliLog::GetGlobalLogLevel();
706 if (fgAssertRaw == kFALSE)
708 AliLog::SetGlobalLogLevel(AliLog::kFatal);
710 if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
712 fRawReader = AliRawReader::Create(rawPath);
716 fRawReader = AliRawReader::Create(fgRawFileName);
718 if (fgAssertRaw == kFALSE)
720 AliLog::SetGlobalLogLevel(oldLogLevel);
727 throw (kEH + "raw-data not initialized. Its precence was requested.");
731 Warning(kEH, "raw-data not initialized.");
739 if ( ! fRawReader->NextEvent())
741 throw (kEH + "can not go to first event in raw-reader to determine run-id.");
743 runNo = fRawReader->GetRunNumber();
744 Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
745 fRawReader->RewindEvents();
749 fExternalCtrl = kTRUE;
755 // Initialize OCDB ... only in master event-manager
763 void AliEveEventManager::InitOCDB(int runNo)
765 static const TEveException kEH("AliEveEventManager::InitOCDB ");
766 //if (this == fgMaster)
768 AliCDBManager* cdb = AliCDBManager::Instance();
769 if (cdb->IsDefaultStorageSet() == kTRUE)
771 Warning(kEH, "CDB already set - using the old storage:\n '%s'",
772 cdb->GetDefaultStorage()->GetURI().Data());
776 if (fgCdbUri.IsNull())
778 gEnv->SetValue("Root.Stacktrace", "no");
779 Fatal("Open()", "OCDB path was not specified.");
782 // Handle some special cases for MC (should be in OCDBManager).
783 if (fgCdbUri == "mcideal://")
784 cdb->SetDefaultStorage("MC", "Ideal");
785 else if (fgCdbUri == "mcresidual://")
786 cdb->SetDefaultStorage("MC", "Residual");
787 else if (fgCdbUri == "mcfull://")
788 cdb->SetDefaultStorage("MC", "Full");
789 else if (fgCdbUri == "local://") {
790 fgCdbUri = Form("local://%s/OCDB", gSystem->Getenv("ALICE_ROOT"));
791 cdb->SetDefaultStorage(fgCdbUri);
793 cdb->SetDefaultStorage(fgCdbUri);
797 if (cdb->IsDefaultStorageSet() == kFALSE)
798 throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
801 if (fgCdbUri.BeginsWith("local://"))
803 TString curPath = gSystem->WorkingDirectory();
804 TString grp = "GRP/GRP/Data";
805 TString grppath = curPath + "/" + grp;
806 if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
808 if (cdb->GetSpecificStorage(grp))
810 Warning(kEH, "Local GRP exists, but the specific storage is already set.");
814 Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
815 TString lpath("local://");
817 cdb->SetSpecificStorage(grp, lpath);
824 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
826 // Set an event from an external source.
827 // The method is used in the online visualisation.
828 // AOD is not supported.
830 static const TEveException kEH("AliEveEventManager::SetEvent ");
834 Warning(kEH, "Event-files were open. Closing and switching to external control.");
838 Info(kEH,"setting it!!! ============================");
840 fRunLoader = runLoader;
841 fRawReader = rawReader;
848 fExternalCtrl = kTRUE;
850 SetTitle("Online event in memory");
851 SetName ("Online Event");
854 AfterNewEventLoaded();
856 if (fAutoLoad || fLoopMarked) StartAutoLoadTimer();
860 Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
862 // Returns maximum available event id.
863 // If under external control or event is not opened -1 is returned.
864 // If raw-data is the only data-source this can not be known
865 // and 10,000,000 is returned.
866 // If neither data-source is initialised an exception is thrown.
867 // If refresh_esd is true and ESD is the primary event-data source
868 // its header is re-read from disk.
870 static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
872 if (fExternalCtrl || fIsOpen == kFALSE)
877 if ((fESDTree!=0) || (fHLTESDTree!=0))
881 if(fESDTree!=0) fESDTree->Refresh();
882 if(fHLTESDTree!=0) fHLTESDTree->Refresh();
883 fPEventSelector->Update();
887 switch(fgESDvisibleTrees){
889 case AliEveEventManager::kOfflineTree :
890 maxEventId = fESDTree->GetEntries() - 1;
892 case AliEveEventManager::kHLTTree :
893 maxEventId = fHLTESDTree->GetEntries() - 1;
901 return fAODTree->GetEntries() - 1;
905 return fRunLoader->GetNumberOfEvents() - 1;
909 Int_t n = fRawReader->GetNumberOfEvents() - 1;
910 return n > -1 ? n : 10000000;
914 throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
918 void AliEveEventManager::GotoEvent(Int_t event)
920 cout<<"Go to event:"<<event<<endl;
921 // Load data for specified event.
922 // If event is out of range an exception is thrown and old state
924 // After successful loading of event, the virtual function
925 // AfterNewEventLoaded() is called. This executes commands that
926 // were registered via TEveEventManager::AddNewEventCommand().
928 // If event is negative, it is subtracted from the number of
929 // available events, thus passing -1 will load the last event.
930 // This is not supported when raw-data is the only data-source
931 // as the number of events is not known.
933 static const TEveException kEH("AliEveEventManager::GotoEvent ");
935 if (fAutoLoadTimerRunning)
937 throw (kEH + "Event auto-load timer is running.");
941 // throw (kEH + "Event-loop is under external control.");
943 if (fStorageDown && -1 == event)
951 // create new server request:
952 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
955 if (event == -1) {requestMessage->messageType = REQUEST_GET_LAST_EVENT;}
956 else if (event == 0) {requestMessage->messageType = REQUEST_GET_FIRST_EVENT;}
957 else if (event == 1) {requestMessage->messageType = REQUEST_GET_PREV_EVENT;}
958 else if (event == 2) {requestMessage->messageType = REQUEST_GET_NEXT_EVENT;}
961 struct eventStruct eventToLoad;
962 eventToLoad.runNumber = fESD->GetRunNumber();
963 eventToLoad.eventNumber = fESD->GetEventNumberInFile();
964 requestMessage->event = eventToLoad;
966 // create event manager:
967 AliStorageEventManager *eventManager =
968 AliStorageEventManager::GetEventManagerInstance();
969 AliESDEvent *resultEvent = NULL;
971 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
974 // send request and receive event:
975 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
976 resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
981 InitOCDB(resultEvent->GetRunNumber());
982 SetEvent(0,0,resultEvent,0);
986 if(event==-1){cout<<"\n\nWARNING -- No last event is avaliable.\n\n"<<endl;}
987 if(event==0){cout<<"\n\nWARNING -- No first event is avaliable.\n\n"<<endl;}
988 if(event==1){cout<<"\n\nWARNING -- No previous event is avaliable.\n\n"<<endl;}
989 if(event==2){cout<<"\n\nWARNING -- No next event is avaliable.\n\n"<<endl;}
996 cout<<"\n\nWARNING -- No event has been already loaded. Loading the most recent event...\n\n"<<endl;
998 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
999 requestMessage->messageType = REQUEST_GET_LAST_EVENT;
1001 AliStorageEventManager *eventManager = AliStorageEventManager::GetEventManagerInstance();
1002 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1003 AliESDEvent *resultEvent = NULL;
1006 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1007 resultEvent = eventManager->GetEvent(SERVER_COMMUNICATION_REQ);
1013 InitOCDB(resultEvent->GetRunNumber());
1014 SetEvent(0,0,resultEvent,0);
1016 else{cout<<"\n\nWARNING -- The most recent event is not avaliable.\n\n"<<endl;}
1024 throw (kEH + "Event-files not opened.");
1032 if ((fESDTree!=0) || (fHLTESDTree!=0))
1035 if (event >= fESDTree->GetEntries())
1036 fESDTree->Refresh();
1037 maxEvent = fESDTree->GetEntries() - 1;
1039 event = fESDTree->GetEntries() + event;
1043 if (event >= fHLTESDTree->GetEntries())
1044 fHLTESDTree->Refresh();
1045 maxEvent = fHLTESDTree->GetEntries() - 1;
1047 event = fHLTESDTree->GetEntries() + event;
1053 maxEvent = fAODTree->GetEntries() - 1;
1055 event = fAODTree->GetEntries() + event;
1057 else if (fRunLoader)
1059 maxEvent = fRunLoader->GetNumberOfEvents() - 1;
1061 event = fRunLoader->GetNumberOfEvents() + event;
1063 else if (fRawReader)
1065 maxEvent = fRawReader->GetNumberOfEvents() - 1;
1068 maxEvent = 10000000;
1070 Error(kEH, "current raw-data source does not support direct event access.");
1073 Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
1078 event = fRawReader->GetNumberOfEvents() + event;
1083 throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
1085 if (event < 0 || event > maxEvent)
1087 throw (kEH + Form("event %d not present, available range [%d, %d].",
1088 event, 0, maxEvent));
1091 TString sysInfoHeader;
1092 sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
1093 AliSysInfo::AddStamp(sysInfoHeader + "Start");
1095 TEveManager::TRedrawDisabler rd(gEve);
1096 gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
1098 // !!! MT this is somewhat brutal; at least optionally, one could be
1099 // a bit gentler, checking for objs owning their external refs and having
1100 // additinal parents.
1101 gEve->GetViewers()->DeleteAnnotations();
1102 fTransients->DestroyElements();
1103 for (TEveElement::List_i i = fTransientLists->BeginChildren();
1104 i != fTransientLists->EndChildren(); ++i)
1106 (*i)->DestroyElements();
1110 AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
1113 if (fESDTree->GetEntry(event) <= 0)
1114 throw (kEH + "failed getting required event from ESD.");
1116 if (fESDfriendExists)
1117 fESD->SetESDfriend(fESDfriend);
1121 if (fHLTESDTree->GetEntry(event) <= 0)
1122 throw (kEH + "failed getting required event from HLT ESD.");
1124 if (fESDfriendExists)
1125 fESD->SetESDfriend(fESDfriend);
1129 if (fAODTree->GetEntry(event) <= 0)
1130 throw (kEH + "failed getting required event from AOD.");
1134 if (fRunLoader->GetEvent(event) != 0)
1135 throw (kEH + "failed getting required event.");
1140 // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
1141 if (fRawReader->GotoEvent(event) == kFALSE)
1143 // Use fallback method - iteration with NextEvent().
1144 Int_t rawEv = fEventId;
1147 fRawReader->RewindEvents();
1151 while (rawEv < event)
1153 if ( ! fRawReader->NextEvent())
1155 fRawReader->RewindEvents();
1157 throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
1161 Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
1167 if (this == fgMaster)
1169 SetName(Form("Event %d", fEventId));
1173 AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
1175 AfterNewEventLoaded();
1177 AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
1180 void AliEveEventManager::Timeout()
1185 void AliEveEventManager::PrepareForNewEvent(AliESDEvent *event)
1188 InitOCDB(event->GetRunNumber());
1189 printf("======================= setting event to %d\n", fEventId);
1190 SetEvent(0,0,event,0);
1193 void AliEveEventManager::NextEvent()
1195 // Loads next event.
1196 // Does magick needed for online display when under external event control.
1198 static const TEveException kEH("AliEveEventManager::NextEvent ");
1200 if (fAutoLoadTimerRunning){throw (kEH + "Event auto-load timer is running.");}
1205 if(fIsNewEventAvaliable)
1208 if(fWritingToEventIndex == 0) fEventInUse = 0;
1209 else if(fWritingToEventIndex == 1) fEventInUse = 1;
1211 if(fCurrentEvent[fEventInUse])
1213 if(fCurrentEvent[fEventInUse]->GetRunNumber() >= 0)
1215 printf("======================= setting event to %d\n", fEventId);
1218 InitOCDB(fCurrentEvent[fEventInUse]->GetRunNumber());
1219 SetEvent(0,0,fCurrentEvent[fEventInUse],0);
1223 fIsNewEventAvaliable = false;
1228 cout<<"No new event is avaliable."<<endl;
1233 else if ((fESDTree!=0) || (fHLTESDTree!=0))
1236 if (fPEventSelector->FindNext(nextevent))
1238 GotoEvent(nextevent);
1241 else if (fEventId < GetMaxEventId(kTRUE))
1243 GotoEvent(fEventId + 1);
1246 gSystem->ProcessEvents();
1250 AliEveVSDCreator *vsdCreator = new AliEveVSDCreator();
1251 cout<<"contructor called"<<endl;
1252 vsdCreator->CreateVSD("myVSD.root");
1255 //if(fEventListenerThread){delete fEventListenerThread;fEventListenerThread=0;}
1258 void AliEveEventManager::PrevEvent()
1260 // Loads previous event.
1262 static const TEveException kEH("AliEveEventManager::PrevEvent ");
1264 if (fAutoLoadTimerRunning)
1266 throw (kEH + "Event auto-load timer is running.");
1270 throw (kEH + "Event-loop is under external control.");
1273 if ((fESDTree!=0) || (fHLTESDTree!=0))
1276 if (fPEventSelector->FindPrev(nextevent))
1278 GotoEvent(nextevent);
1281 else if (fEventId > 0)
1283 GotoEvent(fEventId - 1);
1287 void AliEveEventManager::MarkCurrentEvent()
1290 struct serverRequestStruct *requestMessage = new struct serverRequestStruct;
1291 struct eventStruct mark;
1292 mark.runNumber = fESD->GetRunNumber();
1293 mark.eventNumber = fESD->GetEventNumberInFile();
1294 requestMessage->messageType = REQUEST_MARK_EVENT;
1295 requestMessage->event = mark;
1297 AliStorageEventManager *eventManager =
1298 AliStorageEventManager::GetEventManagerInstance();
1299 eventManager->CreateSocket(SERVER_COMMUNICATION_REQ);
1302 std::future<bool> unused = std::async([]()
1304 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1305 bool response = eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1309 //fStatusLabel->SetText("Event marked");
1310 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1314 //fStatusLabel->SetText("Couldn't mark this event");
1315 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1320 eventManager->Send(requestMessage,SERVER_COMMUNICATION_REQ);
1321 bool response = eventManager->GetBool(SERVER_COMMUNICATION_REQ);
1326 //fStatusLabel->SetText("Event marked");
1327 cout<<"ADMIN PANEL -- Event marked succesfully"<<endl;
1331 //fStatusLabel->SetText("Couldn't mark this event");
1332 cout<<"ADMIN PANEL -- Could not matk event"<<endl;
1334 if(requestMessage){delete requestMessage;}
1338 void AliEveEventManager::Close()
1340 // Close the event data-files and delete ESD, ESDfriend, run-loader
1343 static const TEveException kEH("AliEveEventManager::Close ");
1347 throw (kEH + "Event-files not opened.");
1350 if (fAutoLoadTimerRunning)
1351 StopAutoLoadTimer();
1353 if ((fESDTree!=0) || (fHLTESDTree!=0)) {
1354 delete fESD; fESD = 0;
1355 // delete fESDfriend; // friend tree is deleted with the tree
1357 fESDfriendExists = kFALSE;
1359 if(fESDTree) { delete fESDTree; fESDTree = 0; }
1360 if(fHLTESDTree) { delete fHLTESDTree; fHLTESDTree = 0; }
1361 delete fESDFile; fESDFile = 0;
1365 delete fAOD; fAOD = 0;
1367 delete fAODTree; fAODTree = 0;
1368 delete fAODFile; fAODFile = 0;
1372 delete fRunLoader; fRunLoader = 0;
1376 delete fRawReader; fRawReader = 0;
1385 //------------------------------------------------------------------------------
1386 // Static convenience functions, mainly used from macros.
1387 //------------------------------------------------------------------------------
1389 Int_t AliEveEventManager::CurrentEventId()
1391 // Return current event-id.
1393 static const TEveException kEH("AliEveEventManager::CurrentEventId ");
1395 if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1396 throw (kEH + "ALICE event not ready.");
1397 return fgCurrent->GetEventId();
1400 Bool_t AliEveEventManager::HasRunLoader()
1402 // Check if AliRunLoader is initialized.
1404 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRunLoader;
1407 Bool_t AliEveEventManager::HasESD()
1409 // Check if AliESDEvent is initialized.
1411 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESD;
1414 Bool_t AliEveEventManager::HasESDfriend()
1416 // Check if AliESDfriend is initialized.
1418 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
1421 Bool_t AliEveEventManager::HasAOD()
1423 // Check if AliESDEvent is initialized.
1425 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
1428 Bool_t AliEveEventManager::HasRawReader()
1430 // Check if raw-reader is initialized.
1432 return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fRawReader;
1435 AliRunLoader* AliEveEventManager::AssertRunLoader()
1437 // Make sure AliRunLoader is initialized and return it.
1438 // Throws exception in case run-loader is not available.
1439 // Static utility for macros.
1441 static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
1443 if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1444 throw (kEH + "ALICE event not ready.");
1445 if (fgCurrent->fRunLoader == 0)
1446 throw (kEH + "AliRunLoader not initialised.");
1447 return fgCurrent->fRunLoader;
1450 AliESDEvent* AliEveEventManager::AssertESD()
1452 // Make sure AliESDEvent is initialized and return it.
1453 // Throws exception in case ESD is not available.
1454 // Static utility for macros.
1456 static const TEveException kEH("AliEveEventManager::AssertESD ");
1458 if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1459 throw (kEH + "ALICE event not ready.");
1460 if (fgCurrent->fESD == 0)
1461 throw (kEH + "AliESD not initialised.");
1462 return fgCurrent->fESD;
1465 AliESDfriend* AliEveEventManager::AssertESDfriend()
1467 // Make sure AliESDfriend is initialized and return it.
1468 // Throws exception in case ESDfriend-loader is not available.
1469 // Static utility for macros.
1471 static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
1473 if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1474 throw (kEH + "ALICE event not ready.");
1475 if (fgCurrent->fESDfriend == 0)
1476 throw (kEH + "AliESDfriend not initialised.");
1477 return fgCurrent->fESDfriend;
1480 AliAODEvent* AliEveEventManager::AssertAOD()
1482 // Make sure AliAODEvent is initialized and return it.
1483 // Throws exception in case AOD is not available.
1484 // Static utility for macros.
1486 static const TEveException kEH("AliEveEventManager::AssertAOD ");
1488 if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1489 throw (kEH + "ALICE event not ready.");
1490 if (fgCurrent->fAOD == 0)
1491 throw (kEH + "AliAOD not initialised.");
1492 return fgCurrent->fAOD;
1495 AliRawReader* AliEveEventManager::AssertRawReader()
1497 // Make sure raw-reader is initialized and return it.
1499 static const TEveException kEH("AliEveEventManager::AssertRawReader ");
1501 if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
1502 throw (kEH + "ALICE event not ready.");
1503 if (fgCurrent->fRawReader == 0)
1504 throw (kEH + "RawReader not ready.");
1506 return fgCurrent->fRawReader;
1509 //==============================================================================
1511 AliMagF* AliEveEventManager::AssertMagField()
1513 // Make sure AliMagF is initialized and returns it.
1514 // Throws exception in case magnetic field is not available.
1515 // Static utility for macros.
1517 static const TEveException kEH("AliEveEventManager::AssertMagField ");
1522 if (TGeoGlobalMagField::Instance()->GetField())
1524 fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1525 if (fgMagField == 0)
1526 throw kEH + "Global field set, but it is not AliMagF.";
1535 if (TGeoGlobalMagField::Instance()->GetField())
1537 fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
1538 if (fgMagField == 0)
1539 throw kEH + "Global field set, but it is not AliMagF.";
1543 throw kEH + "Could not initialize magnetic field.";
1549 TGeoManager* AliEveEventManager::AssertGeometry()
1551 // Make sure AliGeomManager is initialized and returns the
1552 // corresponding TGeoManger.
1553 // gGeoManager is set to the return value.
1554 // Throws exception if geometry can not be loaded or if it is not
1555 // available and the TGeoManager is locked.
1556 // Static utility for macros.
1558 static const TEveException kEH("AliEveEventManager::AssertGeometry ");
1560 if (AliGeomManager::GetGeometry() == 0)
1562 if (TGeoManager::IsLocked())
1563 throw (kEH + "geometry is not loaded but TGeoManager is locked.");
1566 AliGeomManager::LoadGeometry();
1567 if ( ! AliGeomManager::GetGeometry())
1569 throw (kEH + "can not load geometry.");
1571 if ( ! AliGeomManager::ApplyAlignObjsFromCDB("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO ACORDE"))
1573 ::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
1574 // throw (kEH + "could not apply align objs.");
1576 AliGeomManager::GetGeometry()->DefaultColors();
1579 gGeoManager = AliGeomManager::GetGeometry();
1583 AliRecoParam* AliEveEventManager::AssertRecoParams()
1591 Bool_t AliEveEventManager::InitRecoParam()
1593 // This is mostly a reap-off from reconstruction
1594 // The method accesses OCDB and retrieves all
1595 // the available reco-param objects from there.
1597 fgRecoParam = new AliRecoParam;
1598 const Int_t kNDetectors = 14;
1600 static const TEveException kEH("AliEveEventManager::InitRecoParam");
1602 Bool_t isOK = kTRUE;
1604 if (fgRecoParam->GetDetRecoParamArray(kNDetectors)) {
1605 ::Info(kEH, "Using custom GRP reconstruction parameters");
1608 ::Info(kEH, "Loading GRP reconstruction parameter objects");
1610 AliCDBPath path("GRP","Calib","RecoParam");
1611 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1613 ::Warning(kEH, "Couldn't find GRP RecoParam entry in OCDB");
1617 TObject *recoParamObj = entry->GetObject();
1618 if (dynamic_cast<TObjArray*>(recoParamObj)) {
1619 // GRP has a normal TobjArray of AliDetectorRecoParam objects
1620 // Registering them in AliRecoParam
1621 fgRecoParam->AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
1623 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1624 // GRP has only onse set of reco parameters
1625 // Registering it in AliRecoParam
1626 ::Info(kEH, "Single set of GRP reconstruction parameters found");
1627 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1628 fgRecoParam->AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1631 ::Error(kEH, "No valid GRP RecoParam object found in the OCDB");
1638 const char* fgkDetectorName[kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE" };
1641 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1643 if (fgRecoParam->GetDetRecoParamArray(iDet)) {
1644 ::Info(kEH, "Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]);
1648 ::Info(kEH, "Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]);
1650 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
1651 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
1653 ::Warning(kEH, "Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]);
1657 TObject *recoParamObj = entry->GetObject();
1658 if (dynamic_cast<TObjArray*>(recoParamObj)) {
1659 // The detector has a normal TobjArray of AliDetectorRecoParam objects
1660 // Registering them in AliRecoParam
1661 fgRecoParam->AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
1663 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
1664 // The detector has only onse set of reco parameters
1665 // Registering it in AliRecoParam
1666 ::Info(kEH, "Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]);
1667 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
1668 fgRecoParam->AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
1671 ::Error(kEH, "No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]);
1687 TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
1689 if(!fESDFile && !fESD) return 0;
1691 static const TEveException kEH("AliEveEventManager::readESDTree ");
1693 TTree* tempTree = 0;
1695 tempTree =(TTree*) fESDFile->Get(treeName);
1698 TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
1701 if (!esdFriendFile->IsZombie())
1703 esdFriendFile->Close();
1704 fESDfriendExists = kTRUE;
1705 tempTree->SetBranchStatus ("ESDfriend*", 1);
1707 delete esdFriendFile;
1710 fESD->ReadFromTree(tempTree);
1711 if (fESDfriendExists)
1713 fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
1714 Info(kEH, "found and attached ESD friend.");
1718 Warning(kEH, "ESDfriend not found.");
1721 if (tempTree->GetEntry(0) <= 0)
1723 Warning(kEH, "failed getting the first entry from tree: %s", treeName);
1728 runNo = fESD->GetESDRun()->GetRunNumber();
1733 Warning(kEH, "failed getting the tree:%s", treeName);
1740 //------------------------------------------------------------------------------
1742 AliEveEventManager* AliEveEventManager::AddDependentManager(const TString& name, const TString& path)
1744 // Create and attach a dependent event-manager.
1745 // It is not added into eve list tree.
1747 static const TEveException kEH("AliEveEventManager::AddDependentManager ");
1750 throw(kEH + "Master event-manager must be instantiated first.");
1752 if (fgMaster->fSubManagers == 0)
1754 fgMaster->fSubManagers = new TList;
1755 fgMaster->fSubManagers->SetOwner(kTRUE);
1758 AliEveEventManager* new_mgr = 0;
1762 new_mgr = new AliEveEventManager(name, fgMaster->fEventId);
1763 new_mgr->SetFilesPath(path);
1764 fgMaster->fSubManagers->Add(new_mgr);
1766 catch (TEveException& exc)
1768 ::Error(kEH, "Creation of new event-manager failed: '%s'.", exc.Data());
1770 fgCurrent = fgMaster;
1775 AliEveEventManager* AliEveEventManager::GetDependentManager(const TString& name)
1777 // Get a dependant manager by name.
1778 // This will not change the current manager, use helper class
1779 // AliEveEventManager::CurrentChanger for that.
1781 static const TEveException kEH("AliEveEventManager::GetDependentManager ");
1784 throw(kEH + "Master event-manager must be instantiated first.");
1786 if (fgMaster->fSubManagers == 0)
1789 return dynamic_cast<AliEveEventManager*>(fgMaster->fSubManagers->FindObject(name));
1792 AliEveEventManager* AliEveEventManager::GetMaster()
1794 // Get master event-manager.
1799 AliEveEventManager* AliEveEventManager::GetCurrent()
1801 // Get current event-manager.
1806 void AliEveEventManager::RegisterTransient(TEveElement* element)
1808 GetCurrent()->fTransients->AddElement(element);
1811 void AliEveEventManager::RegisterTransientList(TEveElement* element)
1813 GetCurrent()->fTransientLists->AddElement(element);
1816 //------------------------------------------------------------------------------
1817 // Autoloading of events
1818 //------------------------------------------------------------------------------
1820 void AliEveEventManager::SetAutoLoadTime(Float_t time)
1822 // Set the auto-load time in seconds
1824 fAutoLoadTime = time;
1827 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
1829 // Set the automatic event loading mode
1831 static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
1833 if (fAutoLoad == autoLoad)
1835 Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
1839 fAutoLoad = autoLoad;
1842 StartAutoLoadTimer();
1846 StopAutoLoadTimer();
1850 void AliEveEventManager::SetLoopMarked(Bool_t loopMarked)
1852 // Set the automatic event loading mode
1853 fLoopMarked = loopMarked;
1854 if (fLoopMarked){StartAutoLoadTimer();}
1855 else{StopAutoLoadTimer();}
1858 void AliEveEventManager::SetTrigSel(Int_t trig)
1860 static const TEveException kEH("AliEveEventManager::SetTrigSel ");
1864 Warning(kEH, "No Raw-reader exists. Ignoring the call.");
1869 ULong64_t trigMask = 0;
1870 if (trig >= 0) trigMask = (1ull << trig);
1871 Info(kEH,"Trigger selection: 0x%llx",trigMask);
1872 fRawReader->SelectEvents(-1,trigMask,NULL);
1876 void AliEveEventManager::StartAutoLoadTimer()
1878 // Start the auto-load timer.
1880 fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
1881 fAutoLoadTimer->Reset();
1882 fAutoLoadTimer->TurnOn();
1883 fAutoLoadTimerRunning = kTRUE;
1886 void AliEveEventManager::StopAutoLoadTimer()
1888 // Stop the auto-load timer.
1890 fAutoLoadTimerRunning = kFALSE;
1891 fAutoLoadTimer->TurnOff();
1894 void AliEveEventManager::AutoLoadNextEvent()
1896 // Called from auto-load timer, so it has to be public.
1897 // Do NOT call it directly.
1899 static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
1901 Info(kEH, "called!");
1903 if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
1905 Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
1909 StopAutoLoadTimer();
1911 if (fAutoLoad || fLoopMarked)
1912 StartAutoLoadTimer();
1915 //------------------------------------------------------------------------------
1916 // Post event-loading functions
1917 //------------------------------------------------------------------------------
1919 void AliEveEventManager::AfterNewEventLoaded()
1921 // Execute registered macros and commands.
1922 // At the end emit NewEventLoaded signal.
1924 // Virtual from TEveEventManager.
1926 static const TEveException kEH("AliEveEventManager::AfterNewEventLoaded ");
1928 Info(kEH, "------------------!!!------------");
1930 NewEventDataLoaded();
1931 if (fExecutor) fExecutor->ExecMacros();
1933 TEveEventManager::AfterNewEventLoaded();
1936 if (this == fgMaster && fSubManagers != 0)
1938 TIter next(fSubManagers);
1939 while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
1941 gEve->SetCurrentEvent(fgCurrent);
1944 fgCurrent->GotoEvent(fEventId);
1946 catch (TEveException& exc)
1948 // !!! Should somehow tag / disable / remove it?
1949 Error(kEH, "Getting event %d for sub-event-manager '%s' failed: '%s'.",
1950 fEventId, fgCurrent->GetName(), exc.Data());
1952 Info(kEH, "------------------!!! while() gEve->SetCurrentEvent() ------------");
1954 fgCurrent = fgMaster;
1955 Info(kEH, "------------------!!! while() gEve->SetCurrentEvent(MASTER) ------------");
1956 gEve->SetCurrentEvent(fgMaster);
1960 void AliEveEventManager::NewEventDataLoaded()
1962 // Emit NewEventDataLoaded signal.
1963 Emit("NewEventDataLoaded()");
1965 void AliEveEventManager::NewEventLoaded()
1967 // Emit NewEventLoaded signal.
1968 Emit("NewEventLoaded()");
1970 void AliEveEventManager::NoEventLoaded()
1972 // Emit NoEventLoaded signal.
1973 Emit("NoEventLoaded()");
1975 void AliEveEventManager::StorageManagerOk()
1977 // Emit StorageManagerOk signal.
1978 Emit("StorageManagerOk()");
1980 void AliEveEventManager::StorageManagerDown()
1982 // Emit StorageManagerOk signal.
1983 Emit("StorageManagerDown()");
1987 //------------------------------------------------------------------------------
1988 // Event info dumpers
1989 //------------------------------------------------------------------------------
1991 const AliEventInfo* AliEveEventManager::GetEventInfo()
1993 // Fill the event info object
1995 AliCentralTrigger *aCTP = NULL;
1997 fEventInfo.SetEventType(fRawReader->GetType());
1999 ULong64_t mask = fRawReader->GetClassMask();
2000 fEventInfo.SetTriggerMask(mask);
2001 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2002 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
2004 aCTP = new AliCentralTrigger();
2005 TString configstr("");
2006 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
2007 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
2011 aCTP->SetClassMask(mask);
2012 aCTP->SetClusterMask(clmask);
2015 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
2017 rlCTP->SetClassMask(mask);
2018 rlCTP->SetClusterMask(clmask);
2023 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
2025 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
2026 aCTP = fRunLoader->GetTrigger();
2027 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
2028 // get inputs from actp - just get
2029 AliESDHeader* esdheader = fESD->GetHeader();
2030 esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
2031 esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
2032 esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
2033 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
2036 AliWarning("No trigger can be loaded! The trigger information will not be used!");
2041 AliTriggerConfiguration *config = aCTP->GetConfiguration();
2043 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
2044 if (fRawReader) delete aCTP;
2048 TString declTriggerClasses;
2050 // Load trigger aliases and declare the trigger classes included in aliases
2051 AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
2053 THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
2055 lst->Sort(kSortDescending); // to avoid problems with substrings
2056 if (fRawReader) fRawReader->LoadTriggerAlias(lst);
2057 // Now declare all the triggers present in the aliases
2060 while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
2061 declTriggerClasses += " ";
2062 declTriggerClasses += nmd->GetName();
2066 AliError("Cannot cast the object with trigger aliases to THashList!");
2070 AliError("No OCDB entry for the trigger aliases!");
2073 // Load trigger classes for this run
2074 UChar_t clustmask = 0;
2076 ULong64_t trmask = fEventInfo.GetTriggerMask();
2077 const TObjArray& classesArray = config->GetClasses();
2078 Int_t nclasses = classesArray.GetEntriesFast();
2079 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
2080 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
2081 if (trclass && trclass->GetMask()>0) {
2082 Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
2083 if (fESD) fESD->SetTriggerClass(trclass->GetName(),trindex);
2084 if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
2085 if (trmask & (1ull << trindex)) {
2087 trclasses += trclass->GetName();
2089 clustmask |= trclass->GetCluster()->GetClusterMask();
2093 fEventInfo.SetTriggerClasses(trclasses);
2095 if (!aCTP->CheckTriggeredDetectors()) {
2096 if (fRawReader) delete aCTP;
2100 if (fRawReader) delete aCTP;
2102 // everything went ok, return pointer
2103 return (&fEventInfo);
2107 TString AliEveEventManager::GetEventInfoHorizontal() const
2109 // Dumps the event-header contents in vertical formatting.
2111 TString rawInfo, esdInfo;
2115 rawInfo = "No raw-data event info is available!\n";
2119 const UInt_t* attr = fRawReader->GetAttributes();
2120 TTimeStamp ts(fRawReader->GetTimestamp());
2121 rawInfo.Form("RAW event info: Run#: %d Event type: %d (%s) Period: %x Orbit: %x BC: %x\n"
2122 "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x Timestamp: %s\n",
2123 fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2124 fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2125 fRawReader->GetClassMask(),
2126 *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2127 attr[0],attr[1],attr[2], ts.AsString("s"));
2132 esdInfo = "No ESD event info is available!";
2136 TString acttrclasses = fESD->GetESDRun()->GetActiveTriggerClasses();
2137 TString firedtrclasses = fESD->GetFiredTriggerClasses();
2138 TTimeStamp ts(fESD->GetTimeStamp());
2139 esdInfo.Form("ESD event info: Run#: %d Event type: %d (%s) Period: %x Orbit: %x BC: %x\n"
2140 "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d Timestamp: %s, MagField: %.2e",
2141 fESD->GetRunNumber(),
2142 fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2143 fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2144 acttrclasses.Data(),
2145 fESD->GetTriggerMask(),firedtrclasses.Data(),
2146 fESD->GetEventNumberInFile(), ts.AsString("s"), fESD->GetMagneticField());
2149 return rawInfo + esdInfo;
2152 TString AliEveEventManager::GetEventInfoVertical() const
2154 // Dumps the event-header contents in vertical formatting.
2156 TString rawInfo, esdInfo;
2160 rawInfo = "No raw-data event info is available!\n";
2164 const UInt_t* attr = fRawReader->GetAttributes();
2165 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",
2166 fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
2167 fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
2168 fRawReader->GetClassMask(),
2169 *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
2170 attr[0],attr[1],attr[2],
2171 fRawReader->GetTimestamp());
2176 esdInfo = "No ESD event info is available!\n";
2180 TString acttrclasses = fESD->GetESDRun()->GetActiveTriggerClasses();
2181 TString firedtrclasses = fESD->GetFiredTriggerClasses();
2182 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",
2183 fESD->GetRunNumber(),
2184 acttrclasses.Data(),
2185 fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
2186 fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
2187 fESD->GetTriggerMask(),firedtrclasses.Data(),
2188 fESD->GetEventNumberInFile(),
2189 fESD->GetTimeStamp());
2192 return rawInfo + "\n" + esdInfo;
2196 //==============================================================================
2197 // Reading of GRP and MagneticField.
2198 // This is a reap-off from reconstruction ... should really be a common
2199 // code to do this somewhere in STEER.
2200 //==============================================================================
2202 Bool_t AliEveEventManager::InitGRP()
2204 //------------------------------------
2205 // Initialization of the GRP entry
2206 //------------------------------------
2208 static const TEveException kEH("AliEveEventManager::InitGRP ");
2210 AliGRPManager grpMgr;
2211 if (!grpMgr.ReadGRPEntry()) {
2214 fgGRPLoaded = kTRUE;
2215 if (!grpMgr.SetMagField()) {
2216 throw kEH + "Setting of field failed!";
2219 //*** Get the diamond profiles from OCDB
2220 // Eventually useful.
2223 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
2225 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
2227 ::Error(kEH, "No SPD diamond profile found in OCDB!");
2230 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
2232 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
2234 ::Error(kEH, "No diamond profile found in OCDB!");
2237 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
2239 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
2241 ::Error(kEH, "No TPC diamond profile found in OCDB!");
2248 //------------------------------------
2249 // Global variables management
2250 //------------------------------------
2252 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model)
2254 // Insert a new visualization-parameter database entry with the default
2255 return InsertGlobal(tag, model, fGlobalReplace, fGlobalUpdate);
2258 Bool_t AliEveEventManager::InsertGlobal(const TString& tag, TEveElement* model,
2259 Bool_t replace, Bool_t update)
2261 TPair* pair = (TPair*) fGlobal->FindObject(tag);
2266 model->IncDenyDestroy();
2267 model->SetRnrChildren(kFALSE);
2269 TEveElement* old_model = dynamic_cast<TEveElement*>(pair->Value());
2270 if(!old_model) AliFatal("old_model == 0, dynamic cast failed\n");
2271 while (old_model->HasChildren())
2273 TEveElement *el = old_model->FirstChild();
2274 el->SetVizModel(model);
2277 el->CopyVizParams(model);
2278 el->PropagateVizParamsToProjecteds();
2281 old_model->DecDenyDestroy();
2283 pair->SetValue(dynamic_cast<TObject*>(model));
2293 model->IncDenyDestroy();
2294 model->SetRnrChildren(kFALSE);
2295 fGlobal->Add(new TObjString(tag), dynamic_cast<TObject*>(model));
2300 TEveElement* AliEveEventManager::FindGlobal(const TString& tag)
2302 return dynamic_cast<TEveElement*>(fGlobal->GetValue(tag));
2304 Int_t AliEveEventManager::NewEventAvailable()
2306 if (fIsNewEventAvaliable)