def RPC_DigitizationBasicCfg(flags, **kwargs):
"""Return ComponentAccumulator for RPC digitization"""
acc = MuonGeoModelCfg(flags)
if "PileUpTools" not in kwargs:
PileUpTools = acc.popToolsAndMerge(RPC_DigitizationToolCfg(flags))
kwargs["PileUpTools"] = PileUpTools
acc.merge(PileUpToolsCfg(flags, **kwargs))
return acc
def TgcRDODecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
# We need the TGC cabling to be setup
from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
acc.merge(TGCCablingConfigCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Get the RDO -> PRD tool
Muon__TgcRdoToPrepDataToolMT = CompFactory.Muon.TgcRdoToPrepDataToolMT
TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataToolMT(
name="TgcRdoToTgcPrepDataTool")
# Get the RDO -> PRD alorithm
TgcRdoToTgcPrepData = CompFactory.TgcRdoToTgcPrepData
TgcRdoToTgcPrepData = TgcRdoToTgcPrepData(
name="TgcRdoToTgcPrepData",
DecodingTool=TgcRdoToTgcPrepDataTool,
PrintPrepData=False)
# add RegSelTool
from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
TgcRdoToTgcPrepData.RegSel_TGC = acc.popToolsAndMerge(
regSelTool_TGC_Cfg(flags))
if forTrigger:
# Set the algorithm to RoI mode
TgcRdoToTgcPrepData.DoSeededDecoding = True
from L1Decoder.L1DecoderConfig import mapThresholdToL1RoICollection
TgcRdoToTgcPrepData.RoIs = mapThresholdToL1RoICollection("MU")
acc.addEventAlgo(TgcRdoToTgcPrepData)
return acc
def RPC_OverlayDigitizationBasicCfg(flags, **kwargs):
"""Return ComponentAccumulator with RPC Overlay digitization"""
acc = MuonGeoModelCfg(flags)
if "DigitizationTool" not in kwargs:
tool = acc.popToolsAndMerge(RPC_OverlayDigitizationToolCfg(flags))
kwargs["DigitizationTool"] = tool
if flags.Concurrency.NumThreads > 0:
kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
# Set common overlay extra inputs
kwargs.setdefault("ExtraInputs", flags.Overlay.ExtraInputs)
RPC_Digitizer = CompFactory.RPC_Digitizer
acc.addEventAlgo(RPC_Digitizer(name="RPC_OverlayDigitizer", **kwargs))
return acc
def MuonTrackBuildingCfg(flags, name="MuPatTrackBuilder"):
MuPatTrackBuilder = CompFactory.MuPatTrackBuilder
# This is based on https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonStandalone.py#L162
result = ComponentAccumulator()
#Arguably this should be somewhere deeper - not quite sure where yet though. FIXME
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(flags))
Muon__MuonEDMHelperSvc = CompFactory.Muon.MuonEDMHelperSvc
muon_edm_helper_svc = Muon__MuonEDMHelperSvc("MuonEDMHelperSvc")
result.addService(muon_edm_helper_svc)
acc = MuonTrackSteeringCfg(flags)
track_steering = acc.getPrimary()
result.merge(acc)
track_builder = MuPatTrackBuilder(
name=name,
TrackSteering=track_steering,
MuonSegmentCollection="MuonSegments",
SpectrometerTrackOutputLocation="MuonSpectrometerTracks")
result.addEventAlgo(track_builder, primary=True)
return result
def MuonGeoDetectorToolCfg(ConfigFlags, name='Muon', **kwargs):
#set up geometry
result=MuonGeoModelCfg(ConfigFlags)
kwargs.setdefault("DetectorName", "Muon")
#add the GeometryNotifierSvc
result.addService(G4GeometryNotifierSvcCfg(ConfigFlags))
kwargs.setdefault("GeometryNotifierSvc", result.getService("G4GeometryNotifierSvc"))
result.setPrivateTools(GeoDetectorTool(name, **kwargs))
return result
def CSCCablingConfigCfg(flags):
acc = ComponentAccumulator()
acc.merge(MuonGeoModelCfg(flags))
CSCcablingSvc = CompFactory.CSCcablingSvc
cscCablingSvc = CSCcablingSvc()
acc.addService(cscCablingSvc, primary=True)
return acc
def testCfg (configFlags):
result = ComponentAccumulator()
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge (MuonGeoModelCfg(configFlags))
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge (MagneticFieldSvcCfg(configFlags, UseDCS = False))
Muon__MdtRdoToPrepDataTool = CompFactory.Muon.MdtRdoToPrepDataTool
result.addPublicTool (Muon__MdtRdoToPrepDataTool ('Muon__MdtRdoToPrepDataTool', OutputLevel = 1))
result.addEventAlgo (TestAlg ('TestAlg'))
return result
def testCfg(configFlags):
result = ComponentAccumulator()
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(configFlags))
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge(MagneticFieldSvcCfg(configFlags, UseDCS=False))
MuonStationIntersectSvc = CompFactory.MuonStationIntersectSvc
result.addService(
MuonStationIntersectSvc('MuonStationIntersectSvc', OutputLevel=1))
result.addEventAlgo(TestAlg('TestAlg'))
return result
def MDTCablingConfigCfg(flags):
acc = ComponentAccumulator()
acc.merge(MuonGeoModelCfg(flags))
MuonMDT_CablingAlg = CompFactory.MuonMDT_CablingAlg
MDTCablingAlg = MuonMDT_CablingAlg("MuonMDT_CablingAlg")
MuonMDT_CablingSvc = CompFactory.MuonMDT_CablingSvc
mdtCablingSvc = MuonMDT_CablingSvc()
mdtCablingSvc.UseOldCabling = False
mdtCablingSvc.ForcedUse = True
MDTCablingDbTool = CompFactory.MDTCablingDbTool
MDTCablingDbTool = MDTCablingDbTool()
from IOVDbSvc.IOVDbSvcConfig import addFolders
if flags.Input.isMC is True:
MDTCablingDbTool.MapFolders = "/MDT/Ofl/CABLING/MAP_SCHEMA"
MDTCablingDbTool.MezzanineFolders = "/MDT/Ofl/CABLING/MEZZANINE_SCHEMA"
MDTCablingAlg.MapFolders = "/MDT/Ofl/CABLING/MAP_SCHEMA"
MDTCablingAlg.MezzanineFolders = "/MDT/Ofl/CABLING/MEZZANINE_SCHEMA"
acc.merge(
addFolders(flags, [
"/MDT/Ofl/CABLING/MAP_SCHEMA",
"/MDT/Ofl/CABLING/MEZZANINE_SCHEMA"
],
'MDT_OFL',
className="CondAttrListCollection"))
else:
MDTCablingDbTool.MapFolders = "/MDT/CABLING/MAP_SCHEMA"
MDTCablingDbTool.MezzanineFolders = "/MDT/CABLING/MEZZANINE_SCHEMA"
MDTCablingAlg.MapFolders = "/MDT/CABLING/MAP_SCHEMA"
MDTCablingAlg.MezzanineFolders = "/MDT/CABLING/MEZZANINE_SCHEMA"
acc.merge(
addFolders(
flags,
["/MDT/CABLING/MAP_SCHEMA", "/MDT/CABLING/MEZZANINE_SCHEMA"],
'MDT',
className="CondAttrListCollection"))
acc.addCondAlgo(MDTCablingAlg)
acc.addPublicTool(MDTCablingDbTool)
mdtCablingSvc.DBTool = MDTCablingDbTool
acc.addService(mdtCablingSvc, primary=True)
return acc
def testCfg(configFlags):
result = ComponentAccumulator()
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(configFlags))
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge(MagneticFieldSvcCfg(configFlags, UseDCS=False))
TrigL2MuonSA__MdtDataPreparator = CompFactory.TrigL2MuonSA.MdtDataPreparator
result.addPublicTool(
TrigL2MuonSA__MdtDataPreparator('TrigL2MuonSA::MdtDataPreparator',
OutputLevel=1)) # noqa: ATL900
result.addEventAlgo(TestAlg('TestAlg'))
return result
def RpcBytestreamDecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
# We need the RPC cabling to be setup
from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
acc.merge(RPCCablingConfigCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Setup the RPC ROD decoder
Muon__RpcROD_Decoder = CompFactory.Muon.RpcROD_Decoder
RPCRodDecoder = Muon__RpcROD_Decoder(name="RpcROD_Decoder")
# RAW data provider tool needs ROB data provider service (should be another Config function?)
ROBDataProviderSvc = CompFactory.ROBDataProviderSvc
robDPSvc = ROBDataProviderSvc()
acc.addService(robDPSvc)
# Setup the RAW data provider tool
keyName = flags.Overlay.BkgPrefix + "RPCPAD" if flags.Detector.OverlayRPC else "RPCPAD"
Muon__RPC_RawDataProviderToolMT = CompFactory.Muon.RPC_RawDataProviderToolMT
MuonRpcRawDataProviderTool = Muon__RPC_RawDataProviderToolMT(
name="RPC_RawDataProviderToolMT",
Decoder=RPCRodDecoder,
RdoLocation=keyName)
if forTrigger:
MuonRpcRawDataProviderTool.RpcContainerCacheKey = MuonCacheNames.RpcCache
MuonRpcRawDataProviderTool.WriteOutRpcSectorLogic = False
acc.addPublicTool(
MuonRpcRawDataProviderTool
) # This should be removed, but now defined as PublicTool at MuFastSteering
# Setup the RAW data provider algorithm
Muon__RpcRawDataProvider = CompFactory.Muon.RpcRawDataProvider
RpcRawDataProvider = Muon__RpcRawDataProvider(
name="RpcRawDataProvider", ProviderTool=MuonRpcRawDataProviderTool)
if forTrigger:
# Configure the RAW data provider for ROI access
from L1Decoder.L1DecoderConfig import mapThresholdToL1RoICollection
RpcRawDataProvider.RoIs = mapThresholdToL1RoICollection("MU")
acc.addEventAlgo(RpcRawDataProvider, primary=True)
return acc
def MdtBytestreamDecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
# We need the MDT cabling to be setup
from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
acc.merge(MDTCablingConfigCfg(flags))
# need the MagFieldSvc since MdtRdoToMdtPrepData.MdtRdoToMdtPrepDataTool.MdtCalibrationTool wants to retrieve it
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
acc.merge(MagneticFieldSvcCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Setup the MDT ROD decoder
MdtROD_Decoder = CompFactory.MdtROD_Decoder
MDTRodDecoder = MdtROD_Decoder(name="MdtROD_Decoder")
# RAW data provider tool needs ROB data provider service (should be another Config function?)
ROBDataProviderSvc = CompFactory.ROBDataProviderSvc
robDPSvc = ROBDataProviderSvc()
acc.addService(robDPSvc)
# Setup the RAW data provider tool
keyName = flags.Overlay.BkgPrefix + "MDTCSM" if flags.Detector.OverlayMDT else "MDTCSM"
Muon__MDT_RawDataProviderToolMT = CompFactory.Muon.MDT_RawDataProviderToolMT
MuonMdtRawDataProviderTool = Muon__MDT_RawDataProviderToolMT(
name="MDT_RawDataProviderToolMT",
Decoder=MDTRodDecoder,
RdoLocation=keyName)
if forTrigger:
MuonMdtRawDataProviderTool.CsmContainerCacheKey = MuonCacheNames.MdtCsmCache
acc.addPublicTool(
MuonMdtRawDataProviderTool
) # This should be removed, but now defined as PublicTool at MuFastSteering
# Setup the RAW data provider algorithm
Muon__MdtRawDataProvider = CompFactory.Muon.MdtRawDataProvider
MdtRawDataProvider = Muon__MdtRawDataProvider(
name="MdtRawDataProvider", ProviderTool=MuonMdtRawDataProviderTool)
acc.addEventAlgo(MdtRawDataProvider, primary=True)
return acc
def RPCCablingConfigCfg(flags):
acc = ComponentAccumulator()
# TODO check if we actually need this here?
acc.merge(MuonGeoModelCfg(flags))
RpcCablingCondAlg = CompFactory.RpcCablingCondAlg
RpcCablingAlg = RpcCablingCondAlg("RpcCablingCondAlg")
acc.addCondAlgo(RpcCablingAlg)
RPCcablingServerSvc = CompFactory.RPCcablingServerSvc
RPCCablingSvc = RPCcablingServerSvc()
RPCCablingSvc.Atlas = True
RPCCablingSvc.forcedUse = True
RPCCablingSvc.useMuonRPC_CablingSvc = True #Needed to switch to new cabling
acc.addService(RPCCablingSvc)
MuonRPC_CablingSvc = CompFactory.MuonRPC_CablingSvc
rpcCablingSvc = MuonRPC_CablingSvc()
rpcCablingSvc.ConfFileName = 'LVL1confAtlas.data' # this should come from config flag maybe ???
rpcCablingSvc.CorrFileName = 'LVL1confAtlas.corr'
rpcCablingSvc.ConfFilePath = 'MuonRPC_Cabling/'
rpcCablingSvc.RPCTriggerRoadsfromCool = True
rpcCablingSvc.CosmicConfiguration = 'HLT' in flags.IOVDb.GlobalTag # this was set to true by the modifier openThresholdRPCCabling in runHLT_standalone.py
from IOVDbSvc.IOVDbSvcConfig import addFolders
dbName = 'RPC_OFL' if flags.Input.isMC else 'RPC'
acc.merge(
addFolders(flags, [
'/RPC/TRIGGER/CM_THR_ETA', '/RPC/TRIGGER/CM_THR_PHI',
'/RPC/CABLING/MAP_SCHEMA', '/RPC/CABLING/MAP_SCHEMA_CORR'
],
dbName,
className='CondAttrListCollection'))
RPCCablingDbTool = CompFactory.RPCCablingDbTool
RPCCablingDbTool = RPCCablingDbTool()
RPCCablingDbTool.MapConfigurationFolder = '/RPC/CABLING/MAP_SCHEMA'
RPCCablingDbTool.MapCorrectionFolder = '/RPC/CABLING/MAP_SCHEMA_CORR'
acc.addPublicTool(RPCCablingDbTool)
rpcCablingSvc.TheRpcCablingDbTool = RPCCablingDbTool
acc.addService(rpcCablingSvc, primary=True)
return acc
def TrackingGeoCfg(inputFlags):
result = ComponentAccumulator()
from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg
result.merge(InDetGeometryCfg(inputFlags))
# Something builds muon stations -- extrapolator?
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(inputFlags))
from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
result.merge(TrackingGeometrySvcCfg(inputFlags))
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge(MagneticFieldSvcCfg(inputFlags))
return result
def AtlasGeometryCfg(flags):
acc = ComponentAccumulator()
from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg
acc.merge(InDetGeometryCfg(flags))
from LArGeoAlgsNV.LArGMConfig import LArGMCfg
acc.merge(LArGMCfg(flags))
from TileGeoModel.TileGMConfig import TileGMCfg
acc.merge(TileGMCfg(flags))
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
#from AtlasGeoModel.ForDetGeoModelConfig import ForDetGeometryCfg
#acc.merge(ForDetGeometryCfg(flags))
from BeamPipeGeoModel.BeamPipeGMConfig import BeamPipeGeometryCfg
acc.merge(BeamPipeGeometryCfg(flags))
from AtlasGeoModel.CavernGMConfig import CavernGeometryCfg
acc.merge(CavernGeometryCfg(flags))
return acc
def MuonSegmentFindingCfg(flags, cardinality=1):
# Set up some general stuff needed by muon reconstruction
result = ComponentAccumulator()
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(flags))
Muon__MuonEDMHelperSvc = CompFactory.Muon.MuonEDMHelperSvc
muon_edm_helper_svc = Muon__MuonEDMHelperSvc("MuonEDMHelperSvc")
result.addService(muon_edm_helper_svc)
# We need to add two algorithms - one for normal collisions, one for NCB
acc = MooSegmentFinderAlgCfg(flags, Cardinality=cardinality)
result.merge(acc)
acc = MooSegmentFinderAlg_NCBCfg(flags, Cardinality=cardinality)
result.merge(acc)
return result
def TgcBytestreamDecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
# We need the TGC cabling to be setup
from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
acc.merge(TGCCablingConfigCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Setup the TGC ROD decoder
Muon__TGC_RodDecoderReadout = CompFactory.Muon.TGC_RodDecoderReadout
TGCRodDecoder = Muon__TGC_RodDecoderReadout(name="TgcROD_Decoder")
# RAW data provider tool needs ROB data provider service (should be another Config function?)
ROBDataProviderSvc = CompFactory.ROBDataProviderSvc
robDPSvc = ROBDataProviderSvc()
acc.addService(robDPSvc)
# Setup the RAW data provider tool
keyName = flags.Overlay.BkgPrefix + "TGCRDO" if flags.Detector.OverlayTGC else "TGCRDO"
Muon__TGC_RawDataProviderToolMT = CompFactory.Muon.TGC_RawDataProviderToolMT
MuonTgcRawDataProviderTool = Muon__TGC_RawDataProviderToolMT(
name="TGC_RawDataProviderToolMT",
Decoder=TGCRodDecoder,
RdoLocation=keyName)
if forTrigger:
MuonTgcRawDataProviderTool.TgcContainerCacheKey = MuonCacheNames.TgcCache
acc.addPublicTool(
MuonTgcRawDataProviderTool
) # This should be removed, but now defined as PublicTool at MuFastSteering
# Setup the RAW data provider algorithm
Muon__TgcRawDataProvider = CompFactory.Muon.TgcRawDataProvider
TgcRawDataProvider = Muon__TgcRawDataProvider(
name="TgcRawDataProvider", ProviderTool=MuonTgcRawDataProviderTool)
acc.addEventAlgo(TgcRawDataProvider, primary=True)
return acc
def RpcRDODecodeCfg(flags, forTrigger=False):
from MuonConfig.MuonCondAlgConfig import RpcCondDbAlgCfg # MT-safe conditions access
acc = RpcCondDbAlgCfg(flags)
# We need the RPC cabling to be setup
from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
acc.merge(RPCCablingConfigCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Get the RDO -> PRD tool
Muon__RpcRdoToPrepDataToolMT = CompFactory.Muon.RpcRdoToPrepDataToolMT
RpcRdoToRpcPrepDataTool = Muon__RpcRdoToPrepDataToolMT(
name="RpcRdoToRpcPrepDataTool")
if flags.Common.isOnline:
RpcRdoToRpcPrepDataTool.ReadKey = "" ## cond data not needed online
if forTrigger:
RpcRdoToRpcPrepDataTool.RpcPrdContainerCacheKey = MuonPrdCacheNames.RpcCache
RpcRdoToRpcPrepDataTool.RpcCoinDataContainerCacheKey = MuonPrdCacheNames.RpcCoinCache
# Get the RDO -> PRD alorithm
RpcRdoToRpcPrepData = CompFactory.RpcRdoToRpcPrepData
RpcRdoToRpcPrepData = RpcRdoToRpcPrepData(
name="RpcRdoToRpcPrepData",
DecodingTool=RpcRdoToRpcPrepDataTool,
PrintPrepData=False)
# add RegSelTool
from RegionSelector.RegSelToolConfig import regSelTool_RPC_Cfg
RpcRdoToRpcPrepData.RegSel_RPC = acc.popToolsAndMerge(
regSelTool_RPC_Cfg(flags))
if forTrigger:
# Set the algorithm to RoI mode
RpcRdoToRpcPrepData.DoSeededDecoding = True
from L1Decoder.L1DecoderConfig import mapThresholdToL1RoICollection
RpcRdoToRpcPrepData.RoIs = mapThresholdToL1RoICollection("MU")
acc.addEventAlgo(RpcRdoToRpcPrepData)
return acc
def TGCCablingConfigCfg(flags):
acc = ComponentAccumulator()
# TODO check if we actually need this here?
acc.merge(MuonGeoModelCfg(flags))
LVL1TGC__TGCRecRoiSvc = CompFactory.LVL1TGC.TGCRecRoiSvc
acc.addService(LVL1TGC__TGCRecRoiSvc())
TGCcablingServerSvc = CompFactory.TGCcablingServerSvc
TGCCablingSvc = TGCcablingServerSvc()
TGCCablingSvc.Atlas = True
TGCCablingSvc.useMuonTGC_CablingSvc = True
TGCCablingSvc.forcedUse = True
acc.addService(TGCCablingSvc, primary=True)
from IOVDbSvc.IOVDbSvcConfig import addFolders
dbName = 'TGC_OFL' if flags.Input.isMC else 'TGC'
acc.merge(addFolders(flags, '/TGC/CABLING/MAP_SCHEMA', dbName))
return acc
def CscRDODecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
# We need the CSC cabling to be setup
from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg # Not yet been prepared
acc.merge(CSCCablingConfigCfg(flags))
from MuonConfig.MuonCondAlgConfig import CscCondDbAlgCfg
acc.merge(CscCondDbAlgCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Get the RDO -> PRD tool
Muon__CscRdoToCscPrepDataToolMT = CompFactory.Muon.CscRdoToCscPrepDataToolMT
CscRdoToCscPrepDataTool = Muon__CscRdoToCscPrepDataToolMT(
name="CscRdoToCscPrepDataTool")
# Get the RDO -> PRD alorithm
CscRdoToCscPrepData = CompFactory.CscRdoToCscPrepData
CscRdoToCscPrepData = CscRdoToCscPrepData(
name="CscRdoToCscPrepData",
CscRdoToCscPrepDataTool=CscRdoToCscPrepDataTool,
PrintPrepData=False)
# add RegSelTool
from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
CscRdoToCscPrepData.RegSel_CSC = acc.popToolsAndMerge(
regSelTool_CSC_Cfg(flags))
if forTrigger:
# Set the algorithm to RoI mode
CscRdoToCscPrepData.DoSeededDecoding = True
from L1Decoder.L1DecoderConfig import mapThresholdToL1RoICollection
CscRdoToCscPrepData.RoIs = mapThresholdToL1RoICollection("MU")
acc.addEventAlgo(CscRdoToCscPrepData)
return acc
def MdtRDODecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
# We need the MDT cabling to be setup
from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
acc.merge(MDTCablingConfigCfg(flags))
from MuonConfig.MuonCalibConfig import MdtCalibDbAlgCfg
acc.merge(MdtCalibDbAlgCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Get the RDO -> PRD tool
Muon__MdtRdoToPrepDataToolMT = CompFactory.Muon.MdtRdoToPrepDataToolMT
MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataToolMT(
name="MdtRdoToMdtPrepDataTool")
# Get the RDO -> PRD alorithm
MdtRdoToMdtPrepData = CompFactory.MdtRdoToMdtPrepData
MdtRdoToMdtPrepData = MdtRdoToMdtPrepData(
name="MdtRdoToMdtPrepData",
DecodingTool=MdtRdoToMdtPrepDataTool,
PrintPrepData=False)
# add RegSelTool
from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
MdtRdoToMdtPrepData.RegSel_MDT = acc.popToolsAndMerge(
regSelTool_MDT_Cfg(flags))
if forTrigger:
# Set the algorithm to RoI mode
MdtRdoToMdtPrepData.DoSeededDecoding = True
from L1Decoder.L1DecoderConfig import mapThresholdToL1RoICollection
MdtRdoToMdtPrepData.RoIs = mapThresholdToL1RoICollection("MU")
acc.addEventAlgo(MdtRdoToMdtPrepData)
return acc
def PrepareStandAloneBTagCfg(inputFlags):
result = ComponentAccumulator()
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
result.merge(PoolReadCfg(inputFlags))
from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
acc = TrackingGeometrySvcCfg(inputFlags)
result.merge(acc)
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(inputFlags))
GeometryDBSvc = CompFactory.GeometryDBSvc
result.addService(GeometryDBSvc("InDetGeometryDBSvc"))
from PixelGeoModel.PixelGeoModelConfig import PixelGeometryCfg
result.merge(PixelGeometryCfg(inputFlags))
# get standard config for magnetic field - map and cache
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge(MagneticFieldSvcCfg(inputFlags))
from IOVDbSvc.IOVDbSvcConfig import addFolders, addFoldersSplitOnline
#load folders needed for Run2 ID alignment
result.merge(
addFoldersSplitOnline(inputFlags,
"INDET",
"/Indet/Onl/Align",
"/Indet/Align",
className="AlignableTransformContainer"))
result.merge(addFolders(inputFlags, ['/TRT/Align'], 'TRT_OFL'))
#load folders needed for IBL
result.merge(addFolders(inputFlags, ['/Indet/IBLDist'], 'INDET_OFL'))
return result
def TPCnvTest(infile,
keys,
useGeoModelSvc=False,
useIOVDbSvc=False,
doPixel=False,
doSCT=False,
doTRT=False,
doLAr=False,
doTile=False,
doMuon=False):
# Make sure we don't have a stale file catalog.
if os.path.exists('PoolFileCatalog.xml'):
os.remove('PoolFileCatalog.xml')
if ('ATLAS_REFERENCE_TAG' not in globals()
and 'ATLAS_REFERENCE_TAG' in os.environ):
ATLAS_REFERENCE_TAG = os.environ['ATLAS_REFERENCE_TAG'] # noqa: F841
refpaths = [
os.environ.get('ATLAS_REFERENCE_DATA', None),
'/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art',
'/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/CommonInputs',
'/afs/cern.ch/atlas/maxidisk/d33/referencefiles'
]
if infile.startswith('rtt:'):
infile = infile[4:]
infile = find_file(infile, refpaths)
# Provide MC input
ConfigFlags.Input.Files = [infile]
ConfigFlags.GeoModel.AtlasVersion = 'ATLAS-R1-2012-03-01-00'
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Detector.GeometryPixel = doPixel
ConfigFlags.Detector.GeometrySCT = doSCT
ConfigFlags.Detector.GeometryTRT = doTRT
ConfigFlags.Detector.GeometryLAr = doLAr
ConfigFlags.Detector.GeometryTile = doTile
ConfigFlags.Detector.GeometryMuon = doMuon
ConfigFlags.lock()
# Construct ComponentAccumulator
acc = MainServicesCfg(ConfigFlags)
acc.merge(PoolReadCfg(ConfigFlags))
if useIOVDbSvc:
acc.merge(IOVDbSvcCfg(ConfigFlags))
if useGeoModelSvc:
if ConfigFlags.Detector.GeometryPixel:
acc.merge(PixelGeometryCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometrySCT:
acc.merge(SCT_GeometryCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryTRT:
acc.merge(TRT_GeometryCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryLAr:
acc.merge(LArGMCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryTile:
acc.merge(TileGMCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryMuon:
acc.merge(MuonGeoModelCfg(ConfigFlags))
useGeoModelSvc = True
#acc.merge(ForDetGeometryCfg(ConfigFlags))
acc.merge(GeoModelCfg(ConfigFlags))
acc.getService("GeoModelSvc").IgnoreTagDifference = True
acc.addEventAlgo(
Dumper('dumper', ConfigFlags.Input.Files[0], keys, refpaths),
'AthAlgSeq')
return acc.run(maxEvents=10)
def PFCfg(inputFlags, **kwargs):
#This is monolithic for now.
#Once a first complete example runs, this will be split into small modular chunks.
#Some such items may be best placed elsewehere (e.g. put magnetic field setup in magnetic field git folder etc)
result = ComponentAccumulator()
StoreGateSvc = CompFactory.StoreGateSvc
result.addService(StoreGateSvc("DetectorStore"))
#Alias calibrated topoclusters, if they exist already, such that overwrite won't fial
from SGComps.AddressRemappingConfig import InputRenameCfg
result.merge(
InputRenameCfg("xAOD::CaloClusterContainer", "CaloCalTopoClusters",
""))
#Setup up general geometry
from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg
result.merge(InDetGeometryCfg(inputFlags))
#Setup TRT conditions
TRTAlignCondAlg = CompFactory.TRTAlignCondAlg
result.addCondAlgo(
TRTAlignCondAlg(name="TRTAlignCondAlg",
UseDynamicFolders=inputFlags.GeoModel.Align.Dynamic))
#Setup Pixel conditions
PixelAlignCondAlg = CompFactory.PixelAlignCondAlg
result.addCondAlgo(
PixelAlignCondAlg(
name="PixelAlignCondAlg",
UseDynamicAlignFolders=inputFlags.GeoModel.Align.Dynamic))
PixelDetectorElementCondAlg = CompFactory.PixelDetectorElementCondAlg
result.addCondAlgo(
PixelDetectorElementCondAlg(name="PixelDetectorElementCondAlg"))
#Setup SCT conditions
SCT_AlignCondAlg = CompFactory.SCT_AlignCondAlg
result.addCondAlgo(
SCT_AlignCondAlg(
name="SCT_AlignCondAlg",
UseDynamicAlignFolders=inputFlags.GeoModel.Align.Dynamic))
SCT_DetectorElementCondAlg = CompFactory.SCT_DetectorElementCondAlg
result.addCondAlgo(
SCT_DetectorElementCondAlg(name="SCT_DetectorElementCondAlg"))
GeometryDBSvc = CompFactory.GeometryDBSvc
result.addService(GeometryDBSvc("InDetGeometryDBSvc"))
#from AthenaCommon import CfgGetter
#result.getService("GeoModelSvc").DetectorTools += [ CfgGetter.getPrivateTool("PixelDetectorTool", checkType=True) ]
#result.getService("GeoModelSvc").DetectorTools += [ CfgGetter.getPrivateTool("SCT_DetectorTool", checkType=True) ]
#Setup TRT geometry
TRT_DetectorTool = CompFactory.TRT_DetectorTool
trtDetectorTool = TRT_DetectorTool()
#These two lines fix ATLASRECTS-5053. I expect eventually we can remove them, once the underlying issue is fixed.
trtDetectorTool.DoXenonArgonMixture = False
trtDetectorTool.DoKryptonMixture = False
result.getService("GeoModelSvc").DetectorTools += [trtDetectorTool]
#Setup up material for inner detector
InDetServMatTool = CompFactory.InDetServMatTool
result.getService("GeoModelSvc").DetectorTools += [InDetServMatTool()]
#Setup up tracking geometry
from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
acc = TrackingGeometrySvcCfg(inputFlags)
result.merge(acc)
#load folders needed for Run2 ID alignment
from IOVDbSvc.IOVDbSvcConfig import addFolders
result.merge(addFolders(inputFlags, ['/TRT/Align'], 'TRT_OFL'))
#Setup up muon geometry
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(inputFlags))
#setup magnetic field service
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge(MagneticFieldSvcCfg(inputFlags))
#hard-code MC conditions tag needed for my ESD file - must be a better way? how to auto-configure?
iovDbSvc = result.getService("IOVDbSvc")
iovDbSvc.GlobalTag = "OFLCOND-MC16-SDR-20"
#Configure topocluster algorithmsm, and associated conditions
from CaloRec.CaloTopoClusterConfig import CaloTopoClusterCfg
result.merge(CaloTopoClusterCfg(inputFlags, doLCCalib=True))
from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
result.merge(caloTopoCoolFolderCfg(inputFlags))
from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
result.merge(CaloNoiseCondAlgCfg(inputFlags, "totalNoise"))
result.merge(CaloNoiseCondAlgCfg(inputFlags, "electronicNoise"))
#Cache the track extrapolations
from TrackToCalo.CaloExtensionBuilderAlgCfg import getCaloExtenstionBuilderAlgorithm
result.addEventAlgo(getCaloExtenstionBuilderAlgorithm(inputFlags))
#Configure the pflow algorithms
PFLeptonSelector = CompFactory.PFLeptonSelector
result.addEventAlgo(PFLeptonSelector("PFLeptonSelector"))
from eflowRec.PFCfg import getPFTrackSelectorAlgorithm
result.addEventAlgo(
getPFTrackSelectorAlgorithm(inputFlags, "PFTrackSelector"))
result.addEventAlgo(getOfflinePFAlgorithm(inputFlags))
from eflowRec.PFCfg import getChargedPFOCreatorAlgorithm, getNeutralPFOCreatorAlgorithm
result.addEventAlgo(getChargedPFOCreatorAlgorithm(inputFlags, ""))
result.addEventAlgo(getNeutralPFOCreatorAlgorithm(inputFlags, ""))
return result
def MuonCombinedReconstructionCfg(flags):
result = ComponentAccumulator()
from AtlasGeoModel.GeoModelConfig import GeoModelCfg
result.merge(GeoModelCfg(flags))
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(flags))
from LArGeoAlgsNV.LArGMConfig import LArGMCfg
result.merge(LArGMCfg(flags))
from TileGeoModel.TileGMConfig import TileGMCfg
result.merge(TileGMCfg(flags))
from BeamPipeGeoModel.BeamPipeGMConfig import BeamPipeGeometryCfg
result.merge(BeamPipeGeometryCfg(flags))
from PixelGeoModel.PixelGeoModelConfig import PixelGeometryCfg
result.merge(PixelGeometryCfg(flags))
from SCT_GeoModel.SCT_GeoModelConfig import SCT_GeometryCfg
result.merge(SCT_GeometryCfg(flags))
from TRT_GeoModel.TRT_GeoModelConfig import TRT_GeometryCfg
result.merge(TRT_GeometryCfg(flags))
from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
result.merge(TrackingGeometrySvcCfg(flags))
muon_edm_helper_svc = CompFactory.Muon.MuonEDMHelperSvc("MuonEDMHelperSvc")
result.addService(muon_edm_helper_svc)
# Set up to read Tracks.
from TrkConfig.TrackCollectionReadConfig import TrackCollectionReadCfg
result.merge(TrackCollectionReadCfg(flags, 'Tracks'))
result.merge(MuonCombinedInDetCandidateAlg(flags))
result.merge(MuonCombinedMuonCandidateAlgCfg(flags))
if flags.MuonCombined.doStatisticalCombination or flags.MuonCombined.doCombinedFit:
result.merge(MuonCombinedAlgCfg(flags))
if flags.MuonCombined.doMuGirl:
result.merge(
MuonInsideOutRecoAlgCfg(flags, name="MuonInsideOutRecoAlg"))
if flags.MuonCombined.doMuGirlLowBeta:
result.merge(MuGirlStauAlgCfg)
if flags.MuonCombined.doCaloTrkMuId:
result.merge(MuonCaloTagAlgCfg(flags))
if flags.MuonCombined.doMuonSegmentTagger:
result.merge(MuonSegmentTagAlgCfg(flags))
# runs over outputs and create xAODMuon collection
acc = MuonCreatorAlgCfg(flags)
result.merge(acc)
if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
# Has to be at end if not using sequencer. If we drop this requirement, can be moved above
result.merge(StauCreatorAlgCfg(flags))
return result
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from AthenaCommon import Logging
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
if __name__=="__main__":
# Setting needed for the ComponentAccumulator to do its thing
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior=True
# Set message levels
from AthenaCommon import Constants
msgLvl = "WARNING"
from AthenaCommon.Logging import log
log.setLevel(msgLvl)
# Config flags steer the job at various levels
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.Input.isMC = True
ConfigFlags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/ASG/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1"]
# Flags relating to multithreaded execution
nthreads=0
ConfigFlags.Concurrency.NumThreads =nthreads
if nthreads>0:
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Concurrency.NumConcurrentEvents = 1
ConfigFlags.MET.UseTracks = True
ConfigFlags.MET.DoPFlow = True
if ConfigFlags.Beam.Type == 'cosmics' or ConfigFlags.Beam.Type == 'singlebeam':# used to have " or not rec.doInDet()" on the end
def CscMonitoringConfig(inputFlags):
'''Function to configures some algorithms in the monitoring system.'''
### STEP 1 ###
# If you need to set up special tools, etc., you will need your own ComponentAccumulator;
# uncomment the following 2 lines and use the last three lines of this function instead of the ones
# just before
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
result = ComponentAccumulator()
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
result.merge(MuonGeoModelCfg(inputFlags))
# The following class will make a sequence, configure algorithms, and link
# them to GenericMonitoringTools
from AthenaMonitoring import AthMonitorCfgHelper
helper = AthMonitorCfgHelper(inputFlags, 'CscAthMonitorCfg')
### STEP 2 ###
# Adding an algorithm to the helper. Here, we will use the example
# algorithm in the AthenaMonitoring package. Just pass the type to the
# helper. Then, the helper will instantiate an instance and set up the
# base class configuration following the inputFlags. The returned object
# is the algorithm.
# This uses the new Configurables object system.
cscClusMonAlg = helper.addAlgorithm(CompFactory.CscClusterValMonAlg,
'CscClusMonAlg')
cscPrdMonAlg = helper.addAlgorithm(CompFactory.CscPrdValMonAlg,
'CscPrdMonAlg')
# cscSegmMonAlg = helper.addAlgorithm(CompFactory.CscSegmValMonAlg,'CscSegmValMonAlg')
### STEP 3 ###
# Edit properties of a algorithm
# some generic property
# exampleMonAlg.RandomHist = True
cscClusMonAlg.CSCQmaxCutADC = 100
cscPrdMonAlg.NoiseCutADC = 50
cscPrdMonAlg.MapYXandRZ = False
# to enable a trigger filter, for example:
#exampleMonAlg.TriggerChain = 'HLT_mu26_ivarmedium'
### STEP 4 ###
# Add some tools. N.B. Do not use your own trigger decion tool. Use the
# standard one that is included with AthMonitorAlgorithm.
# # Then, add a tool that doesn't have its own configuration function. In
# # this example, no accumulator is returned, so no merge is necessary.
# from MyDomainPackage.MyDomainPackageConf import MyDomainTool
# exampleMonAlg.MyDomainTool = MyDomainTool()
from MuonConfig.MuonCalibConfig import CscCalibToolCfg
calibtool = result.popToolsAndMerge(CscCalibToolCfg(inputFlags))
cscClusMonAlg.CscCalibTool = calibtool
from MuonConfig.MuonSegmentFindingConfig import CalibCscStripFitterCfg
stripfitter = result.popToolsAndMerge(CalibCscStripFitterCfg(inputFlags))
cscClusMonAlg.CSCStripFitter = stripfitter
cscPrdMonAlg.CSCStripFitter = stripfitter
# Add a generic monitoring tool (a "group" in old language). The returned
# object here is the standard GenericMonitoringTool.
cscClusGroup = helper.addGroup(cscClusMonAlg, 'CscClusMonitor',
'Muon/MuonRawDataMonitoring/CSC/')
cscPrdGroup = helper.addGroup(cscPrdMonAlg, 'CscPrdMonitor',
'Muon/MuonRawDataMonitoring/CSC/')
# cscSegmGroup = helper.addGroup(cscSegmMonAlg,'CscSegmMonitor','Muon/MuonRawDataMonitoring/CSC/')
### STEP 5 ###
# Configure histograms
qmaxCut = str(cscClusMonAlg.CSCQmaxCutADC)
#Cluster
cscClusGroup.defineHistogram('z,r;h2csc_clus_r_vs_z_hitmap',
type='TH2F',
title='R vs. Z Cluster hitmap;z(mm);R(mm)',
path='Clusters/Shift',
xbins=200,
xmin=-10000.,
xmax=10000.,
ybins=40,
ymin=0.,
ymax=4000.)
cscClusGroup.defineHistogram('y,x;h2csc_clus_y_vs_x_hitmap',
type='TH2F',
title='X vs. Y Cluster hitmap;y(mm);x(mm)',
path='Clusters/Shift',
xbins=100,
xmin=-5000.,
xmax=5000.,
ybins=100,
ymin=-5000,
ymax=5000)
cscClusGroup.defineHistogram(
'noStrips,secLayer;h2csc_clus_phicluswidth',
type='TH2F',
cutmask='clus_phi',
title='Phi-Cluster width;# strips;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=48,
xmin=0,
xmax=48,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'noStrips,secLayer;h2csc_clus_etacluswidth',
type='TH2F',
cutmask='clus_eta',
title='Eta-Cluster width;# strips;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=192,
xmin=0,
xmax=192,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'stripid,secLayer;h2csc_clus_hitmap',
type='TH2F',
title='Cluster occupancy;channel;[sector]+[0.2 #times layer]',
path='Clusters/Expert',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'fStripIDs_col,secLayer;h2csc_clus_hitmap_signal',
cutmask='signal_mon',
type='TH2F',
title='Cluster occupancy, Qmax > ' + qmaxCut +
' counts;channel;[sector] + [0.2 #times layer]',
path='Clusters/Shift',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'noStrips,secLayer;h2csc_clus_phicluswidth_signal',
type='TH2F',
cutmask='clus_phiSig',
title='#phi-cluster width, Qmax > ' + qmaxCut +
' counts;# strips;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=48,
xmin=0,
xmax=48,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'noStrips,secLayer;h2csc_clus_etacluswidth_signal',
type='TH2F',
cutmask='clus_etaSig',
title='#eta-cluster width, Qmax > ' + qmaxCut +
' counts;# strips;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=192,
xmin=0,
xmax=192,
ybins=175,
ymin=-17,
ymax=18)
thisLabelx = getCSCLabelx("labels_clus_occupancy_signal_EA")
cscClusGroup.defineHistogram('secLayer;h1csc_clus_occupancy_signal_EA',
type='TH1F',
cutmask='sideA',
title='EndCap A: Layer occupancy, Qmax > ' +
qmaxCut + ' counts;;entries/layer',
path='Overview/CSCEA/Cluster',
xbins=90,
xmin=0,
xmax=18,
xlabels=thisLabelx)
thisLabelx = getCSCLabelx("labels_clus_occupancy_signal_EC")
cscClusGroup.defineHistogram('secLayer;h1csc_clus_occupancy_signal_EC',
type='TH1F',
cutmask='sideC',
title='EndCap C: Layer occupancy, Qmax > ' +
qmaxCut + ' counts;;entries/layer',
path='Overview/CSCEC/Cluster',
xbins=85,
xmin=-17.,
xmax=0.,
xlabels=thisLabelx)
cscClusGroup.defineHistogram(
'fStripIDs_col,secLayer;h2csc_clus_hitmap_noise',
cutmask='noise_mon',
type='TH2F',
title='Cluster occupancy, Qmax #leq ' + qmaxCut +
' counts;channel;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'noStrips,secLayer;h2csc_clus_phicluswidth_noise',
type='TH2F',
cutmask='clus_phiNoise',
title='#phi-cluster width, Qmax #leq ' + qmaxCut +
' counts;# strips;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=48,
xmin=0,
xmax=48,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'noStrips,secLayer;h2csc_clus_etacluswidth_noise',
type='TH2F',
cutmask='clus_etaNoise',
title='#eta-cluster width, Qmax #leq ' + qmaxCut +
' counts;# strips;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=192,
xmin=0,
xmax=192,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'QmaxADC,secLayer;h2csc_clus_qmax',
type='TH2F',
title=
'Cluster peak-strip charge, Qmax;counts;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'QmaxADC,secLayer;h2csc_clus_qmax_signal',
cutmask='signal_mon',
type='TH2F',
title='Cluster peak-strip charge, Qmax > ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Clusters/Shift',
xbins=400,
xmin=0,
xmax=8000,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'QmaxADC,secLayer;h2csc_clus_qmax_noise',
cutmask='noise_mon',
type='TH2F',
title='Cluster peak-strip charge, Qmax #leq ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'QmaxADC,secLayer;h2csc_clus_qmax_signal_EA',
cutmask='sideA',
type='TH2F',
title='EndCap A: Cluster peak-strip charge, Qmax > ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Overview/CSCEA/Cluster',
xbins=400,
xmin=0,
xmax=8000,
ybins=90,
ymin=0,
ymax=18)
cscClusGroup.defineHistogram(
'QmaxADC;h1csc_clus_qmax_signal_EA_count',
cutmask='sideA',
type='TH1F',
title='EndCap A: Cluster peak-strip charge, Qmax > ' + qmaxCut +
' counts;counts;entries/20 counts;',
path='Overview/CSCEA/Cluster',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'QmaxADC,secLayer;h2csc_clus_qmax_signal_EC',
cutmask='sideC',
type='TH2F',
title='EndCap C: Cluster peak-strip charge, Qmax > ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Overview/CSCEC/Cluster',
xbins=400,
xmin=0,
xmax=8000,
ybins=90,
ymin=0,
ymax=18)
cscClusGroup.defineHistogram(
'QmaxADC;h1csc_clus_qmax_signal_EC_count',
cutmask='sideC',
type='TH1F',
title='EndCap C: Cluster peak-strip charge, Qmax > ' + qmaxCut +
' counts;counts;entries/20 counts;',
path='Overview/CSCEC/Cluster',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'QsumADC,secLayer;h2csc_clus_qsum',
type='TH2F',
title='Cluster charge (Qsum);counts;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'QsumADC,secLayer;h2csc_clus_qsum_signal',
cutmask='signal_mon',
type='TH2F',
title='Cluster charge(Qsum), Qmax > ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Clusters/Shift',
xbins=400,
xmin=0,
xmax=8000,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'QsumADC,secLayer;h2csc_clus_qsum_signal_EA',
cutmask='sideA',
type='TH2F',
title='EndCap A: Cluster charge(Qsum), Qmax > ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Overview/CSCEA/Cluster',
xbins=400,
xmin=0,
xmax=8000,
ybins=90,
ymin=0,
ymax=18)
cscClusGroup.defineHistogram(
'QsumADC;h1csc_clus_qsum_signal_EA_count',
cutmask='sideA',
type='TH1F',
title='EndCap A: Cluster charge(Qsum), Qmax > ' + qmaxCut +
' counts;counts;entries/20 counts;',
path='Overview/CSCEA/Cluster',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'QsumADC;h2csc_clus_qsum_signal_EC',
cutmask='sideC',
type='TH1F',
title='EndCap C: Cluster charge(Qsum), Qmax > ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Overview/CSCEC/Cluster',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'QsumADC;h1csc_clus_qsum_signal_EC_count',
cutmask='sideC',
type='TH1F',
title='EndCap C: Cluster charge(Qsum), Qmax > ' + qmaxCut +
' counts;counts;entries/20 counts;',
path='Overview/CSCEC/Cluster',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'QsumADC,secLayer;h2csc_clus_qsum_noise',
cutmask='noise_mon',
type='TH2F',
title='Cluster charge(Qsum), Qmax #leq ' + qmaxCut +
' counts;counts;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000,
ybins=175,
ymin=-17,
ymax=18)
cscClusGroup.defineHistogram(
'clu_time;h1csc_clus_transverse_time',
cutmask='clus_phi',
type='TH1F',
title='#phi-cluster sampling time;ns;entries/ns',
path='Clusters/Expert',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_charge_kiloele;h1csc_clus_transverse_charge',
cutmask='clus_phi',
type='TH1F',
title='#phi-cluster charge;counts;entries/count',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram('clu_time;h1csc_clus_transverse_time_signal',
cutmask='clus_phiSig',
type='TH1F',
title='#phi-cluster sampling time, Qmax > ' +
qmaxCut + ' counts;ns;entries/ns',
path='Clusters/Expert',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_charge_kiloele;h1csc_clus_transverse_charge_signal',
cutmask='clus_phiSig',
type='TH1F',
title='#phi-cluster charge, Qmax > ' + qmaxCut +
' counts;counts;entries/count',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'clu_time;h1csc_clus_transverse_time_noise',
cutmask='clus_phiNoise',
type='TH1F',
title='#phi-cluster sampling time, Qmax #leq ' + qmaxCut +
' counts;ns;entries/ns',
path='Clusters/Expert',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_charge_kiloele;h1csc_clus_transverse_charge_noise',
cutmask='clus_phiNoise',
type='TH1F',
title='#phi-cluster charge, Qmax #leq ' + qmaxCut +
' counts;counts;entries/count',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'clu_time;h1csc_clus_precision_time',
cutmask='clus_eta',
type='TH1F',
title='#eta-cluster sampling time;ns;entries/ns',
path='Clusters/Expert',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_charge_kiloele;h1csc_clus_precision_charge',
cutmask='clus_eta',
type='TH1F',
title='eta-cluster charge;counts;entries/count',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram('clu_time;h1csc_clus_precision_time_signal',
cutmask='clus_etaSig',
type='TH1F',
title='#eta-cluster sampling time, Qmax > ' +
qmaxCut + ' counts;ns;entries/ns',
path='Clusters/Shift',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_charge_kiloele;h1csc_clus_precision_charge_signal',
cutmask='clus_etaSig',
type='TH1F',
title='#eta-cluster charge, Qmax > ' + qmaxCut +
' counts;counts;entries/count',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'clu_time;h1csc_clus_precision_time_signal_EA',
cutmask='sideA',
type='TH1F',
title='EndCap A: #eta-cluster sampling time, Qmax > ' + qmaxCut +
' counts;ns;entries/ns',
path='Overview/CSCEA/Cluster',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_time;h1csc_clus_precision_time_signal_EC',
cutmask='sideC',
type='TH1F',
title='EndCap C: #eta-cluster sampling time, Qmax > ' + qmaxCut +
' counts;ns;entries/ns',
path='Overview/CSCEC/Cluster',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_time;h1csc_clus_precision_time_noise',
cutmask='clus_etaNoise',
type='TH1F',
title='#eta-cluster sampling time, Qmax #leq ' + qmaxCut +
' counts;ns;entries/ns',
path='Clusters/Expert',
xbins=260,
xmin=-60,
xmax=200)
cscClusGroup.defineHistogram(
'clu_charge_kiloele;h1csc_clus_precision_charge_noise',
cutmask='clus_etaNoise',
type='TH1F',
title='#eta-cluster charge, Qmax #leq ' + qmaxCut +
' counts;counts;entries/count',
path='Clusters/Expert',
xbins=400,
xmin=0,
xmax=8000)
cscClusGroup.defineHistogram(
'stripsSum_EA_mon;h1csc_clus_totalWidth_EA',
type='TH1F',
title=
'EndCap A: Cluster hits in all EA eta(#eta) & phi(#phi) strips;strips;cluster hits',
path='Overview/CSCEA/Cluster',
xbins=15360,
xmin=1.,
xmax=15361.)
cscClusGroup.defineHistogram(
'stripsSum_EC_mon;h1csc_clus_totalWidth_EC',
type='TH1F',
title=
'EndCap C: Cluster hits in all EC eta(#eta) & phi(#phi) strips;strips;cluster hits',
path='Overview/CSCEC/Cluster',
xbins=15360,
xmin=1.,
xmax=15361.)
cscClusGroup.defineHistogram(
'nPhiClusWidthCnt_mon,nEtaClusWidthCnt_mon;h2csc_clus_eta_vs_phi_cluswidth',
type='TH2F',
title=
'Eta vs. Phi Cluster width correlation;#varphi-cluster width;#eta-cluster width',
path='Clusters/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
cscClusGroup.defineHistogram(
'count_mon,secLayer;h2csc_clus_phicluscount',
cutmask='mphi_true',
type='TH2F',
title='#phi-cluster count;# clusters;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=20,
xmin=0,
xmax=20,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'scount_mon,secLayer;h2csc_clus_phicluscount_signal',
cutmask='scount_phi_true',
type='TH2F',
title='#phi-cluster count;# clusters;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=20,
xmin=0,
xmax=20,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'count_diff,secLayer;h2csc_clus_phicluscount_noise',
cutmask='scount_phi_false',
type='TH2F',
title='#phi-cluster count, Qmax #leq ' + qmaxCut +
' counts;# clusters;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=20,
xmin=0,
xmax=20,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'count_mon,secLayer;h2csc_clus_etacluscount',
cutmask='mphi_false',
type='TH2F',
title='#eta-cluster count;# clusters;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=20,
xmin=0,
xmax=20,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'scount_mon,secLayer;h2csc_clus_etacluscount_signal',
cutmask='scount_eta_true',
type='TH2F',
title='#eta-cluster count;# clusters;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=20,
xmin=0,
xmax=20,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'count_diff,secLayer;h2csc_clus_etacluscount_noise',
cutmask='scount_eta_false',
type='TH2F',
title='#eta-cluster count, Qmax #leq ' + qmaxCut +
' counts;# clusters;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=20,
xmin=0,
xmax=20,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'segNum_mon,sec_mon;h2csc_clus_segmap_signal',
type='TH2F',
title='Segment occupancy, Qmax > ' + qmaxCut +
' counts;segment;[sector] + [0.2 #times layer]',
path='Clusters/Expert',
xbins=16,
xmin=-0.5,
xmax=15.5,
ybins=175,
ymin=-17.,
ymax=18.)
cscClusGroup.defineHistogram(
'numphi_numeta_mon;h1csc_clus_count',
type='TH1F',
title='Clusters per event;no.of clusters;entries',
path='Clusters/Expert',
xbins=26,
xmin=-1,
xmax=25)
cscClusGroup.defineHistogram(
'numphi_numeta_sig_mon;h1csc_clus_count_signal',
type='TH1F',
title='Clusters per event, Qmax > ' + qmaxCut +
' counts;no.of clusters;entries',
path='Clusters/Expert',
xbins=26,
xmin=-1,
xmax=25)
cscClusGroup.defineHistogram('num_num_noise_mon;h1csc_clus_count_noise',
type='TH1F',
title='Clusters per event, Qmax #leq ' +
qmaxCut + ' counts;no.of clusters;entries',
path='Clusters/Expert',
xbins=26,
xmin=-1,
xmax=25)
cscClusGroup.defineHistogram(
'numphi_mon,numeta_mon;h2csc_clus_eta_vs_phi_cluscount',
type='TH2F',
title=
'Eta vs. Phi Cluster count correlation;#varphi-cluster count;#eta-cluster count',
path='Clusters/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
cscClusGroup.defineHistogram(
'numphi_sig_mon,numeta_sig_mon;h2csc_clus_eta_vs_phi_cluscount_signal',
type='TH2F',
title=
'Eta vs. Phi Signal-Cluster count correlation;#varphi-cluster count;#eta-cluster count',
path='Clusters/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
cscClusGroup.defineHistogram(
'numphi_diff_mon,numeta_diff_mon;h2csc_clus_eta_vs_phi_cluscount_noise',
type='TH2F',
title=
'Eta vs. Phi Noise-Cluster count correlation;#varphi-cluster count;#eta-cluster count',
path='Clusters/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
#PRD
cscPrdGroup.defineHistogram(
'spid, secLayer;h2csc_prd_hitmap',
type='TH2F',
title='Hit Occupancy; channel; [sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'noStrips,secLayer;h2csc_prd_phicluswidth',
type='TH2F',
cutmask='measphi',
title=
'PRD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=48,
xmin=0,
xmax=48,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'noStrips,secLayer;h2csc_prd_etacluswidth',
type='TH2F',
cutmask='measeta',
title=
'PRD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=192,
xmin=0,
xmax=192,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram('z,r;h2csc_prd_r_vs_z_hitmap',
type='TH2F',
title='R vs. Z Cluster hitmap;z(mm);R(mm)',
path='PRD/Shift',
xbins=200,
xmin=-10000.,
xmax=10000.,
ybins=40,
ymin=0.,
ymax=4000.)
cscPrdGroup.defineHistogram('y,x;h2csc_prd_y_vs_x_hitmap',
type='TH2F',
title='Y vs. X Cluster hitmap;x(mm);y(mm)',
path='PRD/Shift',
xbins=100,
xmin=-5000.,
xmax=5000.,
ybins=100,
ymin=-5000.,
ymax=5000.)
cscPrdGroup.defineHistogram(
'spid,secLayer;h2csc_prd_hitmap_signal',
cutmask='signal_mon',
type='TH2F',
title='Signal Occupancy;channel;[sector] + [0.2 #times layer]',
path='PRD/Shift',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'spid,secLayer;h2csc_prd_hitmap_signal_EC',
cutmask='sideC',
type='TH2F',
title=
'EndCap C: Signal Occupancy;channel;[sector] + [0.2 #times layer]',
path='Overview/CSCEC/PRD',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=85,
ymin=-17.,
ymax=0.)
cscPrdGroup.defineHistogram(
'spid;h1csc_prd_hitmap_signal_EC_count',
cutmask='sideC',
type='TH1F',
title='EndCap C: Signal Occupancy;channel;entries/channel;',
path='Overview/CSCEC/PRD',
xbins=242,
xmin=-49.,
xmax=193.)
thisLabelx = getCSCLabelx("labels_clus_occupancy_signal_EC")
cscPrdGroup.defineHistogram(
'secLayer;h1csc_prd_hitmap_signal_EC_occupancy',
cutmask='sideC',
type='TH1F',
title='EndCap C: Signal Occupancy;;entries/layer',
path='Overview/CSCEC/PRD',
xbins=85,
xmin=-17.,
xmax=0.,
xlabels=thisLabelx) #labels
cscPrdGroup.defineHistogram(
'lumiblock_mon,secLayer;h2csc_prd_occvslb_EC',
cutmask='sideC',
type='TH2F',
title=
'EndCap C: Layer Signal Occupancy Per LB;LB;[sector] + [0.2 #times layer]',
path='Overview/CSCEC/PRD',
xbins=2510,
xmin=-10.,
xmax=2500.,
ybins=85,
ymin=-17.,
ymax=0.)
cscPrdGroup.defineHistogram(
'spid,secLayer;h2csc_prd_hitmap_signal_EA',
cutmask='sideA',
type='TH2F',
title=
'EndCap A: Signal Occupancy;channel;[sector] + [0.2 #times layer]',
path='Overview/CSCEA/PRD',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=90,
ymin=0.,
ymax=18.)
cscPrdGroup.defineHistogram(
'spid;h1csc_prd_hitmap_signal_EA_count',
cutmask='sideA',
type='TH1F',
title='EndCap A: Signal Occupancy;channel;entries/channel;',
path='Overview/CSCEA/PRD',
xbins=242,
xmin=-49.,
xmax=193.)
thisLabelx = getCSCLabelx("labels_clus_occupancy_signal_EA")
cscPrdGroup.defineHistogram(
'secLayer;h1csc_prd_hitmap_signal_EA_occupancy',
cutmask='sideA',
type='TH1F',
title='EndCap A: Signal Occupancy;;entries/layer',
path='Overview/CSCEA/PRD',
xbins=90,
xmin=0.,
xmax=18.,
xlabels=thisLabelx) #labels
cscPrdGroup.defineHistogram(
'lumiblock_mon,secLayer;h2csc_prd_occvslb_EA',
cutmask='sideA',
type='TH2F',
title=
'EndCap A: Layer Signal Occupancy Per LB;LB;[sector] + [0.2 #times layer]',
path='Overview/CSCEA/PRD',
xbins=2510,
xmin=-10.,
xmax=2500.,
ybins=90,
ymin=0.,
ymax=18.)
cscPrdGroup.defineHistogram(
'noStrips,secLayer;h2csc_prd_etacluswidth_signal',
cutmask='clus_etaSig',
type='TH2F',
title=
'PRD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=192,
xmin=0.,
xmax=192.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'noStrips,secLayer;h2csc_prd_phicluswidth_signal',
cutmask='clus_phiSig',
type='TH2F',
title=
'PRD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=48,
xmin=0.,
xmax=48.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'spid,secLayer;h2csc_prd_hitmap_noise',
cutmask='noise_mon',
type='TH2F',
title='Noise Occupancy;channel;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=242,
xmin=-49.,
xmax=193.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'noStrips,secLayer;h2csc_prd_etacluswidth_noise',
cutmask='clus_etaNoise',
type='TH2F',
title=
'PRD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=192,
xmin=0.,
xmax=192.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'noStrips,secLayer;h2csc_prd_phicluswidth_noise',
cutmask='clus_phiNoise',
type='TH2F',
title=
'PRD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=48,
xmin=0.,
xmax=48.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'count_mon,secLayer;h2csc_prd_phicluscount',
cutmask='mphi_true',
type='TH2F',
title=
'PRD transverse-cluster count;no.of clusters;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=20,
xmin=0.,
xmax=20.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'scount_mon,secLayer;h2csc_prd_phicluscount_signal',
cutmask='scount_phi_true',
type='TH2F',
title=
'PRD transverse-cluster count;no.of clusters;[sector] + [0.2 #times layer]',
path='PRD/Shift',
xbins=20,
xmin=0.,
xmax=20.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'tmp_val_mon,secLayer;h2csc_prd_phicluscount_noise',
cutmask='mphi_true',
type='TH2F',
title=
'PRD transverse-cluster count;no.of clusters;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=20,
xmin=0.,
xmax=20.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'count_mon,secLayer;h2csc_prd_etacluscount',
cutmask='mphi_false',
type='TH2F',
title=
'PRD precision-cluster count;no.of clusters;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=20,
xmin=0.,
xmax=20.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'scount_mon,secLayer;h2csc_prd_etacluscount_signal',
cutmask='scount_eta_true',
type='TH2F',
title=
'PRD precision-cluster count;no.of clusters;[sector] + [0.2 #times layer]',
path='PRD/Shift',
xbins=20,
xmin=0.,
xmax=20.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'tmp_val_mon,secLayer;h2csc_prd_etacluscount_noise',
cutmask='mphi_false',
type='TH2F',
title=
'PRD precision-cluster count;no.of clusters;[sector] + [0.2 #times layer]',
path='PRD/Expert',
xbins=20,
xmin=0.,
xmax=20.,
ybins=175,
ymin=-17.,
ymax=18.)
cscPrdGroup.defineHistogram(
'numphi_mon,numeta_mon;h2csc_prd_eta_vs_phi_cluscount',
type='TH2F',
title=
'Eta vs. Phi Cluster count correlation;#varphi-cluster count;#eta-cluster count',
path='PRD/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
cscPrdGroup.defineHistogram(
'numphi_sig_mon,numeta_sig_mon;h2csc_prd_eta_vs_phi_cluscount_signal',
type='TH2F',
title=
'Eta vs. Phi Signal-Cluster count correlation;#varphi-cluster count;#eta-cluster count',
path='PRD/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
cscPrdGroup.defineHistogram(
'numphi_diff_mon,numeta_diff_mon;h2csc_prd_eta_vs_phi_cluscount_noise',
type='TH2F',
title=
'Eta vs. Phi Noise-Cluster count correlation;#varphi-cluster count;#eta-cluster count',
path='PRD/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
cscClusGroup.defineHistogram(
'nPhiClusWidthCnt_mon,nEtaClusWidthCnt_mon;h2csc_prd_eta_vs_phi_cluswidth',
type='TH2F',
title=
'Eta vs. Phi Cluster width correlation;#varphi-cluster width;#eta-cluster width',
path='PRD/Expert',
xbins=100,
xmin=0,
xmax=100,
ybins=100,
ymin=0,
ymax=100)
#myGroup.defineHistogram('lb', title='Luminosity Block;lb;Events',
# path='ToFindThem',xbins=1000,xmin=-0.5,xmax=999.5,weight='testweight')
#myGroup.defineHistogram('random', title='LB;x;Events',
# path='ToBringThemAll',xbins=30,xmin=0,xmax=1,opt='kLBNHistoryDepth=10')
#myGroup.defineHistogram('random', title='title;x;y',path='ToBringThemAll',
# xbins=[0,.1,.2,.4,.8,1.6])
##myGroup.defineHistogram('random,pT', type='TH2F', title='title;x;y',path='ToBringThemAll',
# xbins=[0,.1,.2,.4,.8,1.6],ybins=[0,10,30,40,60,70,90])
# TEfficiencies
##myGroup.defineHistogram('pT_passed,pT', type='TEfficiency', title='Test TEfficiency;x;Eff',
# path='AndInTheDarkness', xbins=100, xmin=0.0, xmax=50.0)
#myGroup.defineHistogram('pT_passed,pT,random', type='TEfficiency', title='Test TEfficiency 2D;x;y;Eff',
# path='AndInTheDarkness', xbins=100, xmin=0.0, xmax=50.0,
# ybins=10, ymin=0.0, ymax=2.0)
# # use a cutmask to only fill certain events
#myGroup.defineHistogram('pT;pT_with_cut', title='p_{T};p_{T};Events', path='AndInTheDarkness',
# xbins=50, xmin=0, xmax=50, cutmask='pT_passed')
# make a TTree
#myGroup.defineTree('pT,lb,pT_vec,strvec,str;testtree', path='BindThem',
# treedef='pT/F:lb/i:pT_vec/vector<float>:strvec/vector<string>:str/string')
#anotherGroup.defineHistogram('lbWithFilter',title='Lumi;lb;Events',
# path='top',xbins=1000,xmin=-0.5,xmax=999.5)
#anotherGroup.defineHistogram('run',title='Run Number;run;Events',
# path='top',xbins=1000000,xmin=-0.5,xmax=999999.5)
# Example defining an array of histograms. This is useful if one seeks to create a
# number of histograms in an organized manner. (For instance, one plot for each ASIC
# in the subdetector, and these components are mapped in eta, phi, and layer.) Thus,
# one might have an array of TH1's such as quantity[etaIndex][phiIndex][layerIndex].
# for alg in [exampleMonAlg,anotherExampleMonAlg]:
# Using an array of groups
# topPath = 'OneRing' if alg == exampleMonAlg else ''
# array = helper.addArray([2],alg,'ExampleMonitor', topPath=topPath)
# array.defineHistogram('a,b',title='AB',type='TH2F',path='Eta',
# xbins=10,xmin=0.0,xmax=10.0,
# ybins=10,ymin=0.0,ymax=10.0)
# array.defineHistogram('c',title='C',path='Eta',
# xbins=10,xmin=0.0,xmax=10.0)
# array = helper.addArray([4,2],alg,'ExampleMonitor', topPath=topPath)
# array.defineHistogram('a',title='A',path='EtaPhi',
# xbins=10,xmin=0.0,xmax=10.0)
# Using a map of groups
# layerList = ['layer1','layer2']
# clusterList = ['clusterX','clusterB']
# array = helper.addArray([layerList],alg,'ExampleMonitor', topPath=topPath)
# array.defineHistogram('c',title='C',path='Layer',
# xbins=10,xmin=0,xmax=10.0)
# array = helper.addArray([layerList,clusterList],alg,'ExampleMonitor', topPath=topPath)
# array.defineHistogram('c',title='C',path='LayerCluster',
# xbins=10,xmin=0,xmax=10.0)
### STEP 6 ###
# Finalize. The return value should be a tuple of the ComponentAccumulator
# and the sequence containing the created algorithms. If we haven't called
# any configuration other than the AthMonitorCfgHelper here, then we can
# just return directly (and not create "result" above)
#return helper.result()
# # Otherwise, merge with result object and return
acc = helper.result()
result.merge(acc)
return result