From fe5afb026af176083e35668bffbe901b23cf24cf Mon Sep 17 00:00:00 2001
From: Joerg Stelzer <joerg.stelzer@cern.ch>
Date: Mon, 8 Feb 2021 19:52:37 +0100
Subject: [PATCH] Fix BSMonitoring (ATR-22194) and migrate to new L1Menu
---
...MonitoringJobOptions_forRecExCommission.py | 437 +++---
.../TrigT1CTMonitoring/src/BSMonitoring.cxx | 1244 ++++++++---------
.../TrigT1CTMonitoring/src/BSMonitoring.h | 146 +-
.../TrigT1CTP/python/TrigT1CTPConfig.py | 1 +
.../TrigT1/TrigT1CTP/src/CTPSimulation.cxx | 23 +-
.../python/Lvl1SimulationConfig.py | 1 +
6 files changed, 922 insertions(+), 930 deletions(-)
diff --git a/Trigger/TrigT1/TrigT1CTMonitoring/share/TrigT1CTMonitoringJobOptions_forRecExCommission.py b/Trigger/TrigT1/TrigT1CTMonitoring/share/TrigT1CTMonitoringJobOptions_forRecExCommission.py
index cebacd448a39..54429f44839f 100644
--- a/Trigger/TrigT1/TrigT1CTMonitoring/share/TrigT1CTMonitoringJobOptions_forRecExCommission.py
+++ b/Trigger/TrigT1/TrigT1CTMonitoring/share/TrigT1CTMonitoringJobOptions_forRecExCommission.py
@@ -15,6 +15,9 @@
## get a handle to the ServiceManager
#-----------COMMON CODE---------------------
+from AthenaCommon.Logging import logging
+ctpmonlog = logging.getLogger("CTPMonitoringSetup")
+
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaCommon.Constants import *
@@ -23,10 +26,10 @@ UsedFillStateCoolFolderName="/LHC/DCS/FILLSTATE"
if LHCFillStateAvailable:
UsedFillStateCoolFolderName="Unavailable"
+# add CTP and MUCTPI data to ByteStreamAddressProviderSvc
if not hasattr( svcMgr, "ByteStreamAddressProviderSvc" ):
from ByteStreamCnvSvcBase.ByteStreamCnvSvcBaseConf import ByteStreamAddressProviderSvc
svcMgr += ByteStreamAddressProviderSvc()
-
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"MuCTPI_RDO/MUCTPI_RDO",
"CTP_RDO/CTP_RDO",
@@ -46,234 +49,240 @@ from TrigT1CTMonitoring.TrigT1CTMonitoringConfig import *
from AthenaCommon.AppMgr import ToolSvc as toolSvc
from TrigT1CTMonitoring.TrigT1CTMonitoringConf import TrigT1CTMonitoring__BSMonitoring as BSMon
-#-----------ONLINE CODE---------------------
-if athenaCommonFlags.isOnline() and jp.ConcurrencyFlags.NumThreads() == 0:
- #from TrigServices.TrigServicesConf import TrigMonTHistSvc
- #THistSvc = TrigMonTHistSvc("THistSvc")
- #svcMgr += THistSvc
- doHist=True
- InputDir = "."
- OutputDir="."
- FilePreFix = [ "MonTest"]
- RootHistFileName = 'HistFile.root'
-
- ## add an AthenaMonManager algorithm to the list of algorithms to be ran
- if not hasattr(topSequence,"PrimaryManager"):
- from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager
- topSequence += AthenaMonManager( "PrimaryManager" )
- ## AthenaMonManager is the Algorithm that manages many classes inheriting
- ## from ManagedMonitorToolBase
- CTmonMan = topSequence.PrimaryManager
-
- theApp.Dlls += [ "TrigT1CTMonitoring" ]
-
- CTmonMan.AthenaMonTools += [ "TrigT1CTMonitoring__BSMonitoring/BSMon" ]
-
- ## FILEKEY must match that given to THistSvc
- CTmonMan.FileKey = "GLOBAL"
+if jp.ConcurrencyFlags.NumThreads() == 0: #no monitoring for multithreaded code yet
- DetDescrVersion="ATLAS-DC3-05" # 11.0.42 files
- AllAlgs = False # if false, all algorithms are switched off by defaults
+ #-----------ONLINE CODE---------------------
+ if athenaCommonFlags.isOnline():
+ ctpmonlog.info("Setting up CTP/MUCTPI BS monitoring for online")
+ #from TrigServices.TrigServicesConf import TrigMonTHistSvc
+ #THistSvc = TrigMonTHistSvc("THistSvc")
+ #svcMgr += THistSvc
+ doHist=True
+ InputDir = "."
+ OutputDir="."
+ FilePreFix = [ "MonTest"]
+ RootHistFileName = 'HistFile.root'
+
+ ## add an AthenaMonManager algorithm to the list of algorithms to be ran
+ if not hasattr(topSequence,"PrimaryManager"):
+ from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager
+ topSequence += AthenaMonManager( "PrimaryManager" )
+ ## AthenaMonManager is the Algorithm that manages many classes inheriting
+ ## from ManagedMonitorToolBase
+ CTmonMan = topSequence.PrimaryManager
+ theApp.Dlls += [ "TrigT1CTMonitoring" ]
+
+ CTmonMan.AthenaMonTools += [ "TrigT1CTMonitoring__BSMonitoring/BSMon" ]
- from AthenaCommon.GlobalFlags import GlobalFlags
- GlobalFlags.DataSource.set_data()
- GlobalFlags.InputFormat.set_bytestream()
- GlobalFlags.DetGeo.set_atlas()
-
- from AthenaCommon.DetFlags import DetFlags
-
- DetFlags.detdescr.all_setOn()
- DetFlags.geometry.all_setOn()
- DetFlags.ID_setOff()
- DetFlags.Calo_setOff()
- DetFlags.Truth_setOff()
- #switch on/off detectors
-
- DetFlags.Muon_setOn()
- #DetFlags.Muon_setOff()
-
- DetFlags.LVL1_setOn()
- DetFlags.pileup.all_setOff()
- DetFlags.simulate.all_setOff()
- DetFlags.digitize.all_setOff()
- DetFlags.makeRIO.all_setOff()
- DetFlags.writeBS.all_setOff()
- DetFlags.readRDOBS.all_setOff()
- DetFlags.readRIOBS.all_setOff()
- DetFlags.readRIOPool.all_setOff()
- DetFlags.writeRIOPool.all_setOff()
- DetFlags.writeRDOPool.all_setOff()
- DetFlags.readRDOBS.LVL1_setOn()
- DetFlags.readRIOBS.LVL1_setOn()
- DetFlags.Print()
- GlobalFlags.Print()
-
- #--------------------------------------------------------------
- # GeoModel stuff:
- #--------------------------------------------------------------
- include( "AtlasGeoModel/SetGeometryVersion.py" )
- include( "AtlasGeoModel/GeoModelInit.py" )
-
- #--------------------------------------------------------------
- #
- #--------------------------------------------------------------
- include( "AmdcAth/AmdcAth_jobOptions.py" )
- include( "AtlasGeoModel/MuonGeoModel.py" )
-
- # Cabling and geometry of muon detectors
- from RPCgeometry.RPCgeometryConfig import RPCgeometryConfig
- from RPCcabling.RPCcablingConfig import RPCcablingConfig
- RPCcablingSvc = RPCcablingConfig()
- RPCcablingSvc.ConfFileName = "LVL1conf.data"
- RPCcablingSvc.CorrFileName = "LVL1corr.data"
-
- from MDTcabling.MDTcablingConfig import MDTcablingConfig
- MDTcablingSvc = MDTcablingConfig()
- MDTcablingSvc.RODfile = "RODmap.data"
- from TGCcabling.TGCcablingConfig import TGCcablingConfig
-
- # Needed to decode the RoI information
- from TrigT1RPCRecRoiSvc.TrigT1RPCRecRoiConfig import RPCRecRoiConfig
- from TrigT1TGCRecRoiSvc.TrigT1TGCRecRoiConfig import TGCRecRoiConfig
-
- CTmonMan.Environment = "online"
- CTmonMan.ManualDataTypeSetup = False
- CTmonMan.DataType = "cosmics"
- CTmonMan.ManualRunLBSetup = False
- CTmonMan.Run = 1
- CTmonMan.LumiBlock = 1
-
- #---------------------------------------------------------------
- # LVL1 configuration
- #---------------------------------------------------------------
- log.info("will setup LVL1ConfigSvc and add instance to ServiceMgr")
- from TrigConfigSvc.TrigConfigSvcConfig import LVL1ConfigSvc
- LVL1ConfigSvc = LVL1ConfigSvc('LVL1ConfigSvc')
- LVL1ConfigSvc.ConfigSource = "XML"
- LVL1ConfigSvc.XMLFile = "L1MenuM5.xml"
- LVL1ConfigSvc.CreateLegacyObjects = True
- LVL1ConfigSvc.DumpTTVmap = False
- #LVL1ConfigSvc.OutputLevel = VERBOSE
- svcMgr += LVL1ConfigSvc
- theApp.CreateSvc += [ "TrigConf::LVL1ConfigSvc/LVL1ConfigSvc" ]
-
- # svcMgr.ToolSvc += BSMon( OutputLevel=INFO )
- svcMgr.ToolSvc += BSMon( ProcessMuctpiData=True )
- svcMgr.ToolSvc += BSMon( ProcessMuctpiDataRIO=True )
- svcMgr.ToolSvc += BSMon( ProcessCTPData=True )
- svcMgr.ToolSvc += BSMon( ProcessRoIBResult=True )
- svcMgr.ToolSvc += BSMon( InclusiveTriggerThresholds=True )
- svcMgr.ToolSvc += BSMon( FillStateCoolFolderName=UsedFillStateCoolFolderName)
- # RecMuCTPIByteStreamTool.OutputLevel = INFO #DEBUG
-
- printfunc (topSequence)
- printfunc (svcMgr)
+ ## FILEKEY must match that given to THistSvc
+ CTmonMan.FileKey = "GLOBAL"
+ DetDescrVersion="ATLAS-DC3-05" # 11.0.42 files
+ AllAlgs = False # if false, all algorithms are switched off by defaults
-
-#-----------OFFLINE CODE---------------------
-if not athenaCommonFlags.isOnline() and jp.ConcurrencyFlags.NumThreads() == 0:
- from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
- cfg = TriggerConfigGetter()
+ from AthenaCommon.GlobalFlags import GlobalFlags
+ GlobalFlags.DataSource.set_data()
+ GlobalFlags.InputFormat.set_bytestream()
+ GlobalFlags.DetGeo.set_atlas()
+
+ from AthenaCommon.DetFlags import DetFlags
+
+ DetFlags.detdescr.all_setOn()
+ DetFlags.geometry.all_setOn()
+ DetFlags.ID_setOff()
+ DetFlags.Calo_setOff()
+ DetFlags.Truth_setOff()
+ #switch on/off detectors
- ## add pre algorithms for rerunning CTP simulation
- from PyUtils.MetaReaderPeeker import metadata
- if 'IS_SIMULATION' not in metadata['eventTypes']:
- #svcMgr.DSConfigSvc.readLVL1Thr=True
- #svcMgr.DSConfigSvc.readLVL1BG=True
+ DetFlags.Muon_setOn()
+ #DetFlags.Muon_setOff()
+
+ DetFlags.LVL1_setOn()
+ DetFlags.pileup.all_setOff()
+ DetFlags.simulate.all_setOff()
+ DetFlags.digitize.all_setOff()
+ DetFlags.makeRIO.all_setOff()
+ DetFlags.writeBS.all_setOff()
+ DetFlags.readRDOBS.all_setOff()
+ DetFlags.readRIOBS.all_setOff()
+ DetFlags.readRIOPool.all_setOff()
+ DetFlags.writeRIOPool.all_setOff()
+ DetFlags.writeRDOPool.all_setOff()
+ DetFlags.readRDOBS.LVL1_setOn()
+ DetFlags.readRIOBS.LVL1_setOn()
+ DetFlags.Print()
+ GlobalFlags.Print()
+
+ #--------------------------------------------------------------
+ # GeoModel stuff:
+ #--------------------------------------------------------------
+ include( "AtlasGeoModel/SetGeometryVersion.py" )
+ include( "AtlasGeoModel/GeoModelInit.py" )
+
+ #--------------------------------------------------------------
+ #
+ #--------------------------------------------------------------
+ include( "AmdcAth/AmdcAth_jobOptions.py" )
+ include( "AtlasGeoModel/MuonGeoModel.py" )
+
+ # Cabling and geometry of muon detectors
+ from RPCgeometry.RPCgeometryConfig import RPCgeometryConfig
+ from RPCcabling.RPCcablingConfig import RPCcablingConfig
+ RPCcablingSvc = RPCcablingConfig()
+ RPCcablingSvc.ConfFileName = "LVL1conf.data"
+ RPCcablingSvc.CorrFileName = "LVL1corr.data"
+
+ from MDTcabling.MDTcablingConfig import MDTcablingConfig
+ MDTcablingSvc = MDTcablingConfig()
+ MDTcablingSvc.RODfile = "RODmap.data"
+ from TGCcabling.TGCcablingConfig import TGCcablingConfig
+
+ # Needed to decode the RoI information
+ from TrigT1RPCRecRoiSvc.TrigT1RPCRecRoiConfig import RPCRecRoiConfig
+ from TrigT1TGCRecRoiSvc.TrigT1TGCRecRoiConfig import TGCRecRoiConfig
+
+ CTmonMan.Environment = "online"
+ CTmonMan.ManualDataTypeSetup = False
+ CTmonMan.DataType = "cosmics"
+ CTmonMan.ManualRunLBSetup = False
+ CTmonMan.Run = 1
+ CTmonMan.LumiBlock = 1
+
+ #---------------------------------------------------------------
+ # LVL1 configuration
+ #---------------------------------------------------------------
+ ctpmonlog.info("will setup LVL1ConfigSvc and add instance to ServiceMgr")
+ from TrigConfigSvc.TrigConfigSvcConfig import LVL1ConfigSvc
+ LVL1ConfigSvc = LVL1ConfigSvc('LVL1ConfigSvc')
+ LVL1ConfigSvc.ConfigSource = "XML"
+ LVL1ConfigSvc.XMLFile = "L1MenuM5.xml"
+ LVL1ConfigSvc.CreateLegacyObjects = True
+ LVL1ConfigSvc.DumpTTVmap = False
+ svcMgr += LVL1ConfigSvc
+ theApp.CreateSvc += [ "TrigConf::LVL1ConfigSvc/LVL1ConfigSvc" ]
from AthenaConfiguration.AllConfigFlags import ConfigFlags
- if ConfigFlags.Trigger.enableL1Phase1:
- from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1_on_Data
- topSequence += L1MuctpiPhase1_on_Data()
- else:
- from TrigT1Muctpi.TrigT1MuctpiConfig import L1Muctpi_on_Data
- topSequence += L1Muctpi_on_Data()
-
- from TrigT1CTMonitoring.TrigT1CTMonitoringConf import TrigT1CTMonitoring__DeriveSimulationInputs as DeriveSimulationInputs
- topSequence += DeriveSimulationInputs(do_MuCTPI_input=True,
- do_L1Calo_sim=False)
-
- from TrigT1CTP.TrigT1CTPConfig import CTPSimulationOnData
- topSequence += CTPSimulationOnData("CTPSimulation")
-
- # configure simulation histogram output directory
- from AthenaMonitoring.DQMonFlags import DQMonFlags
- histbase = "/" + DQMonFlags.monManFileKey() + "/"
- if DQMonFlags.monManRun():
- from RecExConfig.AutoConfiguration import GetRunNumber
- histbase += "run_%i/L1" % GetRunNumber()
- else:
- histbase += "L1Simulation"
- try:
- topSequence.CTPSimulation.HistPath = histbase
- except AttributeError as ex:
- printfunc (ex," ignore for now")
- import traceback
- traceback.print_exc()
-
- ## add an AthenaMonManager algorithm to the list of algorithms to be run
- monMan = AthenaMonManager( name="CTMonManager",
- FileKey = DQMonFlags.monManFileKey(),
- Environment = DQMonFlags.monManEnvironment(),
- ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(),
- DataType = DQMonFlags.monManDataType() )
- topSequence += monMan
-
- theApp.Dlls += [ "TrigT1CTMonitoring" ]
+ svcMgr.ToolSvc += BSMon( ProcessMuctpiData=True,
+ ProcessMuctpiDataRIO=True,
+ ProcessCTPData=True,
+ ProcessRoIBResult=True,
+ InclusiveTriggerThresholds=True,
+ FillStateCoolFolderName=UsedFillStateCoolFolderName,
+ UseNewConfig = ConfigFlags.Trigger.readLVL1FromJSON )
+
+ printfunc (topSequence)
+ printfunc (svcMgr)
+
- from PyUtils.MetaReaderPeeker import metadata
+ #-----------OFFLINE CODE---------------------
+ else:
+ from PyUtils.MetaReaderPeeker import metadata
+ isMC = 'IS_SIMULATION' in metadata['eventTypes']
+ ctpmonlog.info("Setting up CTP/MUCTPI BS monitoring for offline (MC=%s)", isMC)
+
+ from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
+ cfg = TriggerConfigGetter()
- # check if global muons are on
- if not rec.doMuon:
+ ## add pre algorithms for rerunning CTP simulation
if 'IS_SIMULATION' not in metadata['eventTypes']:
- CTBSMonTool = BSMon( ProcessCTPData = True,
- ProcessRoIBResult = False,
- InclusiveTriggerThresholds = False,
- ProcessMuctpiData = False,
- ProcessMuctpiDataRIO = False,
- CompareRerun = True,
- FillStateCoolFolderName=UsedFillStateCoolFolderName)
+ #svcMgr.DSConfigSvc.readLVL1Thr=True
+ #svcMgr.DSConfigSvc.readLVL1BG=True
+
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+ if ConfigFlags.Trigger.enableL1Phase1:
+ from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1_on_Data
+ topSequence += L1MuctpiPhase1_on_Data()
+ else:
+ from TrigT1Muctpi.TrigT1MuctpiConfig import L1Muctpi_on_Data
+ topSequence += L1Muctpi_on_Data()
+
+ from TrigT1CTMonitoring.TrigT1CTMonitoringConf import TrigT1CTMonitoring__DeriveSimulationInputs as DeriveSimulationInputs
+ topSequence += DeriveSimulationInputs(do_MuCTPI_input=True,
+ do_L1Calo_sim=False)
+
+ from TrigT1CTP.TrigT1CTPConfig import CTPSimulationOnData
+ topSequence += CTPSimulationOnData("CTPSimulation")
+
+ # configure simulation histogram output directory
+ from AthenaMonitoring.DQMonFlags import DQMonFlags
+ histbase = "/" + DQMonFlags.monManFileKey() + "/"
+ if DQMonFlags.monManRun():
+ from RecExConfig.AutoConfiguration import GetRunNumber
+ histbase += "run_%i/L1" % GetRunNumber()
+ else:
+ histbase += "L1Simulation"
+ try:
+ topSequence.CTPSimulation.HistPath = histbase
+ except AttributeError as ex:
+ printfunc (ex," ignore for now")
+ import traceback
+ traceback.print_exc()
+
+ ## add an AthenaMonManager algorithm to the list of algorithms to be run
+ monMan = AthenaMonManager( name="CTMonManager",
+ FileKey = DQMonFlags.monManFileKey(),
+ Environment = DQMonFlags.monManEnvironment(),
+ ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(),
+ DataType = DQMonFlags.monManDataType() )
+ topSequence += monMan
+
+ theApp.Dlls += [ "TrigT1CTMonitoring" ]
+
+ # check if global muons are on
+ if not rec.doMuon:
+ if 'IS_SIMULATION' not in metadata['eventTypes']:
+ CTBSMonTool = BSMon(ProcessRoIBResult = False,
+ InclusiveTriggerThresholds = False,
+ ProcessMuctpiData = False,
+ ProcessMuctpiDataRIO = False,
+ CompareRerun = True,
+ FillStateCoolFolderName=UsedFillStateCoolFolderName)
+ else:
+ CTBSMonTool = BSMon(ProcessRoIBResult = False,
+ InclusiveTriggerThresholds = False,
+ ProcessMuctpiData = False,
+ ProcessMuctpiDataRIO = False,
+ RunOnESD = True,
+ CompareRerun = False,
+ FillStateCoolFolderName=UsedFillStateCoolFolderName)
else:
- CTBSMonTool = BSMon( ProcessCTPData = True,
- ProcessRoIBResult = False,
- InclusiveTriggerThresholds = False,
- ProcessMuctpiData = False,
- ProcessMuctpiDataRIO = False,
- RunOnESD = True,
- CompareRerun = False,
- FillStateCoolFolderName=UsedFillStateCoolFolderName)
- else:
+ if 'IS_SIMULATION' not in metadata['eventTypes']:
+ CTBSMonTool = BSMon(ProcessRoIBResult = True,
+ ProcessMuctpiData = True,
+ ProcessMuctpiDataRIO = True,
+ CompareRerun = True)
+ else:
+ CTBSMonTool = BSMon(ProcessRoIBResult = True,
+ ProcessMuctpiData = True,
+ ProcessMuctpiDataRIO = False,
+ RunOnESD = True,
+ CompareRerun = False,
+ FillStateCoolFolderName=UsedFillStateCoolFolderName)
+ # Needed to decode the RoI information
+ from TrigT1RPCRecRoiSvc.TrigT1RPCRecRoiConfig import RPCRecRoiConfig
+ from TrigT1TGCRecRoiSvc.TrigT1TGCRecRoiConfig import TGCRecRoiConfig
+
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+ CTBSMonTool.UseNewConfig = ConfigFlags.Trigger.readLVL1FromJSON
+
+
+ processByteStream = True
+
+
if 'IS_SIMULATION' not in metadata['eventTypes']:
- CTBSMonTool = BSMon( ProcessCTPData = True,
- ProcessRoIBResult = True,
- ProcessMuctpiData = True,
- ProcessMuctpiDataRIO = True,
- CompareRerun = True)
- else:
- CTBSMonTool = BSMon( ProcessCTPData = True,
- ProcessRoIBResult = True,
- ProcessMuctpiData = True,
- ProcessMuctpiDataRIO = False,
- RunOnESD = True,
- CompareRerun = False,
- FillStateCoolFolderName=UsedFillStateCoolFolderName)
- # Needed to decode the RoI information
- from TrigT1RPCRecRoiSvc.TrigT1RPCRecRoiConfig import RPCRecRoiConfig
- from TrigT1TGCRecRoiSvc.TrigT1TGCRecRoiConfig import TGCRecRoiConfig
+ from IOVDbSvc.CondDB import conddb
+ conddb.addFolder('TRIGGER', '/TRIGGER/LUMI/LBLB')
+ if LHCFillStateAvailable:
+ conddb.addFolder('DCS_OFL', "/LHC/DCS/FILLSTATE")
+ conddb.addFolder('TDAQ', '/TDAQ/RunCtrl/DataTakingMode', className='AthenaAttributeList')
+ conddb.addFolder('TRIGGER', "/TRIGGER/LVL1/RFPhase")
+ conddb.addFolder('TRIGGER', '/TRIGGER/LVL1/CTPCoreInputMapping')
+
+ monMan.AthenaMonTools += [ CTBSMonTool ]
- processByteStream = True
- if 'IS_SIMULATION' not in metadata['eventTypes']:
- from IOVDbSvc.CondDB import conddb
- conddb.addFolder('TRIGGER', '/TRIGGER/LUMI/LBLB')
- if LHCFillStateAvailable:
- conddb.addFolder('DCS_OFL', "/LHC/DCS/FILLSTATE")
- conddb.addFolder('TDAQ', '/TDAQ/RunCtrl/DataTakingMode', className='AthenaAttributeList')
- conddb.addFolder('TRIGGER', "/TRIGGER/LVL1/RFPhase")
- conddb.addFolder('TRIGGER', '/TRIGGER/LVL1/CTPCoreInputMapping')
- monMan.AthenaMonTools += [ CTBSMonTool ]
+del ctpmonlog
diff --git a/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.cxx b/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.cxx
index 2cc5dc070c64..85b337cfa4a2 100644
--- a/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.cxx
+++ b/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.cxx
@@ -17,11 +17,10 @@
#include "TrigT1Result/RoIBResult.h"
// TrigConf includes
-//#include "TrigConfigSvc/ILVL1ConfigSvc.h"
-#include "TrigConfInterfaces/ILVL1ConfigSvc.h"
#include "TrigConfL1Data/CTPConfig.h"
#include "TrigConfL1Data/Menu.h"
#include "TrigConfStorage/TrigConfCoolFolderSpec.h"
+#include "TrigConfData/L1Menu.h"
// COOL includes
#include "CoraCool/CoraCoolDatabaseSvcFactory.h"
@@ -60,99 +59,35 @@
using namespace std;
-TrigT1CTMonitoring::BSMonitoring::
-BSMonitoring(const std::string & type, const std::string & name, const IInterface * parent)
- :ManagedMonitorToolBase(type, name, parent),
- m_configSvc("TrigConf::TrigConfigSvc/TrigConfigSvc", name),
- m_rpcRoiSvc( "LVL1RPC::RPCRecRoiSvc", name ),
- m_tgcRoiSvc( "LVL1TGC::TGCRecRoiSvc", name ),
- m_histogramsBooked(false),
- m_retrievedLumiBlockTimes(false),
- m_currentLumiBlock(0),
- m_runNumber(0),
- m_eventNumber(0),
- m_inclusiveTriggerThresholds(true),
- m_processMuctpi(true),
- m_processMuctpiRIO(true),
- m_processCTP(true),
- m_processRoIB(true),
- m_compareRerun(false),
- m_runOnESD(false),
- m_retrieveCoolData(true),
- m_eventCount(0),
- m_firstEventTime(0),
- m_firstEventBcid(0),
- m_firstEventTC(0),
- m_filledEventCount(0),
- m_maxLumiBlock(0),
- m_lumiBlockOfPreviousEvent(0),
- m_defaultBcIntervalInNs(24.9507401),
- m_bcsPerTurn(3564),
- m_nLB(0),
- m_lastminbc(0),
- m_lastmaxbc(0) {
-
- declareProperty( "DirectoryName", m_baseDirName = "CT/",
- "Directory in output root file where the histograms will be stored." );
- declareProperty( "InclusiveTriggerThresholds", m_inclusiveTriggerThresholds = 1,
- "Flag to activate the inclusive counting of PT thresholds in trigger patterns" );
- declareProperty( "ProcessMuctpiData", m_processMuctpi = 1,
- "Flag to activate the processing of Muctpi data" );
- declareProperty( "ProcessMuctpiDataRIO", m_processMuctpiRIO = 1,
- "Flag to activate the processing of the Muctpi RIO" );
- declareProperty( "ProcessCTPData", m_processCTP = 1,
- "Flag to activate the processing of CTP data" );
- declareProperty( "ProcessRoIBResult", m_processRoIB = 1,
- "Flag to activate the processing of RoIBResult data" );
- declareProperty( "CompareRerun", m_compareRerun = 0,
- "Flag to activate the processing of RoIBResult data" );
- declareProperty( "RunOnESD", m_runOnESD = 0,
- "Flag to run only on the ESD" );
- declareProperty( "RetrieveCoolData", m_retrieveCoolData = 1,
- "Flag to control whether or not to perform checks based on COOL data" );
- declareProperty( "TrigConfigSvc", m_configSvc,
- "Trigger Config Service" );
- declareProperty( "RPCRecRoiSvc", m_rpcRoiSvc );
- declareProperty( "TGCRecRoiSvc", m_tgcRoiSvc );
- declareProperty( "DefaultBcIntervalInNs", m_defaultBcIntervalInNs = 24.9507401,
- "Default bunch-crossing duration to use if not accessible in COOL" );
- declareProperty( "BCsPerTurn", m_bcsPerTurn = 3564,
- "Number of bunch crossings per turn" );
- declareProperty( "LumiBlockTimeCoolFolderName", m_lbTimeCoolFolderName = "/TRIGGER/LUMI/LBLB",
- "COOL folder in COOLONL_TRIGGER holding info about start and stop times for luminosity blocks" );
- declareProperty( "RFPhaseCoolFolderName", m_rfPhaseCoolFolderName = "/TRIGGER/LVL1/RFPhase",
- "COOL folder in COOLONL_TRIGGER holding LHC timing signal info and ATLAS related settings" );
- declareProperty( "FillStateCoolFolderName", m_fillStateCoolFolderName = "/LHC/DCS/FILLSTATE",
- "COOL folder in COOLOFL_DCS holding the LHC fill state info" );
- declareProperty( "DataTakingModeCoolFolderName", m_dataTakingModeCoolFolderName = "/TDAQ/RunCtrl/DataTakingMode",
- "COOL folder in COOLONL_TDAQ holding the ATLAS data taking mode info" );
-}
-
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-initialize() {
+TrigT1CTMonitoring::BSMonitoring::BSMonitoring(const std::string & type, const std::string & name, const IInterface * parent)
+ : ManagedMonitorToolBase(type, name, parent)
+{}
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::initialize()
+{
// make sure to call initialize of the base class!
- CHECK( ManagedMonitorToolBase::initialize() );
+ ATH_CHECK( ManagedMonitorToolBase::initialize() );
- ATH_MSG(DEBUG) << "begin initialize()" << endmsg;
// connect to the config service
- CHECK( m_configSvc.retrieve() );
+ ATH_CHECK( m_configSvc.retrieve() );
// connect to RPC and TGC RoI services
if ( m_processMuctpi ) {
- CHECK( m_rpcRoiSvc.retrieve() );
- CHECK( m_tgcRoiSvc.retrieve() );
+ ATH_CHECK( m_rpcRoiSvc.retrieve() );
+ ATH_CHECK( m_tgcRoiSvc.retrieve() );
}
return StatusCode::SUCCESS;
}
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-bookHistograms() {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::bookHistograms()
+{
try {
- ATH_MSG(DEBUG) << "begin bookHistograms()" << endmsg;
- ATH_MSG(DEBUG) << "Clearing HistMap and resetting event counters for new run" << endmsg;
+ ATH_MSG_DEBUG( "bookHistograms()");
+ ATH_MSG_DEBUG( "Clearing HistMap and resetting event counters for new run");
m_histNames.clear();
m_eventCount = 0;
@@ -174,7 +109,7 @@ bookHistograms() {
m_histogramsBooked = true;
if (m_retrieveCoolData) {
- ATH_MSG(DEBUG) << "Will now try to access LB times in folder " << m_lbTimeCoolFolderName << endmsg;
+ ATH_MSG_DEBUG( "Will now try to access LB times in folder " << m_lbTimeCoolFolderName);
m_lumiBlocks.clear();
m_lbStartTimes.clear();
m_lbEndTimes.clear();
@@ -184,22 +119,20 @@ bookHistograms() {
const DataHandle<CTP_RIO> theCTP_RIO = 0;
if (!(evtStore()->retrieve(theCTP_RIO, "CTP_RIO").isFailure())) {
getCoolData(theCTP_RIO->getRunNumber());
- ATH_MSG(DEBUG) << m_lumiBlocks.size() << " lumi blocks found" << endmsg;
+ ATH_MSG_DEBUG( m_lumiBlocks.size() << " lumi blocks found");
for ( std::vector<uint32_t>::const_iterator lbIt = m_lumiBlocks.begin();
lbIt != m_lumiBlocks.end(); ++lbIt ) {
- ATH_MSG(DEBUG) << "LB " << *lbIt << ": start time = " << m_lbStartTimes[*lbIt]
- << ", end time = " << m_lbEndTimes[*lbIt] << endmsg;
+ ATH_MSG_DEBUG( "LB " << *lbIt << ": start time = " << m_lbStartTimes[*lbIt]
+ << ", end time = " << m_lbEndTimes[*lbIt]);
}
if (m_lbStartTimes.size() == 0) {
- ATH_MSG(WARNING) << "Lumi block timestamps not found!" << endmsg;
+ ATH_MSG_WARNING( "Lumi block timestamps not found!");
}
else {
m_retrievedLumiBlockTimes = true;
}
}
}
- ATH_MSG(DEBUG) << "end bookHistograms()" << endmsg;
- return StatusCode::SUCCESS;
}
catch(const std::exception & e) {
std::cerr << "Caught standard C++ exception: " << e.what() << " from bookHistograms()" << std::endl;
@@ -208,19 +141,18 @@ bookHistograms() {
return StatusCode::SUCCESS;
}
-
-
StatusCode
-TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
+TrigT1CTMonitoring::BSMonitoring::fillHistograms()
+{
//evtStore()->dump();
try {
if (!m_histogramsBooked) {
- ATH_MSG(ERROR) << "fillHistograms() called before bookHistograms(*,*,1)!" << endmsg;
- ATH_MSG(ERROR) << "calling bookHistograms(1,1,1) manually..." << endmsg;
+ ATH_MSG_ERROR( "fillHistograms() called before bookHistograms(*,*,1)!");
+ ATH_MSG_ERROR( "calling bookHistograms(1,1,1) manually...");
CHECK( bookHistograms() );
}
- ATH_MSG(DEBUG) << "begin fillHistograms()" << endmsg;
+ ATH_MSG_DEBUG( "begin fillHistograms()");
// Now see what exists in StoreGate...
const DataHandle<MuCTPI_RDO> theMuCTPI_RDO = 0;
@@ -247,7 +179,7 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
TH1F_LW* incompleteFragmentType = getTH1("incompleteFragmentType");
if ( !errorSummary || !errorSummaryPerLumiBlock || !errorPerLumiBlock || !incompleteFragmentType ) {
- ATH_MSG(FATAL) << "Problems finding error histograms!" << endmsg;
+ ATH_MSG_FATAL("Problems finding error histograms!");
return StatusCode::FAILURE;
}
@@ -256,25 +188,25 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
if (m_processMuctpi) {
sc = evtStore()->retrieve(theMuCTPI_RDO, "MUCTPI_RDO");
if (sc.isFailure()) {
- ATH_MSG(WARNING) << "Could not find \"MUCTPI_RDO\" in StoreGate" << endmsg;
+ ATH_MSG_WARNING( "Could not find \"MUCTPI_RDO\" in StoreGate");
validMuCTPI_RDO = false;
++numberOfInvalidFragments;
}
// now try to get RPC and TGC SL output for comparisons
sc = evtStore()->retrieve(theRPCContainer, "RPC_SECTORLOGIC");
if (sc.isFailure()) {
- ATH_MSG(WARNING) << "Could not find RPC container in StoreGate" << endmsg;
+ ATH_MSG_WARNING( "Could not find RPC container in StoreGate");
validRPCContainer = false;
}
sc = evtStore()->retrieve(theTGCContainer, "TrigT1CoinDataCollection");
if (sc.isFailure()) {
- ATH_MSG(WARNING) << "Could not find TGC container in StoreGate" << endmsg;
+ ATH_MSG_WARNING( "Could not find TGC container in StoreGate");
validTGCContainer = false;
}
if (m_processMuctpiRIO && !m_runOnESD) {
sc = evtStore()->retrieve(theMuCTPI_RIO, "MUCTPI_RIO");
if (sc.isFailure()) {
- ATH_MSG(WARNING) << "Could not find \"MUCTPI_RIO\" in StoreGate" << endmsg;
+ ATH_MSG_WARNING( "Could not find \"MUCTPI_RIO\" in StoreGate");
validMuCTPI_RIO = false;
++numberOfInvalidFragments;
}
@@ -284,14 +216,14 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
if (m_processCTP) {
sc = evtStore()->retrieve(theCTP_RDO, "CTP_RDO");
if (sc.isFailure()) {
- ATH_MSG(WARNING) << "Could not find \"CTP_RDO\" in StoreGate" << endmsg;
+ ATH_MSG_WARNING( "Could not find \"CTP_RDO\" in StoreGate");
validCTP_RDO = false;
++numberOfInvalidFragments;
}
if (!m_runOnESD) {
sc = evtStore()->retrieve(theCTP_RIO, "CTP_RIO");
if (sc.isFailure()) {
- ATH_MSG(WARNING) << "Could not find \"CTP_RIO\" in StoreGate" << endmsg;
+ ATH_MSG_WARNING( "Could not find \"CTP_RIO\" in StoreGate");
validCTP_RIO = false;
++numberOfInvalidFragments;
}
@@ -300,7 +232,7 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
if (m_processRoIB && m_processMuctpiRIO) {
sc = evtStore()->retrieve(roIBResult, "RoIBResult");
if (sc.isFailure()) {
- ATH_MSG(WARNING) << "Could not find \"RoIBResult\" in StoreGate" << endmsg;
+ ATH_MSG_WARNING( "Could not find \"RoIBResult\" in StoreGate");
validRoIBResult = false;
++numberOfInvalidFragments;
}
@@ -313,42 +245,38 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
m_eventNumber = eventInfo->event_ID()->event_number();
m_lumiBlockOfPreviousEvent = m_currentLumiBlock;
m_currentLumiBlock = eventInfo->event_ID()->lumi_block();
- if ( eventInfo ) {
- incompleteEvent = eventInfo->eventFlags(EventInfo::Core) & 0x40000;
- }
- ATH_MSG(DEBUG) << "Successfully retrieved EventInfo (run: "
- << m_runNumber << ", event: " << m_eventNumber
- << ")" << endmsg;
+ incompleteEvent = eventInfo->eventFlags(EventInfo::Core) & 0x40000;
+ ATH_MSG_DEBUG( "Successfully retrieved EventInfo (run: " << m_runNumber << ", event: " << m_eventNumber << ")");
}
else {
- ATH_MSG(WARNING) << "Could not retrieve EventInfo from StoreGate => run# = event# = 0, LB# = 99" << endmsg;
+ ATH_MSG_WARNING( "Could not retrieve EventInfo from StoreGate => run# = event# = 0, LB# = 99");
m_lumiBlockOfPreviousEvent = m_currentLumiBlock;
m_currentLumiBlock = 99; // dummy LB in case EventInfo is not available - prevents DQ defect flagging with LB# 0...
}
if ( incompleteEvent ) {
- ATH_MSG(WARNING) << "Incomplete event according to EventInfo flag" << endmsg;
+ ATH_MSG_WARNING( "Incomplete event according to EventInfo flag");
incompleteFragmentType->Fill(5,1);
}
-
+
bool l1ctObjectMissingInStoreGate = ( !validCTP_RDO || !validCTP_RIO || !validMuCTPI_RDO || !validMuCTPI_RIO || !validRoIBResult );
if ( l1ctObjectMissingInStoreGate ) {
- ATH_MSG(WARNING) << "At least one L1CT object is missing in SG" << endmsg;
+ ATH_MSG_WARNING( "At least one L1CT object is missing in SG");
}
-
+
dumpData(theCTP_RDO, theCTP_RIO, theMuCTPI_RDO, theMuCTPI_RIO, roIBResult);
if ( m_processCTP ) {
if ( validCTP_RDO ) {
const std::vector<uint32_t> &cDataWords = theCTP_RDO->getDataWords();
if ( cDataWords.size() == 0 ) {
- ATH_MSG(WARNING) << "CTP_RDO is empty, ignoring CTP" << endmsg;
+ ATH_MSG_WARNING( "CTP_RDO is empty, ignoring CTP");
validCTP_RDO = false;
}
}
if ( validCTP_RIO ) {
if ( !m_runOnESD && (theCTP_RIO->getDetectorEventType() & 0xffff) == 0 ) {//LB == 0 only if RIO is empty
- ATH_MSG(WARNING) << "CTP_RIO is not valid, ignoring CTP" << endmsg;
+ ATH_MSG_WARNING( "CTP_RIO is not valid, ignoring CTP");
validCTP_RIO = false;
}
}
@@ -360,37 +288,34 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
// consider the fragment incomplete if the number of data words is less than
// the reported number of candidates (zero words valid for muon-less events!)
if (theMuCTPI_RDO->dataWord().size() < multWord.getNCandidates()) {
- ATH_MSG(INFO)
- << "MuCTPI_RDO reports " << multWord.getNCandidates()
+ ATH_MSG_INFO("MuCTPI_RDO reports " << multWord.getNCandidates()
<< " candidates, but there are only " << theMuCTPI_RDO->dataWord().size()
- << " data words, ignoring MuCTPI" << endmsg;
+ << " data words, ignoring MuCTPI");
validMuCTPI_RDO = false;
}
}
// Note: there's no simple way of checking the validity of the MUCTPI_RIO, so we don't for now.
}
-
+
// if at least one fragment is missing/incomplete, print out a summary
if (!validCTP_RDO || !validCTP_RIO || !validMuCTPI_RDO || !validMuCTPI_RIO || !validRoIBResult) {
- ATH_MSG(WARNING) << "At least one missing/invalid L1CT fragment detected" << endmsg;
- ATH_MSG(WARNING)
- << "CTP_RDO: " << validCTP_RDO << ", CTP_RIO: " << validCTP_RIO
+ ATH_MSG_WARNING( "At least one missing/invalid L1CT fragment detected");
+ ATH_MSG_WARNING( "CTP_RDO: " << validCTP_RDO << ", CTP_RIO: " << validCTP_RIO
<< ", MuCTPI_RIO: " << validMuCTPI_RIO << ", MuCTPI_RDO: " << validMuCTPI_RDO
- << ", RoIBResult: " << validRoIBResult << endmsg;
- //ATH_MSG(WARNING) << getEventInfoString() << endmsg;
+ << ", RoIBResult: " << validRoIBResult);
+ //ATH_MSG_WARNING( getEventInfoString());
if (validCTP_RIO) {
- ATH_MSG(WARNING)
- << "CTP_RIO says LB: " << (theCTP_RIO->getDetectorEventType() & 0xffff)
+ ATH_MSG_WARNING( "CTP_RIO says LB: " << (theCTP_RIO->getDetectorEventType() & 0xffff)
<< ", L1ID: " << std::dec << theCTP_RIO->getLvl1Id()
<< " (HEX: " << std::hex << theCTP_RIO->getLvl1Id() << ")" << std::dec
- << ", BCID: " << theCTP_RIO->getBCID() << endmsg;
+ << ", BCID: " << theCTP_RIO->getBCID());
}
else if (eventInfo) {
- ATH_MSG(WARNING) << "CTP_RIO missing, EventInfo says LB: " << eventInfo->event_ID()->lumi_block()
- << ", BCID: " << eventInfo->event_ID()->bunch_crossing_id() << endmsg; // no L1ID available
+ ATH_MSG_WARNING( "CTP_RIO missing, EventInfo says LB: " << eventInfo->event_ID()->lumi_block()
+ << ", BCID: " << eventInfo->event_ID()->bunch_crossing_id()); // no L1ID available
}
else {
- ATH_MSG(WARNING) << "Not printing event details since both CTP_RIO and EventInfo objects are missing" << endmsg;
+ ATH_MSG_WARNING( "Not printing event details since both CTP_RIO and EventInfo objects are missing");
}
// only fill error-per-LB histograms if L1CT fragments are missing and global incomplete-event flag
@@ -429,7 +354,7 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
// if the event is incomplete (missing L1CT objects or according to EventInfo), skip filling the rest of the histograms
if ( !validCTP_RDO || !validCTP_RIO || !validMuCTPI_RDO || !validMuCTPI_RIO || !validRoIBResult || incompleteEvent ) {
- ATH_MSG(WARNING) << "Event incomplete, will skip filling of all non-error histograms" << endmsg;
+ ATH_MSG_WARNING( "Event incomplete, will skip filling of all non-error histograms");
return StatusCode::SUCCESS;
}
@@ -441,17 +366,19 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
doCtp(theCTP_RDO, theCTP_RIO);
}
- if (m_processMuctpi && m_processCTP && validCTP_RDO && validCTP_RIO && validMuCTPI_RDO && validMuCTPI_RIO)
- doCtpMuctpi(theCTP_RDO, theCTP_RIO, theMuCTPI_RDO, theMuCTPI_RIO);
+ if (m_processMuctpi && m_processCTP && validCTP_RDO && validCTP_RIO && validMuCTPI_RDO && validMuCTPI_RIO) {
+ doCtpMuctpi(theCTP_RDO, theCTP_RIO, theMuCTPI_RDO, theMuCTPI_RIO);
+ }
if (m_processMuctpi && validMuCTPI_RDO && validMuCTPI_RIO && validTGCContainer && validRPCContainer) {
- doMuctpi(theMuCTPI_RDO, theMuCTPI_RIO, theRPCContainer, theTGCContainer );
- if (m_processRoIB && m_processMuctpiRIO)
+ doMuctpi(theMuCTPI_RDO, theMuCTPI_RIO, theRPCContainer, theTGCContainer);
+ if (m_processRoIB && m_processMuctpiRIO) {
doMuonRoI(theMuCTPI_RDO, theMuCTPI_RIO, roIBResult);
+ }
}
++m_eventCount;
-
- ATH_MSG(DEBUG) << "end fillHistograms()" << endmsg;
+
+ ATH_MSG_DEBUG( "end fillHistograms()");
return StatusCode::SUCCESS;
}
catch(const std::exception & e) {
@@ -460,11 +387,11 @@ TrigT1CTMonitoring::BSMonitoring::fillHistograms() {
}
}
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::procHistograms()
+{
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-procHistograms() {
-
- ATH_MSG(DEBUG) << "begin procHistograms()" << endmsg;
+ ATH_MSG_DEBUG( "begin procHistograms()");
updateRangeUser();
@@ -474,99 +401,108 @@ procHistograms() {
h1->getROOTHist()->GetXaxis()->SetRangeUser(0, lastFilledXBin);
}
- ATH_MSG(DEBUG) << "processed " << m_eventCount << " events ("
- << m_filledEventCount << " filled )" << endmsg;
- ATH_MSG(DEBUG) << "end procHistograms()" << endmsg;
+ ATH_MSG_DEBUG( "processed " << m_eventCount << " events ("
+ << m_filledEventCount << " filled )");
+ ATH_MSG_DEBUG( "end procHistograms()");
return StatusCode::SUCCESS;
}
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-initCtpHistograms() {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::initCtpHistograms()
+{
// error histograms
- m_dirName=m_baseDirName+"/";
-
- CHECK( registerTProfile("errorSummary", "CTP and MuCTPI errors; ; Error rate", 20, 0.5, 20.5, -1, 2) );
- CHECK( registerTH2("errorSummaryPerLumiBlock", "Errors per lumi block; LB number; Errors", 2000, 0.5, 2000.5, 20, 0.5, 20.5) );
- CHECK( registerTH1("errorPerLumiBlock", "Number of errors per lumi block; LB number; Errors", 2001, -0.5, 2000.5) );
- CHECK( registerTH1("incompleteFragmentType", "Number of missing fragments per type; Fragment type; Number of incomplete fragments", 8, -0.5, 7.5) );
-
- // CTP histograms
- m_dirName=m_baseDirName+"CTP/";
- CHECK( registerTH1("deltaBcid", "CTP Data BCID - ROD Header BCID; #DeltaBCID; Entries", 401, -200.5, 200.5) );
- CHECK( registerTH1("triggerType", "Trigger Type; Trigger Type; Entries", 256, -0.5, 255.5) );
- CHECK( registerTH1("timeSinceLBStart", "Time Since LB Start; Time After New LB (ms); Entries", 1000, -500, 1500) );
- CHECK( registerTH1("timeUntilLBEnd", "Time Until LB End; Time Until Next LB (ms); Entries", 1000, -500, 1500) );
- CHECK( registerTH1("timeSinceL1A", "Time since last L1A; Time since last L1A (ms); Entries", 2000, -1, 30) );
- CHECK( registerTH1("turnCounterTimeError", "Error of time based on turn counter and BCID; t_{TC+BCID}-t_{GPS} [#mus]; Entries", 2000, -1000., 1000.) );
- CHECK( registerTProfile("turnCounterTimeErrorVsLb", "Error of (TC+BCID)-based time vs. LB; LB; t_{TC+BCID}-t_{GPS} [#mus]", 2001, -0.5, 2000.5, -1000., 1000.) );
- CHECK( registerTH2("pitBC", "CTP BC vs. PIT; PIT; BC", 320, -0.5, 319.5, 127, -63.5, 63.5) );
- CHECK( registerTH2("pitFirstBC", "First CTP BC vs. PIT; PIT; BC", 320, -0.5, 319.5, 127, -63.5, 63.5) );
- CHECK( registerTH1("tav", "Trigger Items After Veto; CTP TAV; Entries", 512, -0.5, 511.5) );
- CHECK( registerTH1("ctpStatus1", "CTP Status Word 1; Bit; Number of times ON", 24, -0.5, 23.5) );
- CHECK( registerTH1("ctpStatus2", "CTP Status Word 2; Bit; Number of times ON", 24, -0.5, 23.5) );
-
- CHECK( registerTH1("l1ItemsBPSimMismatch","Sim mismatch L1 Items before prescale", 512, 0, 512) );
- CHECK( registerTH1("l1ItemsBPSimMismatchItems","Sim mismatch L1 Items before prescale, mismatched ones only", 512, 0, 512) );
-
- // fix cosmetics of some histos, e.g. bin labels
-
- TH1F_LW* l1ItemsBPSimMismatch = getTH1("l1ItemsBPSimMismatch");
- for(const TrigConf::TriggerItem * item : m_configSvc->ctpConfig()->menu().itemVector()) {
- if(item==nullptr) continue;
- string label = item->name() + " (CTP ID " + boost::lexical_cast<string,int>(item->ctpId())+ ")";
- l1ItemsBPSimMismatch->GetXaxis()->SetBinLabel(item->ctpId()+1,label.c_str());
- }
-
- std::map<int, std::string> errorSummaryBinLabels;
- errorSummaryBinLabels[1] = "CTP/ROD BCID Offset";
- errorSummaryBinLabels[2] = "No BCs in Readout";
- errorSummaryBinLabels[3] = "CTP/MuCTPI BCID Offset";
- errorSummaryBinLabels[4] = "Wrong Cand Word Number";
- errorSummaryBinLabels[5] = "Wrong Pt in Mult Word";
- errorSummaryBinLabels[6] = "Wrong Num of RoI";
- errorSummaryBinLabels[7] = "No Cand for RoI";
- errorSummaryBinLabels[8] = "Cand BC Out of Range";
- errorSummaryBinLabels[9] = "Invalid Lumi Block";
- errorSummaryBinLabels[10] = "LB Out of Time";
- errorSummaryBinLabels[11] = "Nanosec > 1e9";
- errorSummaryBinLabels[12] = "TAP w/out TBP";
- errorSummaryBinLabels[13] = "TAV w/out TAP";
- errorSummaryBinLabels[14] = "CTP sim. mismatch";
- errorSummaryBinLabels[15] = "Incomplete fragment";
- errorSummaryBinLabels[16] = "Missing orbit pulse";
- errorSummaryBinLabels[17] = "MuCTPI/noRPC candidate mismatch";
- errorSummaryBinLabels[18] = "MuCTPI/noTGC candidate mismatch";
- errorSummaryBinLabels[19] = "RPC/noMuCTPI candidate mismatch";
- errorSummaryBinLabels[20] = "TGC/noMuCTPI candidate mismatch";
-
- TProfile_LW* errorSummary = getTProfile("errorSummary");
- TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
- if (errorSummary) {
- errorSummary->GetXaxis()->SetLabelSize(0.03);
- errorSummaryPerLumiBlock->GetYaxis()->SetLabelSize(0.03);
- for (unsigned int bin = 1; bin < errorSummaryBinLabels.size()+1; ++bin) {
- errorSummary->GetXaxis()->SetBinLabel(bin, errorSummaryBinLabels[bin].c_str());
- errorSummaryPerLumiBlock->GetYaxis()->SetBinLabel(bin, errorSummaryBinLabels[bin].c_str());
- }
- }
+ m_dirName=m_baseDirName+"/";
+
+ CHECK( registerTProfile("errorSummary", "CTP and MuCTPI errors; ; Error rate", 20, 0.5, 20.5, -1, 2) );
+ CHECK( registerTH2("errorSummaryPerLumiBlock", "Errors per lumi block; LB number; Errors", 2000, 0.5, 2000.5, 20, 0.5, 20.5) );
+ CHECK( registerTH1("errorPerLumiBlock", "Number of errors per lumi block; LB number; Errors", 2001, -0.5, 2000.5) );
+ CHECK( registerTH1("incompleteFragmentType", "Number of missing fragments per type; Fragment type; Number of incomplete fragments", 8, -0.5, 7.5) );
+
+ // CTP histograms
+ m_dirName=m_baseDirName+"CTP/";
+ CHECK( registerTH1("deltaBcid", "CTP Data BCID - ROD Header BCID; #DeltaBCID; Entries", 401, -200.5, 200.5) );
+ CHECK( registerTH1("triggerType", "Trigger Type; Trigger Type; Entries", 256, -0.5, 255.5) );
+ CHECK( registerTH1("timeSinceLBStart", "Time Since LB Start; Time After New LB (ms); Entries", 1000, -500, 1500) );
+ CHECK( registerTH1("timeUntilLBEnd", "Time Until LB End; Time Until Next LB (ms); Entries", 1000, -500, 1500) );
+ CHECK( registerTH1("timeSinceL1A", "Time since last L1A; Time since last L1A (ms); Entries", 2000, -1, 30) );
+ CHECK( registerTH1("turnCounterTimeError", "Error of time based on turn counter and BCID; t_{TC+BCID}-t_{GPS} [#mus]; Entries", 2000, -1000., 1000.) );
+ CHECK( registerTProfile("turnCounterTimeErrorVsLb", "Error of (TC+BCID)-based time vs. LB; LB; t_{TC+BCID}-t_{GPS} [#mus]", 2001, -0.5, 2000.5, -1000., 1000.) );
+ CHECK( registerTH2("pitBC", "CTP BC vs. PIT; PIT; BC", 320, -0.5, 319.5, 127, -63.5, 63.5) );
+ CHECK( registerTH2("pitFirstBC", "First CTP BC vs. PIT; PIT; BC", 320, -0.5, 319.5, 127, -63.5, 63.5) );
+ CHECK( registerTH1("tav", "Trigger Items After Veto; CTP TAV; Entries", 512, -0.5, 511.5) );
+ CHECK( registerTH1("ctpStatus1", "CTP Status Word 1; Bit; Number of times ON", 24, -0.5, 23.5) );
+ CHECK( registerTH1("ctpStatus2", "CTP Status Word 2; Bit; Number of times ON", 24, -0.5, 23.5) );
+
+ CHECK( registerTH1("l1ItemsBPSimMismatch","Sim mismatch L1 Items before prescale", 512, 0, 512) );
+ CHECK( registerTH1("l1ItemsBPSimMismatchItems","Sim mismatch L1 Items before prescale, mismatched ones only", 512, 0, 512) );
+
+ // bin lables
+ TH1F_LW* l1ItemsBPSimMismatch = getTH1("l1ItemsBPSimMismatch");
+ if(m_useNewConfig) {
+ const TrigConf::L1Menu * l1menu = nullptr;
+ ATH_CHECK(detStore()->retrieve(l1menu));
+ for(const TrigConf::L1Item & item : *l1menu) {
+ string label = item.name() + " (CTP ID " + boost::lexical_cast<string,int>(item.ctpId())+ ")";
+ l1ItemsBPSimMismatch->GetXaxis()->SetBinLabel(item.ctpId()+1,label.c_str());
+ }
+ } else {
+ for(const TrigConf::TriggerItem * item : m_configSvc->ctpConfig()->menu().itemVector()) {
+ if(item==nullptr) continue;
+ string label = item->name() + " (CTP ID " + boost::lexical_cast<string,int>(item->ctpId())+ ")";
+ l1ItemsBPSimMismatch->GetXaxis()->SetBinLabel(item->ctpId()+1,label.c_str());
+ }
+ }
+ std::map<int, std::string> errorSummaryBinLabels;
+ errorSummaryBinLabels[1] = "CTP/ROD BCID Offset";
+ errorSummaryBinLabels[2] = "No BCs in Readout";
+ errorSummaryBinLabels[3] = "CTP/MuCTPI BCID Offset";
+ errorSummaryBinLabels[4] = "Wrong Cand Word Number";
+ errorSummaryBinLabels[5] = "Wrong Pt in Mult Word";
+ errorSummaryBinLabels[6] = "Wrong Num of RoI";
+ errorSummaryBinLabels[7] = "No Cand for RoI";
+ errorSummaryBinLabels[8] = "Cand BC Out of Range";
+ errorSummaryBinLabels[9] = "Invalid Lumi Block";
+ errorSummaryBinLabels[10] = "LB Out of Time";
+ errorSummaryBinLabels[11] = "Nanosec > 1e9";
+ errorSummaryBinLabels[12] = "TAP w/out TBP";
+ errorSummaryBinLabels[13] = "TAV w/out TAP";
+ errorSummaryBinLabels[14] = "CTP sim. mismatch";
+ errorSummaryBinLabels[15] = "Incomplete fragment";
+ errorSummaryBinLabels[16] = "Missing orbit pulse";
+ errorSummaryBinLabels[17] = "MuCTPI/noRPC candidate mismatch";
+ errorSummaryBinLabels[18] = "MuCTPI/noTGC candidate mismatch";
+ errorSummaryBinLabels[19] = "RPC/noMuCTPI candidate mismatch";
+ errorSummaryBinLabels[20] = "TGC/noMuCTPI candidate mismatch";
+
+ TProfile_LW* errorSummary = getTProfile("errorSummary");
+ TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
+ if (errorSummary) {
+ errorSummary->GetXaxis()->SetLabelSize(0.03);
+ errorSummaryPerLumiBlock->GetYaxis()->SetLabelSize(0.03);
+ for (unsigned int bin = 1; bin < errorSummaryBinLabels.size()+1; ++bin) {
+ errorSummary->GetXaxis()->SetBinLabel(bin, errorSummaryBinLabels[bin].c_str());
+ errorSummaryPerLumiBlock->GetYaxis()->SetBinLabel(bin, errorSummaryBinLabels[bin].c_str());
+ }
+ }
- TH1F_LW* incompleteFragmentType = getTH1("incompleteFragmentType");
- if (incompleteFragmentType) {
- incompleteFragmentType->GetXaxis()->SetBinLabel(1, "CTP RIO");
- incompleteFragmentType->GetXaxis()->SetBinLabel(2, "CTP RDO");
- incompleteFragmentType->GetXaxis()->SetBinLabel(3, "MuCTPI RIO");
- incompleteFragmentType->GetXaxis()->SetBinLabel(4, "MuCTPI RDO");
- incompleteFragmentType->GetXaxis()->SetBinLabel(5, "RoIBResult");
- incompleteFragmentType->GetXaxis()->SetBinLabel(6, "TGC SL RDO");
- incompleteFragmentType->GetXaxis()->SetBinLabel(7, "RPC SL RDO");
- }
+ TH1F_LW* incompleteFragmentType = getTH1("incompleteFragmentType");
+ if (incompleteFragmentType) {
+ incompleteFragmentType->GetXaxis()->SetBinLabel(1, "CTP RIO");
+ incompleteFragmentType->GetXaxis()->SetBinLabel(2, "CTP RDO");
+ incompleteFragmentType->GetXaxis()->SetBinLabel(3, "MuCTPI RIO");
+ incompleteFragmentType->GetXaxis()->SetBinLabel(4, "MuCTPI RDO");
+ incompleteFragmentType->GetXaxis()->SetBinLabel(5, "RoIBResult");
+ incompleteFragmentType->GetXaxis()->SetBinLabel(6, "TGC SL RDO");
+ incompleteFragmentType->GetXaxis()->SetBinLabel(7, "RPC SL RDO");
+ }
- return StatusCode::SUCCESS;
+ return StatusCode::SUCCESS;
}
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-initMuctpiHistograms() {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::initMuctpiHistograms()
+{
m_dirName=m_baseDirName+"MUCTPI/";
@@ -636,8 +572,9 @@ initMuctpiHistograms() {
return StatusCode::SUCCESS;
}
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-initCtpMuctpiHistograms() {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::initCtpMuctpiHistograms()
+{
m_dirName=m_baseDirName+"CTPMUCTPI/";
@@ -648,8 +585,9 @@ initCtpMuctpiHistograms() {
return StatusCode::SUCCESS;
}
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-initRoIHistograms() {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::initRoIHistograms()
+{
m_dirName=m_baseDirName+"ROI/";
@@ -676,8 +614,11 @@ initRoIHistograms() {
return StatusCode::SUCCESS;
}
-void TrigT1CTMonitoring::BSMonitoring::
-doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO> theMuCTPI_RIO, const DataHandle <RpcSectorLogicContainer> theRPCContainer, const DataHandle <Muon::TgcCoinDataContainer> theTGCContainer) {
+void
+TrigT1CTMonitoring::BSMonitoring::doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO> theMuCTPI_RIO,
+ const DataHandle <RpcSectorLogicContainer> theRPCContainer,
+ const DataHandle <Muon::TgcCoinDataContainer> theTGCContainer)
+{
TProfile_LW* errorSummary = getTProfile("errorSummary");
TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
@@ -701,15 +642,15 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
TH1F_LW* endcapPt = getTH1("endcapPt");
TH1F_LW* forwardPt = getTH1("forwardPt");
- if ( !errorSummary || !errorSummaryPerLumiBlock || !errorPerLumiBlock || !nCandidates || !nCandidatesDataWord || !pt || !muctpiStatus1
+ if ( !errorSummary || !errorSummaryPerLumiBlock || !errorPerLumiBlock || !nCandidates || !nCandidatesDataWord || !pt || !muctpiStatus1
|| !muctpiStatus2 || !nCandidatesMictpMioct || !bcidMictpMioct || !bcidMictpHeader
|| !endcapSectorIDOverlapBit || !barrelSectorID || !endcapSectorID || !forwardSectorID
|| !barrelPt || !endcapSectorIDAll || !forwardSectorIDAll || !barrelSectorIDAll
- || !endcapPt || !forwardPt ) {
- ATH_MSG(FATAL) << "Problems finding 1D histograms for MuCTPI!"
- << endmsg;
- return;
- }
+ || !endcapPt || !forwardPt )
+ {
+ ATH_MSG_FATAL("Problems finding 1D histograms for MuCTPI!");
+ return;
+ }
TH2F_LW *barrelRoiSectorID = getTH2("barrelRoiSectorID");
TH2F_LW *endcapRoiSectorID = getTH2("endcapRoiSectorID");
TH2F_LW *forwardRoiSectorID = getTH2("forwardRoiSectorID");
@@ -735,10 +676,9 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
!nCandidatesPt || !barrelSectorIDOverlapBits || !muctpiNoRPCCandfound ||
!rpcNoMuCTPICandfound || !muctpiNoTGCecCandfound || !tgcecNoMuCTPICandfound ||
!muctpiNoTGCfwCandfound || !tgcfwNoMuCTPICandfound) {
- ATH_MSG(FATAL) << "Problems finding 2D histograms for MuCTPI!"
- << endmsg;
+ ATH_MSG_FATAL("Problems finding 2D histograms for MuCTPI!");
return;
- }
+ }
// maps for comapring MuCTPI and RPC/TGC candidates
std::map <std::string,MuCTPI_DataWord_Decoder> muctpiCandidates;
@@ -845,9 +785,8 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
int diffNCandidates = (static_cast<int>(numberCandidates) - numberDataWords);
if (diffNCandidates != 0) {
- ATH_MSG(WARNING) << "Number of candidates in multiplicity word " << numberCandidates
- << " != number of candidates " << numberDataWords << " from " << vDataWords.size()
- << " data words" << endmsg;
+ ATH_MSG_WARNING( "Number of candidates in multiplicity word " << numberCandidates
+ << " != number of candidates " << numberDataWords << " from " << vDataWords.size() << " data words");
// dump multiplicity and data words (DEBUG level)
multWord.dumpData();
for ( std::vector<uint32_t>::const_iterator it = vDataWords.begin(); it != vDataWords.end(); ++it ) {
@@ -897,50 +836,33 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
forwardRoiSectorIDAll->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), dataWord.getRoiNumber());
}
-/* candidateBcid = dataWord.getBCID();
-
- int candbcdiff = candidateBcid - mictpBcid;
- if (candbcdiff > 3) candbcdiff -= 8;
- if (candbcdiff < -3) candbcdiff += 8;
- bcidMictpMioct->Fill(candbcdiff);
-
- if (abs(candbcdiff)>3) {
- ATH_MSG(WARNING) << "MIOCT candidate BC " << candidateBcid << " out of range of MICTP BC "
- << mictpBcid << endmsg;
- errorSummary->Fill(8,1);
- errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 8);
- errorPerLumiBlock->Fill(m_currentLumiBlock);
- }
- else errorSummary->Fill(8,0);
-*/
- //Use only non-vetoed candidates from the same BCID for multiplicity calculation
- if ( //(dataWord.getBCID() == multWord.getBCID()) &&
- !dataWord.getVetoed() ) {
+ // Use only non-vetoed candidates from the same BCID for multiplicity calculation
+ if ( ! dataWord.getVetoed() ) {
uint16_t candPt = dataWord.getPt();
pt->Fill(candPt);
if (0 < candPt && candPt <= MuCTPI_RDO::MULT_THRESH_NUM) {
- if (m_inclusiveTriggerThresholds) {
- for ( uint16_t i(0); i < candPt; ++i )
- if (MioctPtCount[i] < 7) {
- MioctPtCount[i] += 1;
- }
- }
- else {
- if (MioctPtCount[candPt - 1] < 7)
- MioctPtCount[candPt - 1] += 1;
- }
+ if (m_inclusiveTriggerThresholds) {
+ for ( uint16_t i(0); i < candPt; ++i )
+ if (MioctPtCount[i] < 7) {
+ MioctPtCount[i] += 1;
+ }
+ } else {
+ if (MioctPtCount[candPt - 1] < 7) {
+ MioctPtCount[candPt - 1] += 1;
+ }
+ }
}
if (dataWord.getSectorLocation() == MuCTPI_RDO::BARREL) {
- barrelSectorID->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere());
- barrelRoiSectorID->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), dataWord.getRoiNumber());
+ barrelSectorID->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere());
+ barrelRoiSectorID->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), dataWord.getRoiNumber());
}
else if (dataWord.getSectorLocation() == MuCTPI_RDO::ENDCAP) {
- endcapSectorID->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere());
- endcapRoiSectorID->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), dataWord.getRoiNumber());
+ endcapSectorID->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere());
+ endcapRoiSectorID->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), dataWord.getRoiNumber());
}
else if (dataWord.getSectorLocation() == MuCTPI_RDO::FORWARD) {
- forwardSectorID->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere());
- forwardRoiSectorID->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), dataWord.getRoiNumber());
+ forwardSectorID->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere());
+ forwardRoiSectorID->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), dataWord.getRoiNumber());
}
}
if (dataWord.getSectorLocation() == MuCTPI_RDO::BARREL) {
@@ -961,8 +883,8 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
for ( uint16_t i = 0; i < MuCTPI_RDO::MULT_THRESH_NUM; ++i ) {
if ( multWord.getMultiplicity(i) != MioctPtCount[i] ) {
anyMismatch = true;
- ATH_MSG(WARNING) << "pT threshold " << i+1 << ": MICTP multiplicity (" << multWord.getMultiplicity(i)
- << ") not equal MIOCT multiplicity (" << MioctPtCount[i] << ")" << endmsg;
+ ATH_MSG_WARNING( "pT threshold " << i+1 << ": MICTP multiplicity (" << multWord.getMultiplicity(i)
+ << ") not equal MIOCT multiplicity (" << MioctPtCount[i] << ")");
errorSummary->Fill(5,1);
errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 5);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -986,22 +908,21 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
std::vector<uint32_t> vStatus =
theMuCTPI_RIO->getHeaderStatusWords();
for ( uint32_t i = 0; i < num; ++i ) {
- if (vStatus[i] != 0) {
- TH1F_LW *hist = 0;
- if (i == 0) {
- ATH_MSG(DEBUG) << "MuCTPI error status word #" << i
- << ": 0x" << MSG::hex << vStatus[i] << MSG::dec
- << endmsg;
- hist = muctpiStatus1;
- } else if (i == 1) {
- hist = muctpiStatus2;
- } else {
- continue;
- }
- for ( int bit = 0; bit < 24; ++bit ) {
- if (vStatus[i] & (1 << bit))
- hist->Fill(bit);
- }
+ if (vStatus[i] == 0) {
+ continue;
+ }
+ TH1F_LW *hist = 0;
+ if (i == 0) {
+ ATH_MSG_DEBUG( "MuCTPI error status word #" << i << ": 0x" << MSG::hex << vStatus[i] << MSG::dec);
+ hist = muctpiStatus1;
+ } else if (i == 1) {
+ hist = muctpiStatus2;
+ } else {
+ continue;
+ }
+ for ( int bit = 0; bit < 24; ++bit ) {
+ if (vStatus[i] & (1 << bit))
+ hist->Fill(bit);
}
}
}
@@ -1009,9 +930,9 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
const EventInfo* eventInfo = 0;
StatusCode sc = StatusCode::SUCCESS;
sc = evtStore()->retrieve(eventInfo);
- if (!sc.isSuccess()) {
- ATH_MSG(WARNING) << "Could not retrieve EventInfo from StoreGate" << endmsg;
- }
+ if (!sc.isSuccess()) {
+ ATH_MSG_WARNING( "Could not retrieve EventInfo from StoreGate");
+ }
// Get candidates from TGC and RPC SLs for comparisons
@@ -1067,9 +988,9 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
int tgcnum = tgcCandidates.count(it_mui->first);
int rpcnum = rpcCandidates.count(it_mui->first);
if (tgcnum > 0 || rpcnum > 0 ) {
- ATH_MSG(DEBUG) << "MuCTPI to RPC/TGC match found: MuCTPI key/ MuCTPI BCID / #TGC matches / #RPC matches: "
+ ATH_MSG_DEBUG( "MuCTPI to RPC/TGC match found: MuCTPI key/ MuCTPI BCID / #TGC matches / #RPC matches: "
<< it_mui->first << " / " << /*it_mui->second.getBCID() <<*/ " / "
- << tgcnum << " / " << rpcnum << endmsg;
+ << tgcnum << " / " << rpcnum);
} else {
if ( (it_mui->first).substr(0,2) == "BA" ) {
int baSecID = (it_mui->second).getSectorID(1)+32*(it_mui->second).getHemisphere();
@@ -1087,11 +1008,11 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
muctpiNoTGCfwCandfound->Fill(fwRoIID,fwSecID);
miTGCmismatch= true;
} else {
- ATH_MSG(WARNING) << "Invalid string label in MuCTPI to RPC/TGC map: "
- << (it_mui->first).substr(0,2) << endmsg;
+ ATH_MSG_WARNING( "Invalid string label in MuCTPI to RPC/TGC map: "
+ << (it_mui->first).substr(0,2));
}
- ATH_MSG(WARNING) << "No Muctpi to RPC/TGC match found: MuCTPI key / MuCTPI BCID: "
- << it_mui->first << " / " << /*it_mui->second.getBCID() <<*/ endmsg;
+ ATH_MSG_WARNING( "No Muctpi to RPC/TGC match found: MuCTPI key / MuCTPI BCID: "
+ << it_mui->first << " / ");
}
}
@@ -1117,16 +1038,16 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
it_rpc != rpcCandidates.end(); ++it_rpc) {
int muinum = muctpiCandidates.count(it_rpc->first);
if (muinum > 0) {
- ATH_MSG(DEBUG) << " RPC to Muctpi match found: RPC key / RPC BCID / # matches: "
+ ATH_MSG_DEBUG( " RPC to Muctpi match found: RPC key / RPC BCID / # matches: "
<< it_rpc->first << " / " << it_rpc->second->rowinBcid() << " / "
- << muinum << endmsg;
+ << muinum);
} else {
int idEnd = (it_rpc->first).find("-RoI");
int secID = std::stoi((it_rpc->first).substr(2,idEnd-2));
int roiID = (it_rpc->second)->roi();
rpcNoMuCTPICandfound->Fill(roiID,secID);
- ATH_MSG(WARNING) << "No RPC to Muctpi match found: RPC key / RPC BCID: "
- << it_rpc->first << " / " << it_rpc->second->rowinBcid() << endmsg;
+ ATH_MSG_WARNING( "No RPC to Muctpi match found: RPC key / RPC BCID: "
+ << it_rpc->first << " / " << it_rpc->second->rowinBcid());
rpcMImismatch =true;
}
}
@@ -1143,8 +1064,8 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
it_tgc != tgcCandidates.end(); ++it_tgc) {
int muinum = muctpiCandidates.count(it_tgc->first);
if (muinum > 0) {
- ATH_MSG(DEBUG) << "TGC to Muctpi match found: TGC key / TGC BCID / # matches: "
- << it_tgc->first << " / " << (int)TgcDigit::BC_CURRENT << muinum << endmsg;
+ ATH_MSG_DEBUG( "TGC to Muctpi match found: TGC key / TGC BCID / # matches: "
+ << it_tgc->first << " / " << (int)TgcDigit::BC_CURRENT << muinum);
} else {
int idEnd = (it_tgc->first).find("-RoI");
int secID = std::stoi((it_tgc->first).substr(2,idEnd-2));
@@ -1155,10 +1076,10 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
int fwRoIID = (it_tgc->second)->roi();
tgcfwNoMuCTPICandfound->Fill(fwRoIID,secID);
} else {
- ATH_MSG(WARNING) << "Invalid string label in TGC to MuCTPI map: "
- << (it_tgc->first).substr(0,2) << endmsg;
+ ATH_MSG_WARNING( "Invalid string label in TGC to MuCTPI map: "
+ << (it_tgc->first).substr(0,2));
}
- ATH_MSG(WARNING) << "No TGC to Muctpi match found: TGC key: " << it_tgc->first << endmsg;
+ ATH_MSG_WARNING( "No TGC to Muctpi match found: TGC key: " << it_tgc->first);
tgcMImismatch =true;
}
}
@@ -1171,13 +1092,9 @@ doMuctpi(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO
}
}
-
-
-
-
-void TrigT1CTMonitoring::BSMonitoring::
-doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO) {
-
+void
+TrigT1CTMonitoring::BSMonitoring::doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
+{
TProfile_LW *errorSummary = getTProfile("errorSummary");
TH1F_LW *errorPerLumiBlock = getTH1("errorPerLumiBlock");
TH1F_LW *deltaBcid = getTH1("deltaBcid");
@@ -1193,17 +1110,16 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
if ( !errorSummary || !errorPerLumiBlock || !deltaBcid || !triggerType || !timeSinceLBStart ||
!timeUntilLBEnd || !timeSinceL1A || !tcTimeError || !tcTimeErrorVsLb || !ctpStatus1 || !tav || !ctpStatus2 ) {
- ATH_MSG(FATAL) << "Problems finding 1D histograms for CTP!" << endmsg;
+ ATH_MSG_FATAL("Problems finding 1D histograms for CTP!");
return;
}
TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
TH2F_LW *pitBC = getTH2("pitBC");
TH2F_LW *pitFirstBC = getTH2("pitFirstBC");
-
+
if ( !errorSummaryPerLumiBlock || !pitBC || !pitFirstBC ) {
- ATH_MSG(FATAL) << "Problems finding 2D histograms for CTP!"
- << endmsg;
+ ATH_MSG_FATAL("Problems finding 2D histograms for CTP!");
return;
}
@@ -1223,17 +1139,17 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
// check that the LB number is the same in the EventInfo and the CTP_RIO. TODO: add error for this?
if (m_currentLumiBlock != (theCTP_RIO->getDetectorEventType() & 0xffff)) {
- ATH_MSG(WARNING) << "LB number in EventInfo (" << m_currentLumiBlock
+ ATH_MSG_WARNING( "LB number in EventInfo (" << m_currentLumiBlock
<< ") does not match the one in the CTP_RIO object ("
- << (theCTP_RIO->getDetectorEventType() & 0xffff) << ")" << endmsg;
+ << (theCTP_RIO->getDetectorEventType() & 0xffff) << ")");
}
- //ATH_MSG(DEBUG) << getEventInfoString() << endmsg;
+ //ATH_MSG_DEBUG( getEventInfoString());
if (m_currentLumiBlock > m_maxLumiBlock) m_maxLumiBlock = m_currentLumiBlock;
if (m_currentLumiBlock < 1 ||
(m_retrievedLumiBlockTimes && (find(m_lumiBlocks.begin(), m_lumiBlocks.end(), m_currentLumiBlock) == m_lumiBlocks.end()))) {
- ATH_MSG(WARNING) << "Invalid lumi block: " << m_currentLumiBlock << endmsg;
+ ATH_MSG_WARNING( "Invalid lumi block: " << m_currentLumiBlock);
errorSummary->Fill(9,1);
errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 9);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -1243,10 +1159,10 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
if (m_retrievedLumiBlockTimes) {
uint64_t eventTime = static_cast<uint64_t>(theCTP_RDO->getTimeSec()*1e09 + theCTP_RDO->getTimeNanoSec());
if (eventTime < m_lbStartTimes[m_currentLumiBlock] || eventTime > m_lbEndTimes[m_currentLumiBlock]) {
- ATH_MSG(WARNING) << "Event time (" << eventTime
+ ATH_MSG_WARNING( "Event time (" << eventTime
<< ") not within time interval for current lumi block (LB: " << m_currentLumiBlock
<< ", start: " << m_lbStartTimes[m_currentLumiBlock]
- << ", stop: " << m_lbEndTimes[m_currentLumiBlock] << ")" << endmsg;
+ << ", stop: " << m_lbEndTimes[m_currentLumiBlock] << ")");
errorSummary->Fill(10,1);
errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 10);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -1272,12 +1188,12 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
else {
bcDurationInNs = 1./freqFromCool*1e9;
}
- ATH_MSG(DEBUG) << "Will use BC interval calculated from frequency measurement(s) in COOL: f = "
- << freqFromCool << " Hz => t_BC = " << bcDurationInNs << " ns" << endmsg;
+ ATH_MSG_DEBUG( "Will use BC interval calculated from frequency measurement(s) in COOL: f = "
+ << freqFromCool << " Hz => t_BC = " << bcDurationInNs << " ns");
}
else {
- ATH_MSG(DEBUG) << "No valid frequency measurements found in COOL, will use hardcoded BC interval: t_BC = "
- << bcDurationInNs << " ns" << endmsg; //TODO: make this a WARNING when everything is in place in COOL
+ ATH_MSG_DEBUG( "No valid frequency measurements found in COOL, will use hardcoded BC interval: t_BC = "
+ << bcDurationInNs << " ns"); //TODO: make this a WARNING when everything is in place in COOL
}
// set the reference variables for the turn counter monitoring if this is the first processed event of the run/LB
@@ -1303,8 +1219,8 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
!((m_dataTakingMode.find(m_currentLumiBlock) != m_dataTakingMode.end()) &&
(m_dataTakingMode[m_currentLumiBlock] == true)) &&
(fabs(tDiffInNs) > 45000) ) {
- ATH_MSG(WARNING) << "Turn-counter based time off by " << tDiffInNs
- << " ns (> 0.5 LHC turn) during stable beams - missing orbit pulse?" << endmsg;
+ ATH_MSG_WARNING( "Turn-counter based time off by " << tDiffInNs
+ << " ns (> 0.5 LHC turn) during stable beams - missing orbit pulse?");
errorSummary->Fill(16,1);
errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 16);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -1316,14 +1232,14 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
tcTimeErrorVsLb->Fill(m_currentLumiBlock, tDiffInNs/1e03);
}
else {
- ATH_MSG(DEBUG) << "Turn counter = 0 for both first processed and current event, not filling TC histograms" << endmsg;
+ ATH_MSG_DEBUG( "Turn counter = 0 for both first processed and current event, not filling TC histograms");
}
}
}
}
if (theCTP_RDO->getTimeNanoSec() > 1e09) {
- ATH_MSG(WARNING) << "Nanosecond timestamp too large: " << theCTP_RDO->getTimeNanoSec() << endmsg;
+ ATH_MSG_WARNING( "Nanosecond timestamp too large: " << theCTP_RDO->getTimeNanoSec());
errorSummary->Fill(11,1);
errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 11);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -1346,8 +1262,8 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
deltaBcid->Fill(bcid_offset);
if (bcid_offset != 0) {
if (!m_runOnESD) {
- ATH_MSG(WARNING) << "Found BCID offset of "<< bcid_offset << " between ROD Header ("
- << headerBcid << ") and data (" << (bcid&0xf) << ")" << endmsg;
+ ATH_MSG_WARNING( "Found BCID offset of "<< bcid_offset << " between ROD Header ("
+ << headerBcid << ") and data (" << (bcid&0xf) << ")");
errorSummary->Fill(1,1);
errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 1);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -1409,7 +1325,7 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
if ( (!bunchIndex) && (m_compareRerun) ) {//gives position of L1A
StatusCode sc = compareRerun(*it);
if ( sc.isFailure() ) {
- ATH_MSG(WARNING) << "compareRerun() returned failure" << endmsg;
+ ATH_MSG_WARNING( "compareRerun() returned failure");
}
}
@@ -1444,25 +1360,25 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
bool allTAPFine=true;
bool allTAVFine=true;
for ( unsigned int i=0; i<m_tapItems.size(); i++ ) {
- ATH_MSG(DEBUG) << m_tapItems.at(i) << " TAP fired at BC " << m_tapBC.at(i) << endmsg;
+ ATH_MSG_DEBUG( m_tapItems.at(i) << " TAP fired at BC " << m_tapBC.at(i));
bool isTBP=false;
for ( unsigned int j=0; j<m_tbpItems.size() && isTBP==false; j++ ) {
if ( m_tbpItems.at(j)==m_tapItems.at(i) && m_tbpBC.at(j)==m_tapBC.at(i) ) isTBP=true;
}
if ( isTBP==false ) {
allTAPFine=false;
- ATH_MSG(WARNING) << "TAP item " << m_tapItems.at(i) << " at BC " << m_tapBC.at(i) << " not found in TBP" << endmsg;
+ ATH_MSG_WARNING( "TAP item " << m_tapItems.at(i) << " at BC " << m_tapBC.at(i) << " not found in TBP");
}
}
for ( unsigned int i=0; i<m_tavItems.size(); i++ ) {
- ATH_MSG(DEBUG) << m_tavItems.at(i) << " TAV fired at BC " << m_tavBC.at(i) << endmsg;
+ ATH_MSG_DEBUG( m_tavItems.at(i) << " TAV fired at BC " << m_tavBC.at(i));
bool isTAP=false;
for ( unsigned int j=0; j<m_tapItems.size() && isTAP==false; j++ ) {
if ( m_tapItems.at(j)==m_tavItems.at(i) && m_tapBC.at(j)==m_tavBC.at(i) ) isTAP=true;
}
if ( isTAP==false ) {
allTAVFine=false;
- ATH_MSG(WARNING) << "TAV item " << m_tavItems.at(i) << " at BC " << m_tavBC.at(i) << " not found in TAP" << endmsg;
+ ATH_MSG_WARNING( "TAV item " << m_tavItems.at(i) << " at BC " << m_tavBC.at(i) << " not found in TAP");
}
}
@@ -1495,11 +1411,11 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
for ( unsigned int i = 0; i < triggersFired.size(); ++i ) {
str << triggersFired[i] << " ";
}
- ATH_MSG(DEBUG) << triggersFired.size() << " trigger items fired: " << str.str() << endmsg;
+ ATH_MSG_DEBUG( triggersFired.size() << " trigger items fired: " << str.str());
}
else {
if (!m_runOnESD) {
- ATH_MSG(WARNING) << "Zero bunches in CTP data for ext. LVL1 ID 0x" << MSG::hex << evId << MSG::dec << endmsg;
+ ATH_MSG_WARNING( "Zero bunches in CTP data for ext. LVL1 ID 0x" << MSG::hex << evId << MSG::dec);
errorSummary->Fill(2,1);
errorSummary->Fill(m_currentLumiBlock, 2);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -1516,7 +1432,7 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
if (vStatus[i] != 0) {
TH1F_LW *hist = 0;
if (i == 0) {
- ATH_MSG(DEBUG) << "CTP error status word #" << i << ": 0x" << MSG::hex << vStatus[i] << MSG::dec << endmsg;
+ ATH_MSG_DEBUG( "CTP error status word #" << i << ": 0x" << MSG::hex << vStatus[i] << MSG::dec);
hist = ctpStatus1;
} else if (i == 1) {
hist = ctpStatus2;
@@ -1532,10 +1448,9 @@ doCtp(const DataHandle<CTP_RDO> theCTP_RDO,const DataHandle<CTP_RIO> theCTP_RIO)
}
}
-
-
-void TrigT1CTMonitoring::BSMonitoring::
-updateRangeUser() {
+void
+TrigT1CTMonitoring::BSMonitoring::updateRangeUser()
+{
//Make 2D plots readable
if (m_lastminbc!=m_lastmaxbc) {
TH2F_LW* h;
@@ -1547,12 +1462,10 @@ updateRangeUser() {
if ((h1=getTH1("errorPerLumiBlock"))) h1->getROOTHist()->GetXaxis()->SetRangeUser(-0.5, m_maxLumiBlock+0.5);
}
-void TrigT1CTMonitoring::BSMonitoring::
-doCtpMuctpi(const DataHandle<CTP_RDO> theCTP_RDO,
- const DataHandle<CTP_RIO> theCTP_RIO,
- const DataHandle<MuCTPI_RDO> theMuCTPI_RDO,
- const DataHandle<MuCTPI_RIO> theMuCTPI_RIO) {
-
+void
+TrigT1CTMonitoring::BSMonitoring::doCtpMuctpi( const DataHandle<CTP_RDO> theCTP_RDO, const DataHandle<CTP_RIO> theCTP_RIO,
+ const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO> theMuCTPI_RIO)
+{
TProfile_LW *errorSummary = getTProfile("errorSummary");
TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
TH1F_LW *errorPerLumiBlock = getTH1("errorPerLumiBlock");
@@ -1560,7 +1473,7 @@ doCtpMuctpi(const DataHandle<CTP_RDO> theCTP_RDO,
TH1F_LW *headerBCIDDifference = getTH1("headerBCIDDifference");
TH1F_LW *bcidDifference = getTH1("bcidDifference");
if ( !errorSummary || !errorSummaryPerLumiBlock || !errorPerLumiBlock || !headerL1IdDifference || !headerBCIDDifference || !bcidDifference ) {
- ATH_MSG(FATAL) << "Problems finding histograms for CTP_MuCTPI!" << endmsg;
+ ATH_MSG_FATAL("Problems finding histograms for CTP_MuCTPI!");
return;
}
if (theCTP_RIO && theMuCTPI_RIO) {
@@ -1575,7 +1488,7 @@ doCtpMuctpi(const DataHandle<CTP_RDO> theCTP_RDO,
headerL1IdDifference->Fill(diffValEvid);
headerBCIDDifference->Fill(diffValBcid);
if (diffValBcid!=0) {
- ATH_MSG(WARNING) << "BCID mismatch between CTP and MuCTPI RIOs, filling error histograms" << endmsg;
+ ATH_MSG_WARNING( "BCID mismatch between CTP and MuCTPI RIOs, filling error histograms");
errorSummary->Fill(3,1);
errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 3);
errorPerLumiBlock->Fill(m_currentLumiBlock);
@@ -1584,14 +1497,12 @@ doCtpMuctpi(const DataHandle<CTP_RDO> theCTP_RDO,
if (diffValBcid < headerBCIDDifference->getXMin()
|| diffValBcid > headerBCIDDifference->getXMax()) {
- ATH_MSG(WARNING) << "BCID difference out of range. CTP_RODHeader_BCID: "
- << ctp_bcid << " MuCTPI_RODHeader_BCID: " << (muctpi_bcid) << endmsg;
+ ATH_MSG_WARNING( "BCID difference out of range. CTP_RODHeader_BCID: "
+ << ctp_bcid << " MuCTPI_RODHeader_BCID: " << (muctpi_bcid));
}
}
- MuCTPI_MultiplicityWord_Decoder multWord(theMuCTPI_RDO->
- candidateMultiplicity(),
- m_inclusiveTriggerThresholds);
- MuCTPI_DataWord_Decoder dataWord(0);
+ MuCTPI_MultiplicityWord_Decoder multWord(theMuCTPI_RDO->candidateMultiplicity(), m_inclusiveTriggerThresholds);
+ MuCTPI_DataWord_Decoder dataWord(0);
CTP_Decoder ctp;
ctp.setRDO(theCTP_RDO);
@@ -1606,237 +1517,267 @@ doCtpMuctpi(const DataHandle<CTP_RDO> theCTP_RDO,
}
}
-void TrigT1CTMonitoring::BSMonitoring::
-doMuonRoI(const DataHandle<MuCTPI_RDO> theMuCTPI_RDO,
- const DataHandle<MuCTPI_RIO> theMuCTPI_RIO,
- const DataHandle<ROIB::RoIBResult> roib) {
-
- TProfile_LW *errorSummary = getTProfile("errorSummary");
- TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
- TH1F_LW *errorPerLumiBlock = getTH1("errorPerLumiBlock");
- TH1F_LW *roiEta = getTH1("roiEta");
- TH1F_LW *roiPhi = getTH1("roiPhi");
- TH1F_LW *nCandidates_secLoc = getTH1("nCandidates_secLoc");
+void
+TrigT1CTMonitoring::BSMonitoring::doMuonRoI( const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO> theMuCTPI_RIO,
+ const DataHandle<ROIB::RoIBResult> roib)
+{
+ TProfile_LW *errorSummary = getTProfile("errorSummary");
+ TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
+ TH1F_LW *errorPerLumiBlock = getTH1("errorPerLumiBlock");
+ TH1F_LW *roiEta = getTH1("roiEta");
+ TH1F_LW *roiPhi = getTH1("roiPhi");
+ TH1F_LW *nCandidates_secLoc = getTH1("nCandidates_secLoc");
- if ( !errorSummary || !errorSummaryPerLumiBlock || !errorPerLumiBlock || !roiEta || !roiPhi || !nCandidates_secLoc ) {
- ATH_MSG(FATAL) << "Problems finding 1D histograms for RoI!" << endmsg;
- return;
- }
- TH2F_LW *roiEtaPhi = getTH2("roiEtaPhi");
- TH2F_LW *barrelSectorIDRoi = getTH2("barrelSectorIDRoi");
- TH2F_LW *endcapSectorIDRoi = getTH2("endcapSectorIDRoi");
- TH2F_LW *forwardSectorIDRoi = getTH2("forwardSectorIDRoi");
- TH2F_LW *barrelSectorIDRoiEta = getTH2("barrelSectorIDRoiEta");
- TH2F_LW *endcapSectorIDRoiEta = getTH2("endcapSectorIDRoiEta");
- TH2F_LW *forwardSectorIDRoiEta = getTH2("forwardSectorIDRoiEta");
- TH2F_LW *barrelSectorIDRoiPhi = getTH2("barrelSectorIDRoiPhi");
- TH2F_LW *endcapSectorIDRoiPhi = getTH2("endcapSectorIDRoiPhi");
- TH2F_LW *forwardSectorIDRoiPhi = getTH2("forwardSectorIDRoiPhi");
+ if ( !errorSummary || !errorSummaryPerLumiBlock || !errorPerLumiBlock || !roiEta || !roiPhi || !nCandidates_secLoc ) {
+ ATH_MSG_FATAL("Problems finding 1D histograms for RoI!");
+ return;
+ }
+ TH2F_LW *roiEtaPhi = getTH2("roiEtaPhi");
+ TH2F_LW *barrelSectorIDRoi = getTH2("barrelSectorIDRoi");
+ TH2F_LW *endcapSectorIDRoi = getTH2("endcapSectorIDRoi");
+ TH2F_LW *forwardSectorIDRoi = getTH2("forwardSectorIDRoi");
+ TH2F_LW *barrelSectorIDRoiEta = getTH2("barrelSectorIDRoiEta");
+ TH2F_LW *endcapSectorIDRoiEta = getTH2("endcapSectorIDRoiEta");
+ TH2F_LW *forwardSectorIDRoiEta = getTH2("forwardSectorIDRoiEta");
+ TH2F_LW *barrelSectorIDRoiPhi = getTH2("barrelSectorIDRoiPhi");
+ TH2F_LW *endcapSectorIDRoiPhi = getTH2("endcapSectorIDRoiPhi");
+ TH2F_LW *forwardSectorIDRoiPhi = getTH2("forwardSectorIDRoiPhi");
if ( !roiEtaPhi || !barrelSectorIDRoi || !endcapSectorIDRoi || !forwardSectorIDRoi ||
!barrelSectorIDRoiEta || !endcapSectorIDRoiEta || !forwardSectorIDRoiEta ||
!barrelSectorIDRoiPhi || !endcapSectorIDRoiPhi || !forwardSectorIDRoiPhi ) {
- ATH_MSG(FATAL) << "Problems finding 2D histograms for RoI!" << endmsg;
+ ATH_MSG_FATAL("Problems finding 2D histograms for RoI!");
return;
}
- const std::vector<ROIB::MuCTPIRoI> roiVec = roib->muCTPIResult().roIVec();
-
- int bcidMismatch = 0;
- uint16_t bcId;
- uint16_t pTval;
- uint16_t pTnum;
- double eta;
- double phi;
- uint16_t secID;
- uint16_t sysID;
- uint16_t hemisphere;
- uint16_t roInum;
- bool accepted;
- bool first;
- bool duplicatedRoI;
- bool duplicatedSector;
- int candNum=0;
+ const std::vector<ROIB::MuCTPIRoI> roiVec = roib->muCTPIResult().roIVec();
+ int bcidMismatch = 0;
+ uint16_t bcId;
+ uint16_t pTval;
+ uint16_t pTnum;
+ double eta;
+ double phi;
+ uint16_t secID;
+ uint16_t sysID;
+ uint16_t hemisphere;
+ uint16_t roInum;
+ bool accepted;
+ bool first;
+ bool duplicatedRoI;
+ bool duplicatedSector;
+ int candNum=0;
if (theMuCTPI_RIO) {
for ( int i = 0; i < theMuCTPI_RIO->getNRoI(); i++ ) {
if (!theMuCTPI_RIO->getRoI(i, bcId, pTval, pTnum, eta, phi, secID, sysID, hemisphere,
- roInum, accepted, first, duplicatedRoI, duplicatedSector)) {
- ATH_MSG(WARNING) << "RoI with index " << i << " not found, skipping this RoI" << endmsg;
- continue;
+ roInum, accepted, first, duplicatedRoI, duplicatedSector)) {
+ ATH_MSG_WARNING( "RoI with index " << i << " not found, skipping this RoI");
+ continue;
+ }
+ roiEtaPhi->Fill(eta, phi);
+ roiEta->Fill(eta);
+ roiPhi->Fill(phi);
+ if (theMuCTPI_RIO->getBCID() != bcId) bcidMismatch++;
}
- roiEtaPhi->Fill(eta, phi);
- roiEta->Fill(eta);
- roiPhi->Fill(phi);
- if (theMuCTPI_RIO->getBCID() != bcId) bcidMismatch++;
- }
for ( unsigned int j = 0; j < roiVec.size(); j++ ) {
bool isCand = false;
for ( int i = 0; i < theMuCTPI_RIO->getNRoI(); i++ ) {
- theMuCTPI_RIO->getRoI(i, bcId, pTval, pTnum, eta, phi, secID, sysID, hemisphere,
- roInum, accepted, first, duplicatedRoI, duplicatedSector);
- if ((roiVec[j].getRoiNumber() == roInum) &&
- (roiVec[j].pt() == pTnum) &&
- (roiVec[j].getSectorID() == secID) &&
- (roiVec[j].getSectorLocation() == sysID) &&
- (roiVec[j].getHemisphere() == hemisphere) &&
- (theMuCTPI_RIO->getBCID() == bcId)) {
- isCand=true;
- candNum=i;
- }
+ theMuCTPI_RIO->getRoI(i, bcId, pTval, pTnum, eta, phi, secID, sysID, hemisphere,
+ roInum, accepted, first, duplicatedRoI, duplicatedSector);
+ if ((roiVec[j].getRoiNumber() == roInum) &&
+ (roiVec[j].pt() == pTnum) &&
+ (roiVec[j].getSectorID() == secID) &&
+ (roiVec[j].getSectorLocation() == sysID) &&
+ (roiVec[j].getHemisphere() == hemisphere) &&
+ (theMuCTPI_RIO->getBCID() == bcId)) {
+ isCand=true;
+ candNum=i;
+ }
+ }
+ if (isCand == false) {
+ ATH_MSG_WARNING( "No DAQ muon for RoI number "
+ << roiVec[j].getRoiNumber() << ", pT " << roiVec[j].pt() << ", and sector ID "
+ << roiVec[j].getSectorID());
+ errorSummary->Fill(7,1);
+ errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 7);
+ errorPerLumiBlock->Fill(m_currentLumiBlock);
+ }
+ else {
+ errorSummary->Fill(7,0);
+ theMuCTPI_RIO->getRoI(candNum, bcId, pTval, pTnum, eta, phi, secID, sysID, hemisphere,
+ roInum, accepted, first, duplicatedRoI, duplicatedSector);
+ if (theMuCTPI_RDO) {// go back to data words to check sector locations
+ MuCTPI_DataWord_Decoder dataWord(0);
+ const std::vector<uint32_t> &vDataWords = theMuCTPI_RDO->dataWord();
+ for ( std::vector<uint32_t>::const_iterator it = vDataWords.begin(); it != vDataWords.end(); ++it ) {
+ dataWord.setWord(*it);
+
+ // MuCTPI_DataWord_Decoder only corrects sector ID for hemisphere if candidate is barrel
+ // correct back for this by providing an argument to getSectorID
+ uint16_t sectorID = dataWord.getSectorID();
+ if (dataWord.getSectorLocation() == MuCTPI_RDO::BARREL)
+ sectorID=dataWord.getSectorID(1);
+
+ if (//(dataWord.getBCID() == theMuCTPI_RIO->getBCID())
+ //&&
+ (sectorID == secID)
+ && (dataWord.getRoiNumber() == roInum)
+ && (dataWord.getSectorLocation() == sysID)
+ && (dataWord.getHemisphere() == hemisphere)) {
+
+ nCandidates_secLoc->Fill(dataWord.getSectorLocation());
+
+ if (dataWord.getSectorLocation() == MuCTPI_RDO::BARREL) {
+ barrelSectorIDRoi->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), roInum);
+ barrelSectorIDRoiEta->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), eta);
+ barrelSectorIDRoiPhi->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), phi);
+ }
+ else if (dataWord.getSectorLocation() == MuCTPI_RDO::ENDCAP) {
+ endcapSectorIDRoi->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), roInum);
+ endcapSectorIDRoiEta->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), eta);
+ endcapSectorIDRoiPhi->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), phi);
+ }
+ else if (dataWord.getSectorLocation() == MuCTPI_RDO::FORWARD) {
+ forwardSectorIDRoi->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), roInum);
+ forwardSectorIDRoiEta->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), eta);
+ forwardSectorIDRoiPhi->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), phi);
+ }
+ }
}
- if (isCand == false) {
- ATH_MSG(WARNING) << "No DAQ muon for RoI number "
- << roiVec[j].getRoiNumber() << ", pT " << roiVec[j].pt() << ", and sector ID "
- << roiVec[j].getSectorID() << endmsg;
- errorSummary->Fill(7,1);
- errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 7);
- errorPerLumiBlock->Fill(m_currentLumiBlock);
}
- else {
- errorSummary->Fill(7,0);
- theMuCTPI_RIO->getRoI(candNum, bcId, pTval, pTnum, eta, phi, secID, sysID, hemisphere,
- roInum, accepted, first, duplicatedRoI, duplicatedSector);
- if (theMuCTPI_RDO) {// go back to data words to check sector locations
- MuCTPI_DataWord_Decoder dataWord(0);
- const std::vector<uint32_t> &vDataWords = theMuCTPI_RDO->dataWord();
- for ( std::vector<uint32_t>::const_iterator it = vDataWords.begin(); it != vDataWords.end(); ++it ) {
- dataWord.setWord(*it);
-
- // MuCTPI_DataWord_Decoder only corrects sector ID for hemisphere if candidate is barrel
- // correct back for this by providing an argument to getSectorID
- uint16_t sectorID = dataWord.getSectorID();
- if (dataWord.getSectorLocation() == MuCTPI_RDO::BARREL)
- sectorID=dataWord.getSectorID(1);
-
- if (//(dataWord.getBCID() == theMuCTPI_RIO->getBCID())
- //&&
- (sectorID == secID)
- && (dataWord.getRoiNumber() == roInum)
- && (dataWord.getSectorLocation() == sysID)
- && (dataWord.getHemisphere() == hemisphere)) {
-
- nCandidates_secLoc->Fill(dataWord.getSectorLocation());
-
- if (dataWord.getSectorLocation() == MuCTPI_RDO::BARREL) {
- barrelSectorIDRoi->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), roInum);
- barrelSectorIDRoiEta->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), eta);
- barrelSectorIDRoiPhi->Fill(dataWord.getSectorID(1)+32*dataWord.getHemisphere(), phi);
- }
- else if (dataWord.getSectorLocation() == MuCTPI_RDO::ENDCAP) {
- endcapSectorIDRoi->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), roInum);
- endcapSectorIDRoiEta->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), eta);
- endcapSectorIDRoiPhi->Fill(dataWord.getSectorID()+48*dataWord.getHemisphere(), phi);
- }
- else if (dataWord.getSectorLocation() == MuCTPI_RDO::FORWARD) {
- forwardSectorIDRoi->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), roInum);
- forwardSectorIDRoiEta->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), eta);
- forwardSectorIDRoiPhi->Fill(dataWord.getSectorID()+24*dataWord.getHemisphere(), phi);
- }
- }
- }
- }
+ }
}
- }
- int lvl2Expected = static_cast<int>(theMuCTPI_RIO->getNRoI()) - bcidMismatch;
- if (lvl2Expected != static_cast<int>(roiVec.size()) && lvl2Expected <= 14) {
- ATH_MSG(WARNING) << "Expected " << lvl2Expected
- << " LVL2 RoIs, but found " << roiVec.size()
- << "!" << endmsg;
- errorSummary->Fill(6,1);
- errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 6);
- errorPerLumiBlock->Fill(m_currentLumiBlock);
- }
- else if (static_cast<int>(roiVec.size()) != 14 && lvl2Expected >= 14) {
- ATH_MSG(WARNING) << "Expected 14 RoI's from " << lvl2Expected
- << " MuCTPI RoI's, but found " << roiVec.size()
- << "!" << endmsg;
- errorSummary->Fill(6,1);
- errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 6);
- errorPerLumiBlock->Fill(m_currentLumiBlock);
- }
- else errorSummary->Fill(6,0);
- }
+ int lvl2Expected = static_cast<int>(theMuCTPI_RIO->getNRoI()) - bcidMismatch;
+ if (lvl2Expected != static_cast<int>(roiVec.size()) && lvl2Expected <= 14) {
+ ATH_MSG_WARNING( "Expected " << lvl2Expected
+ << " LVL2 RoIs, but found " << roiVec.size()
+ << "!");
+ errorSummary->Fill(6,1);
+ errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 6);
+ errorPerLumiBlock->Fill(m_currentLumiBlock);
+ }
+ else if (static_cast<int>(roiVec.size()) != 14 && lvl2Expected >= 14) {
+ ATH_MSG_WARNING( "Expected 14 RoI's from " << lvl2Expected
+ << " MuCTPI RoI's, but found " << roiVec.size()
+ << "!");
+ errorSummary->Fill(6,1);
+ errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 6);
+ errorPerLumiBlock->Fill(m_currentLumiBlock);
+ }
+ else errorSummary->Fill(6,0);
+ }
}
-StatusCode TrigT1CTMonitoring::BSMonitoring::compareRerun(const CTP_BC &bunchCrossing) {
-
- int Mismatch=0;
-
- TProfile_LW *errorSummary = getTProfile("errorSummary");
- TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
- TH1F_LW *errorPerLumiBlock = getTH1("errorPerLumiBlock");
- TH1F_LW* l1ItemsBPSimMismatch = getTH1("l1ItemsBPSimMismatch");
- TH1F_LW* l1ItemsBPSimMismatchItems = getTH1("l1ItemsBPSimMismatchItems");
-
- const CTP_RDO* theCTP_RDO_Rerun = 0;
- ATH_MSG(DEBUG) << "Retrieving CTP_RDO from SG with key CTP_RDO_Rerun" << endmsg;
- CHECK( evtStore()->retrieve(theCTP_RDO_Rerun, "CTP_RDO_Rerun") );
-
- CTP_Decoder ctp_rerun;
- ctp_rerun.setRDO(theCTP_RDO_Rerun);
-
- const std::vector<CTP_BC> ctp_bc_rerun=ctp_rerun.getBunchCrossings();
- if (ctp_bc_rerun.size() != 1) {
- ATH_MSG(ERROR) << "Rerun simulation has non unity number of bunch crossings " << endmsg;
- return StatusCode::FAILURE;
- }
-
-
- ATH_MSG(DEBUG) << "In compareRerun: dumping data for BC " << bunchCrossing.getBCID() << endmsg;
- bunchCrossing.dumpData(msg());
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::compareRerun(const CTP_BC &bunchCrossing)
+{
+ bool itemMismatch{false};
- ATH_MSG(DEBUG) << "In compareRerun: dumping rerun data for BC 0" << endmsg;
- ctp_bc_rerun.at(0).dumpData(msg());
-
- ATH_MSG(DEBUG) << "Comparing TBP from CTP_RDO objects with keys CTP_RDO (from data) and CTP_RDO_Rerun (from simulation)" << endmsg;
-
- const std::bitset<512> currentTBP(bunchCrossing.getTBP());
- const std::bitset<512> currentTBP_rerun(ctp_bc_rerun.at(0).getTBP());
-
- if ( currentTBP != currentTBP_rerun ) {
- for ( TrigConf::TriggerItem* item: m_configSvc->ctpConfig()->menu().items() ) {
+ TProfile_LW *errorSummary = getTProfile("errorSummary");
+ TH2F_LW* errorSummaryPerLumiBlock = getTH2("errorSummaryPerLumiBlock");
+ TH1F_LW *errorPerLumiBlock = getTH1("errorPerLumiBlock");
+ TH1F_LW* l1ItemsBPSimMismatch = getTH1("l1ItemsBPSimMismatch");
+ TH1F_LW* l1ItemsBPSimMismatchItems = getTH1("l1ItemsBPSimMismatchItems");
+
+ const CTP_RDO* theCTP_RDO_Rerun = 0;
+ ATH_MSG_DEBUG( "Retrieving CTP_RDO from SG with key CTP_RDO_Rerun");
+ CHECK( evtStore()->retrieve(theCTP_RDO_Rerun, "CTP_RDO_Rerun") );
+
+ CTP_Decoder ctp_rerun;
+ ctp_rerun.setRDO(theCTP_RDO_Rerun);
+
+ const std::vector<CTP_BC> ctp_bc_rerun=ctp_rerun.getBunchCrossings();
+ if (ctp_bc_rerun.size() != 1) {
+ ATH_MSG_ERROR( "Rerun simulation has non unity number of bunch crossings ");
+ return StatusCode::FAILURE;
+ }
- std::vector<unsigned int> randoms;
- item->topNode()->getAllRandomTriggers(randoms);
-
- //do not include random and non-simulated triggers in this test, so skip those
- bool skip = randoms.size()>0 || item->name().find("L1_TRT") != string::npos || item->name().find("L1_ZB") != string::npos || item->name().find("_AFP") != string::npos;
-
- if( skip ) continue;
-
- bool tbp = currentTBP.test( item->ctpId() );
- bool tbp_rerun = currentTBP_rerun.test( item->ctpId() );
- if ( tbp != tbp_rerun) {
- ATH_MSG(WARNING) << "CTPSimulation TBP / TPB_rerun mismatch!! For L1Item '" << item->name() << "' (CTP ID " << item->ctpId() << "): data="
- << (tbp?"pass":"fail") << " != simulation=" << (tbp_rerun?"pass":"fail") << endmsg;
- Mismatch=1;
- l1ItemsBPSimMismatch->Fill(item->ctpId(),1);
- l1ItemsBPSimMismatchItems->getROOTHist()->Fill( (item->name()).c_str(), 1 );
+ ATH_MSG_DEBUG( "In compareRerun: dumping data for BC " << bunchCrossing.getBCID());
+ bunchCrossing.dumpData(msg());
+
+ ATH_MSG_DEBUG( "In compareRerun: dumping rerun data for BC 0");
+ ctp_bc_rerun.at(0).dumpData(msg());
+
+ ATH_MSG_DEBUG( "Comparing TBP from CTP_RDO objects with keys CTP_RDO (from data) and CTP_RDO_Rerun (from simulation)");
+
+ const std::bitset<512> currentTBP(bunchCrossing.getTBP());
+ const std::bitset<512> currentTBP_rerun(ctp_bc_rerun.at(0).getTBP());
+
+ if ( currentTBP != currentTBP_rerun ) {
+ if(m_useNewConfig) {
+ const TrigConf::L1Menu * l1menu = nullptr;
+ ATH_CHECK(detStore()->retrieve(l1menu));
+ for(const TrigConf::L1Item & item : *l1menu) {
+
+ //do not include random and non-simulated triggers in this test (can be configured)
+ bool skip = item.definition().find("RNDM") != string::npos;
+ for(const std::string & p : m_ignorePatterns) {
+ if(item.name().find(p) != string::npos) {
+ skip = true;
+ break;
+ }
+ }
+ if( skip ) continue;
+
+ bool tbp = currentTBP.test( item.ctpId() );
+ bool tbp_rerun = currentTBP_rerun.test( item.ctpId() );
+ if ( tbp != tbp_rerun) {
+ ATH_MSG_WARNING( "CTPSimulation TBP / TPB_rerun mismatch!! For L1Item '" << item.name()
+ << "' (CTP ID " << item.ctpId() << "): data="
+ << (tbp?"pass":"fail") << " != simulation=" << (tbp_rerun?"pass":"fail"));
+ itemMismatch=true;
+ l1ItemsBPSimMismatch->Fill(item.ctpId(),1);
+ l1ItemsBPSimMismatchItems->getROOTHist()->Fill( (item.name()).c_str(), 1 );
+ }
+ }
+ } else {
+ for ( TrigConf::TriggerItem* item: m_configSvc->ctpConfig()->menu().items() ) {
+ std::vector<unsigned int> randoms;
+ item->topNode()->getAllRandomTriggers(randoms);
+
+ //do not include random and non-simulated triggers in this test (can be configured)
+ bool skip = randoms.size()>0;
+ for(const std::string & p : m_ignorePatterns) {
+ if(item->name().find(p) != string::npos) {
+ skip = true;
+ break;
+ }
+ }
+ if( skip ) continue;
+
+ bool tbp = currentTBP.test( item->ctpId() );
+ bool tbp_rerun = currentTBP_rerun.test( item->ctpId() );
+ if ( tbp != tbp_rerun) {
+ ATH_MSG_WARNING( "CTPSimulation TBP / TPB_rerun mismatch!! For L1Item '" << item->name()
+ << "' (CTP ID " << item->ctpId() << "): data="
+ << (tbp?"pass":"fail") << " != simulation=" << (tbp_rerun?"pass":"fail"));
+ itemMismatch=true;
+ l1ItemsBPSimMismatch->Fill(item->ctpId(),1);
+ l1ItemsBPSimMismatchItems->getROOTHist()->Fill( (item->name()).c_str(), 1 );
+ }
+ }
}
- }
- }
+ }
- if (Mismatch) {
- ATH_MSG(WARNING) << "Mismatch between CTP data and simulation" << endmsg;
- errorSummary->Fill(14,1);
- errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 14);
- errorPerLumiBlock->Fill(m_currentLumiBlock);
- }
- else errorSummary->Fill(14,0);
- return StatusCode::SUCCESS;
+ if (itemMismatch) {
+ ATH_MSG_WARNING( "Mismatch between CTP data and simulation in BC " << bunchCrossing.getBCID());
+ errorSummary->Fill(14,1);
+ errorSummaryPerLumiBlock->Fill(m_currentLumiBlock, 14);
+ errorPerLumiBlock->Fill(m_currentLumiBlock);
+ } else {
+ errorSummary->Fill(14,0);
+ }
+ return StatusCode::SUCCESS;
}
-void TrigT1CTMonitoring::BSMonitoring::
-dumpData(const DataHandle<CTP_RDO> theCTP_RDO,
- const DataHandle<CTP_RIO> theCTP_RIO,
- const DataHandle<MuCTPI_RDO> theMuCTPI_RDO,
- const DataHandle<MuCTPI_RIO> theMuCTPI_RIO,
- const DataHandle<ROIB::RoIBResult> roib) {
-
- if ( !msgLvl(MSG::DEBUG) )
- return;
+void
+TrigT1CTMonitoring::BSMonitoring::dumpData( const DataHandle<CTP_RDO> theCTP_RDO, const DataHandle<CTP_RIO> theCTP_RIO,
+ const DataHandle<MuCTPI_RDO> theMuCTPI_RDO, const DataHandle<MuCTPI_RIO> theMuCTPI_RIO,
+ const DataHandle<ROIB::RoIBResult> roib)
+{
+ if ( !msgLvl(MSG::DEBUG) )
+ return;
if ( m_processMuctpi ) {
// MuCTPI Multiplicity data
MuCTPI_MultiplicityWord_Decoder multWord(theMuCTPI_RDO->
@@ -1846,12 +1787,12 @@ dumpData(const DataHandle<CTP_RDO> theCTP_RDO,
multWord.dumpData();
// MuCTPI candidate data
MuCTPI_DataWord_Decoder dataWord(0);
- ATH_MSG(DEBUG) << "MIOCT candidate data :" << endmsg;
+ ATH_MSG_DEBUG( "MIOCT candidate data :");
std::vector<uint32_t>::const_iterator it =
theMuCTPI_RDO->dataWord().begin();
int count = 1;
for ( ; it != theMuCTPI_RDO->dataWord().end(); ++it ) {
- ATH_MSG(DEBUG) << "Candidate " << count << endmsg;
+ ATH_MSG_DEBUG( "Candidate " << count);
dataWord.setWord(*it);
dataWord.dumpData();
++count;
@@ -1877,11 +1818,12 @@ dumpData(const DataHandle<CTP_RDO> theCTP_RDO,
}
//------------
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-registerTH1(const std::string& histName, const std::string& histTitle, int nbins, float minX, float maxX) {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::registerTH1(const std::string& histName, const std::string& histTitle, int nbins, float minX, float maxX)
+{
HistMap_t::iterator it = m_histNames.find(histName);
if (it != m_histNames.end()) {
- ATH_MSG(ERROR) << "Histogram " << histName << " already registered" << endmsg;
+ ATH_MSG_ERROR( "Histogram " << histName << " already registered");
return StatusCode::FAILURE;
}
TH1F_LW *hist = TH1F_LW::create(histName.c_str(), histTitle.c_str(), nbins, minX, maxX);
@@ -1890,12 +1832,12 @@ registerTH1(const std::string& histName, const std::string& histTitle, int nbins
}
//------------
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-registerTProfile(const std::string& histName, const std::string& histTitle, int nbins,
- float minX, float maxX, float minY, float maxY) {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::registerTProfile(const std::string& histName, const std::string& histTitle, int nbins, float minX, float maxX, float minY, float maxY)
+{
HistMap_t::iterator it = m_histNames.find(histName);
if (it != m_histNames.end()) {
- ATH_MSG(ERROR) << "Histogram " << histName << " already registered" << endmsg;
+ ATH_MSG_ERROR( "Histogram " << histName << " already registered");
return StatusCode::FAILURE;
}
TProfile_LW *hist = TProfile_LW::create(histName.c_str(), histTitle.c_str(), nbins, minX, maxX, minY, maxY);
@@ -1904,12 +1846,13 @@ registerTProfile(const std::string& histName, const std::string& histTitle, int
}
//------------
-StatusCode TrigT1CTMonitoring::BSMonitoring::
-registerTH2(const std::string& histName, const std::string& histTitle, int nbinsX,
- float minX, float maxX, int nbinsY, float minY, float maxY) {
+StatusCode
+TrigT1CTMonitoring::BSMonitoring::registerTH2( const std::string& histName, const std::string& histTitle, int nbinsX,
+ float minX, float maxX, int nbinsY, float minY, float maxY)
+{
HistMap_t::iterator it = m_histNames.find(histName);
if (it != m_histNames.end()) {
- ATH_MSG(ERROR) << "Histogram " << histName << " already registered" << endmsg;
+ ATH_MSG_ERROR( "Histogram " << histName << " already registered");
return StatusCode::FAILURE;
}
TH2F_LW *hist = TH2F_LW::create(histName.c_str(), histTitle.c_str(), nbinsX, minX, maxX, nbinsY, minY, maxY);
@@ -1918,63 +1861,67 @@ registerTH2(const std::string& histName, const std::string& histTitle, int nbins
}
//------------
-TH1F_LW *TrigT1CTMonitoring::BSMonitoring::
-getTH1(const char* histLabel) {
+TH1F_LW *
+TrigT1CTMonitoring::BSMonitoring::getTH1(const char* histLabel)
+{
m_tmpstr = histLabel;
HistMap_t::iterator it = m_histNames.find(m_tmpstr);
if (it == m_histNames.end()) {
- ATH_MSG(ERROR) << "Histogram under " << histLabel << " not found " << endmsg;
+ ATH_MSG_ERROR( "Histogram under " << histLabel << " not found ");
return 0;
}
TH1F_LW* h = dynamic_cast<TH1F_LW*>(it->second);
if (!h)
- ATH_MSG(ERROR) << "Problems converting histogram " << histLabel << " to TH1F_LW " << endmsg;
+ ATH_MSG_ERROR( "Problems converting histogram " << histLabel << " to TH1F_LW ");
return h;
}
//------------
-TH2F_LW *TrigT1CTMonitoring::BSMonitoring::
-getTH2(const char* histLabel) {
+TH2F_LW *
+TrigT1CTMonitoring::BSMonitoring::getTH2(const char* histLabel)
+{
m_tmpstr = histLabel;
HistMap_t::iterator it = m_histNames.find(m_tmpstr);
if (it == m_histNames.end()) {
- ATH_MSG(ERROR) << "Histogram under " << histLabel << " not found " << endmsg;
+ ATH_MSG_ERROR( "Histogram under " << histLabel << " not found ");
return 0;
}
TH2F_LW* h = dynamic_cast<TH2F_LW*>(it->second);
if (!h)
- ATH_MSG(ERROR) << "Problems converting histogram " << histLabel << " to TH2F_LW " << endmsg;
+ ATH_MSG_ERROR( "Problems converting histogram " << histLabel << " to TH2F_LW ");
return h;
}
//------------
-TProfile_LW *TrigT1CTMonitoring::BSMonitoring::
-getTProfile(const char* histLabel) {
+TProfile_LW *
+TrigT1CTMonitoring::BSMonitoring::getTProfile(const char* histLabel)
+{
m_tmpstr = histLabel;
HistMap_t::iterator it = m_histNames.find(m_tmpstr);
if (it == m_histNames.end()) {
- ATH_MSG(ERROR) << "Histogram under " << histLabel << " not found " << endmsg;
+ ATH_MSG_ERROR( "Histogram under " << histLabel << " not found ");
return 0;
}
TProfile_LW* h = dynamic_cast<TProfile_LW*>(it->second);
if (!h)
- ATH_MSG(ERROR) << "Problems converting histogram " << histLabel << " to TProfile_LW " << endmsg;
+ ATH_MSG_ERROR( "Problems converting histogram " << histLabel << " to TProfile_LW ");
return h;
}
//------------
-void TrigT1CTMonitoring::BSMonitoring::
-getCoolData(unsigned int runNumber) {
+void
+TrigT1CTMonitoring::BSMonitoring::getCoolData(unsigned int runNumber)
+{
// establish a connection to COOLONL_TRIGGER
CoraCoolDatabaseSvc& corasvc = CoraCoolDatabaseSvcFactory::databaseService();
CoraCoolDatabasePtr coradb;
try {
coradb = corasvc.openDatabase("COOLONL_TRIGGER/CONDBR2",true);
- ATH_MSG(DEBUG) << "Database connection open OK" << endmsg;
+ ATH_MSG_DEBUG( "Database connection open OK");
}
catch (std::exception& e) {
- ATH_MSG(WARNING) << "Problem opening CORAL database:" << e.what() << endmsg;
+ ATH_MSG_WARNING( "Problem opening CORAL database:" << e.what());
}
// get DB pointer
@@ -1984,7 +1931,7 @@ getCoolData(unsigned int runNumber) {
//cool::IDatabasePtr cooldb = coradb->coolDatabase();
//const std::vector<std::string>& folders = cooldb->listAllNodes();
//for ( std::vector<std::string>::const_iterator itr = folders.begin(); itr != folders.end(); ++itr )
- // ATH_MSG(DEBUG) << *itr << endmsg;
+ // ATH_MSG_DEBUG( *itr);
cool::ValidityKey since(runNumber);
cool::ValidityKey until(since+1);
@@ -1998,24 +1945,21 @@ getCoolData(unsigned int runNumber) {
cool::IFolderPtr lbTimeFolder;
try {
- ATH_MSG(DEBUG) << "Will now try to retrieve LB times in folder " << m_lbTimeCoolFolderName << endmsg;
+ ATH_MSG_DEBUG( "Will now try to retrieve LB times in folder " << m_lbTimeCoolFolderName);
lbTimeFolder = cooldb->getFolder(m_lbTimeCoolFolderName);
}
catch (cool::Exception& e) {
- ATH_MSG(WARNING) << "Exception during cool:IDatabasePtr::getFolder(): " << e.what() << endmsg;
+ ATH_MSG_WARNING( "Exception during cool:IDatabasePtr::getFolder(): " << e.what());
return;
}
// printout specification of folder
//const cool::IRecordSpecification& spec = lbTimeFolder->payloadSpecification();
//for ( unsigned int i = 0; i < spec.size(); ++i ) {
- // ATH_MSG(WARNING) << "Payload column: " << spec[i].name() << " type: " <<
- // spec[i].storageType().name() << endmsg;
+ // ATH_MSG_WARNING( "Payload column: " << spec[i].name() << " type: " <<
+ // spec[i].storageType().name());
//}
- uint64_t stime = 0;
- uint64_t etime = 1;
-
cool::IObjectIteratorPtr lbTimeObjects = lbTimeFolder->browseObjects( since, until, 0 );
if ( lbTimeObjects->size() != 0 ) {
while ( lbTimeObjects->goToNext() ) {
@@ -2025,17 +1969,17 @@ getCoolData(unsigned int runNumber) {
uint32_t startLumiBlock = (obj.since() & 0xffffffff);
uint32_t endRun = (obj.until() >> 32) & 0x7fffffff; // same here
uint32_t endLumiBlock = (obj.until() & 0xffffffff);
- ATH_MSG(DEBUG) << "LB " << " since: run = " << startRun << ", LB = " << startLumiBlock << ", "
- << " until: run = " << endRun << ", LB = " << endLumiBlock << ")" << payload << endmsg;
- stime = payload["StartTime"].data<uint64_t>();
- etime=payload["EndTime"].data<uint64_t>();
+ ATH_MSG_DEBUG( "LB " << " since: run = " << startRun << ", LB = " << startLumiBlock << ", "
+ << " until: run = " << endRun << ", LB = " << endLumiBlock << ")" << payload);
+ auto stime = static_cast<uint64_t>(payload["StartTime"].data<cool::UInt63>());
+ auto etime = static_cast<uint64_t>(payload["EndTime"].data<cool::UInt63>());
m_lumiBlocks.push_back(startLumiBlock);
m_lbStartTimes[startLumiBlock] = stime;
m_lbEndTimes[startLumiBlock] = etime;
}
}
else {
- ATH_MSG(DEBUG) << "No lumi block start and stop times found in COOL for this run!" << endmsg;
+ ATH_MSG_DEBUG( "No lumi block start and stop times found in COOL for this run!");
}
//--------------------------------//
@@ -2047,7 +1991,7 @@ getCoolData(unsigned int runNumber) {
freqMeasFolder = cooldb->getFolder(m_rfPhaseCoolFolderName);
}
catch (cool::Exception& e) {
- ATH_MSG(WARNING) << "Exception caught when retrieving LHC timing signal info from COOL: " << e.what() << endmsg;
+ ATH_MSG_WARNING( "Exception caught when retrieving LHC timing signal info from COOL: " << e.what());
}
double frequency = 0;
@@ -2057,16 +2001,16 @@ getCoolData(unsigned int runNumber) {
if ( freqMeasObjects->size() != 0 ) {
while ( freqMeasObjects->goToNext() ) {
const cool::IObject& obj = freqMeasObjects->currentRef();
- //ATH_MSG(WARNING) << obj << endmsg;
+ //ATH_MSG_WARNING( obj);
const cool::IRecord& payload = obj.payload();
startTime = payload["StartTimeSeconds"].data<uint32_t>()*1e9+payload["StartTimeNanoSeconds"].data<uint32_t>();
frequency = payload["FreqBCctp"].data<double>();
- ATH_MSG(DEBUG) << "StartTime: " << startTime << " ns, FreqBCctp: " << frequency << " Hz" << endmsg;
+ ATH_MSG_DEBUG( "StartTime: " << startTime << " ns, FreqBCctp: " << frequency << " Hz");
m_freqMeasurements[startTime] = frequency;
}
}
else {
- ATH_MSG(DEBUG) << "No frequency measurements found in COOL for this run!" << endmsg;
+ ATH_MSG_DEBUG( "No frequency measurements found in COOL for this run!");
}
// now fill the measured frequencies closest to the start of each LB
@@ -2074,7 +2018,7 @@ getCoolData(unsigned int runNumber) {
lbIt != m_lumiBlocks.end(); ++lbIt ) {
double freq = getFrequencyMeasurement(m_lbStartTimes[*lbIt]);
m_lbStartFreqMeasurements[*lbIt] = freq;
- ATH_MSG(DEBUG) << "Frequency for LB " << *lbIt << " (start time: " << m_lbStartTimes[*lbIt] << "): " << freq << " Hz" << endmsg;
+ ATH_MSG_DEBUG( "Frequency for LB " << *lbIt << " (start time: " << m_lbStartTimes[*lbIt] << "): " << freq << " Hz");
}
//-------------------------------//
@@ -2084,21 +2028,21 @@ getCoolData(unsigned int runNumber) {
// establish a connection to COOLOFL_DCS
try {
coradb = corasvc.openDatabase("COOLOFL_DCS/CONDBR2",true);
- ATH_MSG(DEBUG) << "Database connection open OK" << endmsg;
+ ATH_MSG_DEBUG( "Database connection open OK");
}
catch (std::exception& e) {
- ATH_MSG(WARNING) << "Problem opening CORAL database:" << e.what() << endmsg;
+ ATH_MSG_WARNING( "Problem opening CORAL database:" << e.what());
}
// get DB pointer
cool::IDatabasePtr cooldb2 = coradb->coolDatabase();
if(m_fillStateCoolFolderName!="Unavailable"){
cool::IFolderPtr fillStateFolder;
try {
- ATH_MSG(DEBUG) << "Will now try to retrieve LHC fill state info in folder " << m_fillStateCoolFolderName << endmsg;
+ ATH_MSG_DEBUG( "Will now try to retrieve LHC fill state info in folder " << m_fillStateCoolFolderName);
fillStateFolder = cooldb2->getFolder(m_fillStateCoolFolderName);
}
catch (cool::Exception& e) {
- ATH_MSG(WARNING) << "Exception from cool::IDatabasePtr::getFolder(): " << e.what() << endmsg;
+ ATH_MSG_WARNING( "Exception from cool::IDatabasePtr::getFolder(): " << e.what());
return;
}
@@ -2116,8 +2060,8 @@ getCoolData(unsigned int runNumber) {
currentBeamMode = payload["BeamMode"].data<cool::String4k>();
startTime = obj.since();
endTime = obj.until();
- ATH_MSG(DEBUG) << "BEAM MODE: " << currentBeamMode << ", start time: "
- << startTime << ", stop time: " << endTime << endmsg;
+ ATH_MSG_DEBUG( "BEAM MODE: " << currentBeamMode << ", start time: "
+ << startTime << ", stop time: " << endTime);
// fill the beam mode map, cases ordered by how often they appear
if (!strcmp(currentBeamMode.c_str(), "RAMP"))
@@ -2160,8 +2104,8 @@ getCoolData(unsigned int runNumber) {
m_beamMode[startTime] = NOBEAM;
else {
m_beamMode[startTime] = UNKNOWN;
- ATH_MSG(WARNING) << "Unknown LHC beam mode read from COOL: " << payload["BeamMode"]
- << " (will treat as unstable)" << endmsg;
+ ATH_MSG_WARNING( "Unknown LHC beam mode read from COOL: " << payload["BeamMode"]
+ << " (will treat as unstable)");
}
// fill an entry with unknown after the validity of the last real entry is over
m_beamMode[endTime] = UNKNOWN;
@@ -2176,12 +2120,12 @@ getCoolData(unsigned int runNumber) {
while (bm != m_beamMode.end()) {
currentBeamMode = bm->second;
- ATH_MSG(DEBUG) << "Beam mode at time " << bm->first << ": " << currentBeamMode << endmsg;
+ ATH_MSG_DEBUG( "Beam mode at time " << bm->first << ": " << currentBeamMode);
if (currentBeamMode == previousBeamMode) {
previousbm = bm;
++bm;
m_beamMode.erase(previousbm);
- ATH_MSG(DEBUG) << " => Removing!" << endmsg;
+ ATH_MSG_DEBUG( " => Removing!");
}
else {
++bm;
@@ -2190,15 +2134,15 @@ getCoolData(unsigned int runNumber) {
}
}
else {
- ATH_MSG(DEBUG) << "No Beam Mode info found in COOL for this run!" << endmsg;
+ ATH_MSG_DEBUG( "No Beam Mode info found in COOL for this run!");
}
}
else{ //cool publication is not available
- ATH_MSG(DEBUG) << "No Beam Mode info found in COOL for this run as folder is unavailable!" << endmsg;
+ ATH_MSG_DEBUG( "No Beam Mode info found in COOL for this run as folder is unavailable!");
}
}
else{ //no lumi block available
- ATH_MSG(DEBUG) << "No lumi block available for this run!" << endmsg;
+ ATH_MSG_DEBUG( "No lumi block available for this run!");
}
//-----------------------------------------------//
@@ -2208,10 +2152,10 @@ getCoolData(unsigned int runNumber) {
// establish a connection to COOLOFL_DCS
try {
coradb = corasvc.openDatabase("COOLONL_TDAQ/CONDBR2",true);
- ATH_MSG(DEBUG) << "Database connection open OK" << endmsg;
+ ATH_MSG_DEBUG( "Database connection open OK");
}
catch (std::exception& e) {
- ATH_MSG(WARNING) << "Problem opening CORAL database:" << e.what() << endmsg;
+ ATH_MSG_WARNING( "Problem opening CORAL database:" << e.what());
}
// get DB pointer
cool::IDatabasePtr cooldb3 = coradb->coolDatabase();
@@ -2220,7 +2164,7 @@ getCoolData(unsigned int runNumber) {
dataTakingModeFolder = cooldb3->getFolder(m_dataTakingModeCoolFolderName);
}
catch (cool::Exception& e) {
- ATH_MSG(WARNING) << "Exception caught when retrieving ATLAS data taking mode info from COOL: " << e.what() << endmsg;
+ ATH_MSG_WARNING( "Exception caught when retrieving ATLAS data taking mode info from COOL: " << e.what());
}
uint32_t readyForPhysics = 0;
@@ -2233,24 +2177,24 @@ getCoolData(unsigned int runNumber) {
uint32_t startLumiBlock = (obj.since() & 0xffffffff);
uint32_t endRun = (obj.until() >> 32) & 0x7fffffff; // same here
uint32_t endLumiBlock = (obj.until() & 0xffffffff);
- ATH_MSG(DEBUG) << "Current entry "
+ ATH_MSG_DEBUG( "Current entry "
<< " since: run = " << startRun << ", LB = " << startLumiBlock << ", "
<< " until: run = " << endRun << ", LB = " << endLumiBlock << ")"
- << payload << endmsg;
+ << payload);
readyForPhysics = payload["ReadyForPhysics"].data<uint32_t>();
if (readyForPhysics == 0)
m_dataTakingMode[startLumiBlock] = false;
else {
m_dataTakingMode[startLumiBlock] = true;
if (readyForPhysics != 1) {
- ATH_MSG(WARNING) << "ReadyForPhysics is neither 0 nor 1, retrieved value was: "
- << readyForPhysics << " => will interpret as true" << endmsg;
+ ATH_MSG_WARNING( "ReadyForPhysics is neither 0 nor 1, retrieved value was: "
+ << readyForPhysics << " => will interpret as true");
}
}
}
}
else {
- ATH_MSG(DEBUG) << "No data taking mode info found in COOL for this run!" << endmsg;
+ ATH_MSG_DEBUG( "No data taking mode info found in COOL for this run!");
}
// now clean out all the entries that repeat the previous data taking mode and only keep the ones where it changes
@@ -2262,29 +2206,33 @@ getCoolData(unsigned int runNumber) {
while (dtm != m_dataTakingMode.end()) {
currentDataTakingMode = dtm->second;
- ATH_MSG(DEBUG) << "Data taking mode starting at LB " << dtm->first << ": " << currentDataTakingMode << endmsg;
+ ATH_MSG_DEBUG( "Data taking mode starting at LB " << dtm->first << ": " << currentDataTakingMode);
if (currentDataTakingMode == previousDataTakingMode && dtm != m_dataTakingMode.begin()) { // don't remove 1st
previousdtm = dtm;
++dtm;
m_dataTakingMode.erase(previousdtm);
- ATH_MSG(DEBUG) << " => Removing!" << endmsg;
+ ATH_MSG_DEBUG( " => Removing!");
}
else {
++dtm;
}
previousDataTakingMode = currentDataTakingMode;
}
-
+
return;
}
-std::string TrigT1CTMonitoring::BSMonitoring::getEventInfoString() {
+std::string
+TrigT1CTMonitoring::BSMonitoring::getEventInfoString()
+{
std::stringstream ss;
ss << "Run number: " << m_runNumber << ", event: " << m_eventNumber << ", LB: " << m_currentLumiBlock;
return std::string(ss.str());
}
-double TrigT1CTMonitoring::BSMonitoring::getFrequencyMeasurement(uint64_t eventTimeInNs) const {
+double
+TrigT1CTMonitoring::BSMonitoring::getFrequencyMeasurement(uint64_t eventTimeInNs) const
+{
if (m_freqMeasurements.size() == 0) {
return -1.0; // if there are no frequency measurements available for this run, return invalid frequency
}
@@ -2300,12 +2248,14 @@ double TrigT1CTMonitoring::BSMonitoring::getFrequencyMeasurement(uint64_t eventT
if ( freqMeasAfter != m_freqMeasurements.begin() && (fabs(eventTimeInNs - freqMeasBefore->first) < fabs(eventTimeInNs - freqMeasAfter->first)) )
fm = freqMeasBefore;
- ATH_MSG(DEBUG) << "Closest frequency measurement for time " << eventTimeInNs
- << "): " << fm->second << " Hz (at " << fm->first << ")" << endmsg;
+ ATH_MSG_DEBUG( "Closest frequency measurement for time " << eventTimeInNs
+ << "): " << fm->second << " Hz (at " << fm->first << ")");
return fm->second;
}
-TrigT1CTMonitoring::BeamMode TrigT1CTMonitoring::BSMonitoring::getBeamMode(uint64_t eventTimeInNs) const {
+TrigT1CTMonitoring::BeamMode
+TrigT1CTMonitoring::BSMonitoring::getBeamMode(uint64_t eventTimeInNs) const
+{
// get the pair for the first beam mode transition *after* the provided timestamp
std::map<uint64_t,BeamMode>::const_iterator bm = m_beamMode.lower_bound(eventTimeInNs);
BeamMode beamMode = UNKNOWN;
@@ -2313,6 +2263,6 @@ TrigT1CTMonitoring::BeamMode TrigT1CTMonitoring::BSMonitoring::getBeamMode(uint6
if ( bm != m_beamMode.begin() && bm != m_beamMode.end() ) {
beamMode = (--bm)->second;
}
- ATH_MSG(DEBUG) << "Beam mode at time " << eventTimeInNs << ": " << beamMode << endmsg;
+ ATH_MSG_DEBUG( "Beam mode at time " << eventTimeInNs << ": " << beamMode);
return beamMode;
}
diff --git a/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.h b/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.h
index 850741fe7d7f..72f219976460 100644
--- a/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.h
+++ b/Trigger/TrigT1/TrigT1CTMonitoring/src/BSMonitoring.h
@@ -28,6 +28,8 @@
#include "MuonRDO/RpcSectorLogicContainer.h"
#include "MuonDigitContainer/TgcDigit.h"
+#include "TrigConfInterfaces/ILVL1ConfigSvc.h"
+
class CTP_RDO;
class CTP_RIO;
class MuCTPI_RDO;
@@ -44,10 +46,6 @@ namespace cool {
class IHvsNode;
}
-namespace TrigConf {
- class ILVL1ConfigSvc;
-}
-
namespace ROIB {
class RoIBResult;
}
@@ -107,11 +105,6 @@ namespace TrigT1CTMonitoring {
const IInterface * parent);
private:
-
- ServiceHandle<TrigConf::ILVL1ConfigSvc> m_configSvc;
- ServiceHandle< LVL1::RecMuonRoiSvc > m_rpcRoiSvc; ///RPC rec. RoI service
- ServiceHandle< LVL1::RecMuonRoiSvc > m_tgcRoiSvc; ///TGC rec. RoI service
-
StatusCode initialize();
StatusCode bookHistograms();
StatusCode fillHistograms();
@@ -121,39 +114,44 @@ namespace TrigT1CTMonitoring {
StatusCode initCtpMuctpiHistograms();
StatusCode initRoIHistograms();
- StatusCode registerTH1(const std::string& histName, const std::string& histTitle,
- int nbins, float minX, float maxX);
+ StatusCode registerTH1( const std::string& histName, const std::string& histTitle,
+ int nbins, float minX, float maxX);
StatusCode registerTProfile(const std::string& histName,
- const std::string& histTitle, int nbins,
- float minX, float maxX, float minY,
- float maxY);
- StatusCode registerTH2(const std::string& histName, const std::string& histTitle,
- int nbinsX, float minX, float maxX,
- int nbinsY, float minY, float maxY);
+ const std::string& histTitle, int nbins,
+ float minX, float maxX, float minY,
+ float maxY);
+ StatusCode registerTH2( const std::string& histName, const std::string& histTitle,
+ int nbinsX, float minX, float maxX,
+ int nbinsY, float minY, float maxY);
TH1F_LW *getTH1(const char* histLabel);
TH2F_LW *getTH2(const char* histLabel);
TProfile_LW *getTProfile(const char* histLabel);
void getCoolData(unsigned int runNumber);
- void doMuonRoI(const DataHandle < MuCTPI_RDO > theMuCTPI_RDO,
- const DataHandle < MuCTPI_RIO > theMuCTPI_RIO,
- const DataHandle < ROIB::RoIBResult > roib);
- void doCtp(const DataHandle < CTP_RDO > theCTP_RDO,
- const DataHandle < CTP_RIO > theCTP_RIO);
+ void doMuonRoI( const DataHandle < MuCTPI_RDO > theMuCTPI_RDO,
+ const DataHandle < MuCTPI_RIO > theMuCTPI_RIO,
+ const DataHandle < ROIB::RoIBResult > roib);
+
+ void doCtp( const DataHandle < CTP_RDO > theCTP_RDO,
+ const DataHandle < CTP_RIO > theCTP_RIO);
+
void doMuctpi(const DataHandle < MuCTPI_RDO > theMuCTPI_RDO,
- const DataHandle < MuCTPI_RIO > theMuCTPI_RIO,
- const DataHandle < RpcSectorLogicContainer > theRPCContainer,
- const DataHandle < Muon::TgcCoinDataContainer > theTGCContainer);
- void doCtpMuctpi(const DataHandle < CTP_RDO > theCTP_RDO,
- const DataHandle < CTP_RIO > theCTP_RIO,
- const DataHandle < MuCTPI_RDO > theMuCTPI_RDO,
- const DataHandle < MuCTPI_RIO > theMuCTPI_RIO);
+ const DataHandle < MuCTPI_RIO > theMuCTPI_RIO,
+ const DataHandle < RpcSectorLogicContainer > theRPCContainer,
+ const DataHandle < Muon::TgcCoinDataContainer > theTGCContainer);
+
+ void doCtpMuctpi( const DataHandle < CTP_RDO > theCTP_RDO,
+ const DataHandle < CTP_RIO > theCTP_RIO,
+ const DataHandle < MuCTPI_RDO > theMuCTPI_RDO,
+ const DataHandle < MuCTPI_RIO > theMuCTPI_RIO);
+
void dumpData(const DataHandle < CTP_RDO > theCTP_RDO,
- const DataHandle < CTP_RIO > theCTP_RIO,
- const DataHandle < MuCTPI_RDO > theMuCTPI_RDO,
- const DataHandle < MuCTPI_RIO > theMuCTPI_RIO,
- const DataHandle < ROIB::RoIBResult > roib);
+ const DataHandle < CTP_RIO > theCTP_RIO,
+ const DataHandle < MuCTPI_RDO > theMuCTPI_RDO,
+ const DataHandle < MuCTPI_RIO > theMuCTPI_RIO,
+ const DataHandle < ROIB::RoIBResult > roib);
+
StatusCode compareRerun(const CTP_BC &bunchCrossing);
std::string getEventInfoString();
@@ -161,39 +159,51 @@ namespace TrigT1CTMonitoring {
TrigT1CTMonitoring::BeamMode getBeamMode(uint64_t eventTimeInNs) const;
bool getDataTakingMode(uint32_t lbNumber) const;
- bool m_histogramsBooked;
- bool m_retrievedLumiBlockTimes;
- uint32_t m_currentLumiBlock;
- unsigned int m_runNumber;
- unsigned int m_eventNumber;
-
- bool m_inclusiveTriggerThresholds;
- bool m_processMuctpi;
- bool m_processMuctpiRIO;
- bool m_processCTP;
- bool m_processRoIB;
- bool m_compareRerun;
- bool m_runOnESD;
- bool m_retrieveCoolData;
- std::string m_baseDirName;
- std::string m_dirName;
+
+ bool m_histogramsBooked{false};
+ bool m_retrievedLumiBlockTimes{false};
+ uint32_t m_currentLumiBlock{0};
+ unsigned int m_runNumber{0};
+ unsigned int m_eventNumber{0};
+
+ ServiceHandle<TrigConf::ILVL1ConfigSvc> m_configSvc{ this, "TrigConfigSvc", "TrigConf::TrigConfigSvc/TrigConfigSvc", "Trigger Config Service" };
+ ServiceHandle< LVL1::RecMuonRoiSvc > m_rpcRoiSvc{ this, "RPCRecRoiSvc", "LVL1RPC::RPCRecRoiSvc"};
+ ServiceHandle< LVL1::RecMuonRoiSvc > m_tgcRoiSvc{ this, "TGCRecRoiSvc", "LVL1TGC::TGCRecRoiSvc"};
+
+ Gaudi::Property<bool> m_useNewConfig { this, "UseNewConfig", false, "When true, read the menu from detector store, when false use the L1ConfigSvc" };
+
+ Gaudi::Property<std::string> m_baseDirName{ this, "DirectoryName", "CT/", "Directory in output root file where the histograms will be stored." };
+ Gaudi::Property<bool> m_inclusiveTriggerThresholds{ this, "InclusiveTriggerThresholds", true, "Flag to activate the inclusive counting of PT thresholds in trigger patterns" };
+ Gaudi::Property<bool> m_processMuctpi{ this, "ProcessMuctpiData", true, "Flag to activate the processing of Muctpi data" };
+ Gaudi::Property<bool> m_processMuctpiRIO{ this, "ProcessMuctpiDataRIO", true, "Flag to activate the processing of the Muctpi RIO" };
+ Gaudi::Property<bool> m_processCTP{ this, "ProcessCTPData", true, "Flag to activate the processing of CTP data" };
+ Gaudi::Property<bool> m_processRoIB{ this, "ProcessRoIBResult", true, "Flag to activate the processing of RoIBResult data" };
+ Gaudi::Property<bool> m_compareRerun{ this, "CompareRerun", false, "Flag to activate the processing of RoIBResult data" };
+ Gaudi::Property<bool> m_runOnESD{ this, "RunOnESD", false, "Flag to run only on the ESD" };
+ Gaudi::Property<bool> m_retrieveCoolData{ this, "RetrieveCoolData", true, "Flag to control whether or not to perform checks based on COOL data" };
+
+
+ Gaudi::Property<double> m_defaultBcIntervalInNs{ this, "DefaultBcIntervalInNs", 24.9507401, "Default bunch-crossing duration to use if not accessible in COOL" };
+ Gaudi::Property<int64_t> m_bcsPerTurn{ this, "BCsPerTurn", 3564, "Number of bunch crossings per turn" };
+ Gaudi::Property<std::string > m_lbTimeCoolFolderName{ this, "LumiBlockTimeCoolFolderName", "/TRIGGER/LUMI/LBLB",
+ "COOL folder in COOLONL_TRIGGER holding info about start and stop times for luminosity blocks" };
+ Gaudi::Property<std::string > m_rfPhaseCoolFolderName{ this, "RFPhaseCoolFolderName", "/TRIGGER/LVL1/RFPhase",
+ "COOL folder in COOLONL_TRIGGER holding LHC timing signal info and ATLAS related settings" };
+ Gaudi::Property<std::string > m_fillStateCoolFolderName{ this, "FillStateCoolFolderName", "/LHC/DCS/FILLSTATE",
+ "COOL folder in COOLOFL_DCS holding the LHC fill state info" };
+ Gaudi::Property<std::string> m_dataTakingModeCoolFolderName{ this, "DataTakingModeCoolFolderName", "/TDAQ/RunCtrl/DataTakingMode",
+ "COOL folder in COOLONL_TDAQ holding the ATLAS data taking mode info" };
+ Gaudi::Property<std::vector<std::string>> m_ignorePatterns{ this, "IgnorePatterns", {"L1_TRT", "L1_ZB", "_AFP", "L1_BPTX", "L1_BCM", "L1_LUCID"},
+ "patters that are excluded from check (no regex)"};
+ std::string m_dirName{""};
HistMap_t m_histNames;
- uint32_t m_eventCount;
- uint64_t m_firstEventTime;
- int64_t m_firstEventBcid;
- int64_t m_firstEventTC;
- uint32_t m_filledEventCount;
- uint32_t m_maxLumiBlock;
- uint32_t m_lumiBlockOfPreviousEvent;
-
- // COOL folder names
- std::string m_lbTimeCoolFolderName;
- std::string m_rfPhaseCoolFolderName;
- std::string m_fillStateCoolFolderName;
- std::string m_dataTakingModeCoolFolderName;
- //
- double m_defaultBcIntervalInNs;
- int64_t m_bcsPerTurn;
+ uint32_t m_eventCount{0};
+ uint64_t m_firstEventTime{0};
+ int64_t m_firstEventBcid{0};
+ int64_t m_firstEventTC{0};
+ uint32_t m_filledEventCount{0};
+ uint32_t m_maxLumiBlock{0};
+ uint32_t m_lumiBlockOfPreviousEvent{0};
// STL containers for info from COOL
std::vector<uint32_t> m_lumiBlocks;
@@ -204,7 +214,7 @@ namespace TrigT1CTMonitoring {
std::map<uint64_t,BeamMode> m_beamMode;
std::map<uint32_t,bool> m_dataTakingMode;
- unsigned int m_nLB;
+ unsigned int m_nLB{0};
//Vectors of TBP/TAP/TAB
std::vector<int> m_tbpItems;
@@ -219,8 +229,8 @@ namespace TrigT1CTMonitoring {
//TK: Like this so we can use LW hists when not in online mode:
void updateRangeUser();
- int m_lastminbc;
- int m_lastmaxbc;
+ int m_lastminbc{0};
+ int m_lastmaxbc{0};
};
}
#endif
diff --git a/Trigger/TrigT1/TrigT1CTP/python/TrigT1CTPConfig.py b/Trigger/TrigT1/TrigT1CTP/python/TrigT1CTPConfig.py
index 95f290d5188e..46154ac7a2fd 100755
--- a/Trigger/TrigT1/TrigT1CTP/python/TrigT1CTPConfig.py
+++ b/Trigger/TrigT1/TrigT1CTP/python/TrigT1CTPConfig.py
@@ -42,6 +42,7 @@ class CTPSimulationOnData(DefaultCTPSimulation):
self.DoNIM=True
self.DoRNDM=True
self.DoPSCL=False
+ self.ForceBunchGroupPattern = False # on data we will take the bunchgroups from COOL
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
if hasattr(svcMgr,'DSConfigSvc'):
# this case is still needed for reading Run 2 data configuration from the TriggerDB
diff --git a/Trigger/TrigT1/TrigT1CTP/src/CTPSimulation.cxx b/Trigger/TrigT1/TrigT1CTP/src/CTPSimulation.cxx
index b91330a886df..c79e74eb3871 100644
--- a/Trigger/TrigT1/TrigT1CTP/src/CTPSimulation.cxx
+++ b/Trigger/TrigT1/TrigT1CTP/src/CTPSimulation.cxx
@@ -8,6 +8,7 @@
#include "TrigConfL1Data/L1DataDef.h"
#include "TrigConfL1Data/ClusterThresholdValue.h"
#include "TrigT1Interfaces/TrigT1StoreGateKeys.h"
+#include "TrigConfData/L1BunchGroupSet.h"
#include "./CTPTriggerThreshold.h"
#include "./CTPTriggerItem.h"
@@ -60,6 +61,11 @@ StatusCode
LVL1CTP::CTPSimulation::initialize() {
ATH_MSG_DEBUG("initialize");
+ if(m_forceBunchGroupPattern) {
+ ATH_MSG_INFO("Will use bunchgroup pattern 0x" << std::hex << m_bunchGroupPattern);
+ } else {
+ ATH_MSG_INFO("Will use bunchgroup definition from bunchgroup set");
+ }
if( m_isData ) {
CHECK( m_oKeyRDO.assign(LVL1CTP::DEFAULT_RDOOutputLocation_Rerun) );
@@ -773,7 +779,22 @@ LVL1CTP::CTPSimulation::extractMultiplicities(std::map<std::string, unsigned int
}
} else {
// use bunchgroup definition from configuration and pick according to the BCID
- if( ! l1menu ) {
+ if( m_useNewConfig ) {
+ const TrigConf::L1BunchGroupSet *l1bgs = nullptr;
+ detStore()->retrieve(l1bgs).ignore();
+ if (l1bgs)
+ {
+ for (size_t i = 0; i < l1bgs->maxNBunchGroups(); ++i)
+ {
+ std::shared_ptr<TrigConf::L1BunchGroup> bg = l1bgs->getBunchGroup(i);
+ thrMultiMap[std::string("BGRP") + std::to_string(i)] = bg->contains(bcid) ? 1 : 0;
+ }
+ }
+ else
+ {
+ ATH_MSG_ERROR("Did not find L1BunchGroupSet in DetectorStore");
+ }
+ } else {
for( const TrigConf::BunchGroup & bg : m_configSvc->ctpConfig()->bunchGroupSet().bunchGroups() ) {
std::string bgName("BGRP");
bgName += std::to_string(bg.internalNumber());
diff --git a/Trigger/TriggerCommon/TriggerJobOpts/python/Lvl1SimulationConfig.py b/Trigger/TriggerCommon/TriggerJobOpts/python/Lvl1SimulationConfig.py
index f3484f317a2b..a93c1e96bc90 100644
--- a/Trigger/TriggerCommon/TriggerJobOpts/python/Lvl1SimulationConfig.py
+++ b/Trigger/TriggerCommon/TriggerJobOpts/python/Lvl1SimulationConfig.py
@@ -365,6 +365,7 @@ def Lvl1SimulationSequence( ConfigFlags ):
svcMgr += conf2toConfigurable(getL1ConfigSvc(ConfigFlags))
svcMgr += conf2toConfigurable(getL1TopoConfigSvc(ConfigFlags))
+ log.info("UseNewConfig = %s", ConfigFlags.Trigger.readLVL1FromJSON)
if ConfigFlags.Input.isMC and not ConfigFlags.Common.isOnline:
log.info("Setting up L1 simulation for MC")
l1SimSeq = Lvl1SimulationSequence_MC( ConfigFlags )
--
GitLab