def RpcPrepDataProviderTool(name="RpcPrepDataProviderTool", **kwargs):
global source
# setup dependencies which are not yet in C++
import MuonCnvExample.MuonCablingConfig
# If we run trigger from BS, then the RDO to PRD tools need to automatically run BS to RDO tools
kwargs.setdefault("useBStoRdoTool",
DetFlags.readRDOBS.RPC_on() and recAlgs.doTrigger())
kwargs.setdefault("RawDataProviderTool", "RpcRawDataProviderTool")
### TODO: in C++ do not retrieve tool if useBStoRdoTool==False
## if not kwargs["useBStoRdoTool"]:
## kwargs["RawDataProviderTool"] = None # empty tool
if source == 'data':
kwargs["processingData"] = True
kwargs["reduceCablingOverlap"] = True
kwargs["produceRpcCoinDatafromTriggerWords"] = True
kwargs["overlap_timeTolerance"] = 1000
kwargs["solvePhiAmbiguities"] = True
kwargs["etaphi_coincidenceTime"] = 1000
elif source == 'geant4':
pass
#kwargs["etaphi_coincidenceTime"] = 100
else:
raise ValueError("RpcPrepDataProviderTool: unsupported dataSource %s" %
source)
from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool
return Muon__RpcRdoToPrepDataTool(name, **kwargs)
AlgSequence(
).RPC_Digitizer.RPC_DigitizationTool.turnON_efficiency = 0 # gaps and panels always efficient
AlgSequence(
).RPC_Digitizer.RPC_DigitizationTool.Efficiency_fromCOOL = 0 # irrelevant since the above
AlgSequence(
).RPC_Digitizer.RPC_DigitizationTool.turnON_clustersize = 1 # gaps and panels always efficient
AlgSequence(
).RPC_Digitizer.RPC_DigitizationTool.ClusterSize_fromCOOL = 0 # irrelevant since the above
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
######################## RPC rdo to prd
from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool
RpcRdoToPrepDataTool = Muon__RpcRdoToPrepDataTool("RpcPrepDataProviderTool")
# property had to be removed for technical reasons
# RpcRdoToPrepDataTool.dumpOffToOnlineMapToFile = False
ToolSvc += RpcRdoToPrepDataTool
from MuonRdoToPrepData.MuonRdoToPrepDataConf import RpcRdoToRpcPrepData
RpcRdoToRpcPrepData = RpcRdoToRpcPrepData()
RpcRdoToRpcPrepData.PrintPrepData = False
from RegionSelector.RegSelToolConfig import makeRegSelTool_RPC
RpcRdoToRpcPrepData.RegSel_RPC = makeRegSelTool_RPC()
topSequence += RpcRdoToRpcPrepData
######################## end of RPC rdo to prd
######################## CSC rdo to prd and clusterization
#
def __init__(self, name="TrigMuonEFStandaloneTrackTool", **kwargs):
super(TrigMuonEFStandaloneTrackToolConfig,
self).__init__(name, **kwargs)
if MuonGeometryFlags.hasCSC():
self.CscClusterProvider = CfgGetter.getPublicTool(
"CscThresholdClusterBuilderTool")
self.SegmentsFinderTool = CfgGetter.getPublicToolClone(
"TMEF_SegmentsFinderTool",
"MooSegmentFinder",
HoughPatternFinder=CfgGetter.getPublicTool("MuonLayerHoughTool"),
Csc2dSegmentMaker=("Csc2dSegmentMaker/Csc2dSegmentMaker"
if MuonGeometryFlags.hasCSC() else ""),
Csc4dSegmentMaker=("Csc4dSegmentMaker/Csc4dSegmentMaker"
if MuonGeometryFlags.hasCSC() else ""))
CfgGetter.getPublicTool("MuonHoughPatternFinderTool").RecordAll = False
CfgGetter.getPublicTool("MuonLayerHoughTool").DoTruth = False
CfgGetter.getPublicTool("MooTrackFitter").SLFit = False
self.MdtRawDataProvider = "TMEF_MdtRawDataProviderTool"
self.CscRawDataProvider = "TMEF_CscRawDataProviderTool"
self.RpcRawDataProvider = "TMEF_RpcRawDataProviderTool"
self.TgcRawDataProvider = "TMEF_TgcRawDataProviderTool"
#Need to run non-MT version of decoding tools in the trigger since the caching is not available in MT versions
#Need different PRD container names to run offline and trigger in same jobs, but there are many tools that depend on these containers...
#Since this is legacy code only used for validation comparisons against the Run 3 triggers, will do the not-particularly-nice solution of
#creating containers with unique names only if we are running offline and trigger in the same jobs, and otherwise just use the default names.
#This means that the trigger output when running the trigger as part of RAWtoESD is not 100% correct (the pattern finding uses the correct containers,
#so it's a small effect overall anyway), but that's an use case not currently needed for trigger validation purposes
from AthenaCommon.AppMgr import ToolSvc
#MDT
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool
from MuonCSC_CnvTools.MuonCSC_CnvToolsConf import Muon__CscRdoToCscPrepDataTool
from MuonTGC_CnvTools.MuonTGC_CnvToolsConf import Muon__TgcRdoToPrepDataTool
from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool
MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool(
name="TrigEFMdtRdoToPrepDataTool")
CscRdoToCscPrepDataTool = Muon__CscRdoToCscPrepDataTool(
name="TrigEFCscRdoToPrepDataTool")
TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataTool(
name="TrigEFTgcRdoToPrepDataTool")
RpcRdoToRpcPrepDataTool = Muon__RpcRdoToPrepDataTool(
name="TrigEFRpcRdoToPrepDataTool")
if not rec.doRDOTrigger and rec.doESD:
MdtRdoToMdtPrepDataTool.OutputCollection = "TrigMDT_DriftCircles"
CscRdoToCscPrepDataTool.OutputCollection = "TrigCSC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCollection = "TrigTGC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigerT1CoinDataCollection"
RpcRdoToRpcPrepDataTool.TriggerOutputCollection = "TrigRPC_Measurements"
#InputCollection is really the output RPC coin collection...
RpcRdoToRpcPrepDataTool.InputCollection = "TrigRPC_triggerHits"
else:
MdtRdoToMdtPrepDataTool.OutputCollection = "MDT_DriftCircles"
CscRdoToCscPrepDataTool.OutputCollection = "CSC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCollection = "TGC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigT1CoinDataCollection"
RpcRdoToRpcPrepDataTool.TriggerOutputCollection = "RPC_Measurements"
RpcRdoToRpcPrepDataTool.InputCollection = "RPC_triggerHits"
ToolSvc += MdtRdoToMdtPrepDataTool
self.MdtPrepDataContainer = MdtRdoToMdtPrepDataTool.OutputCollection
self.MdtPrepDataProvider = MdtRdoToMdtPrepDataTool
#CSC
ToolSvc += CscRdoToCscPrepDataTool
self.CscPrepDataProvider = CscRdoToCscPrepDataTool
#We use the clusters not the PRD hits directly for CSCs
self.CscPrepDataContainer = "CSC_Clusters"
#TGC
ToolSvc += TgcRdoToTgcPrepDataTool
self.TgcPrepDataProvider = TgcRdoToTgcPrepDataTool
self.TgcPrepDataContainer = TgcRdoToTgcPrepDataTool.OutputCollection
#RPC
ToolSvc += RpcRdoToRpcPrepDataTool
self.RpcPrepDataProvider = RpcRdoToRpcPrepDataTool
self.RpcPrepDataContainer = RpcRdoToRpcPrepDataTool.TriggerOutputCollection
self.DecodeMdtBS = DetFlags.readRDOBS.MDT_on()
self.DecodeRpcBS = DetFlags.readRDOBS.RPC_on()
self.DecodeTgcBS = DetFlags.readRDOBS.TGC_on()
if MuonGeometryFlags.hasCSC():
self.DecodeCscBS = DetFlags.readRDOBS.CSC_on()
# use seeded decoding
if (TriggerFlags.MuonSlice.doEFRoIDrivenAccess()):
self.useMdtSeededDecoding = True
self.useRpcSeededDecoding = True
self.useTgcSeededDecoding = True
if MuonGeometryFlags.hasCSC(): self.useCscSeededDecoding = True
# use ROB based seeded decoding instead of PRD based
self.useTgcRobDecoding = False # neither available nor needed
self.useCscRobDecoding = False # neither available nor needed
self.useRpcData = muonRecFlags.doRPCs()
self.useTgcData = muonRecFlags.doTGCs()
self.useCscData = muonRecFlags.doCSCs()
# to select barrel(useMdtData=2), endcap(useMdtData=3)
if muonRecFlags.doMDTs():
self.useMdtData = 1
else:
self.useMdtData = 0
self.useTGCInPriorNextBC = False
self.doTimeOutChecks = False
self.doTimeOutGuard = False
self.maxTgcHits = 0
self.maxCscHits = 0
self.maxRpcHits = 0
self.maxMdtHits = 0
self.doCache = True
self.IgnoreMisalginedCSCs = False
self.TrackBuilderTool = "TMEF_TrackBuilderTool"
self.TrkSummaryTool = "TMEF_TrackSummaryTool"
self.MuonCandidateTool = "TMEF_MuonCandidateTool"
self.TrackToTrackParticleConvTool = "MuonParticleCreatorTool"
import MuonCondAlg.MdtCondDbAlgConfig # noqa: F401 (MDT conditions, needed for the MuonStationIntersectSvc)
theDataPreparator.CSCDataPreparator.CscPrepDataProvider = CscRdoToCscPrepDataTool
theDataPreparator.CSCDataPreparator.CSCPrepDataContainer = CscRdoToCscPrepDataTool.OutputCollection
from MuonTGC_CnvTools.MuonTGC_CnvToolsConf import Muon__TgcRdoToPrepDataTool
TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataTool(
name="TrigTgcRdoToPrepDataTool",
OutputCollection="TrigTGC_Measurements",
OutputCoinCollection="TrigerT1CoinDataCollection")
ToolSvc += TgcRdoToTgcPrepDataTool
theDataPreparator.TGCDataPreparator.TgcPrepDataProvider = TgcRdoToTgcPrepDataTool
theDataPreparator.TGCDataPreparator.TGCPrepDataContainer = TgcRdoToTgcPrepDataTool.OutputCollection
from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool
#InputCollection is really the output RPC coin collection...
RpcRdoToRpcPrepDataTool = Muon__RpcRdoToPrepDataTool(
name="TrigRpcRdoToPrepDataTool",
TriggerOutputCollection="TrigRPC_Measurements",
InputCollection="TrigRPC_triggerHits")
ToolSvc += RpcRdoToRpcPrepDataTool
theDataPreparator.RPCDataPreparator.RpcPrepDataProvider = RpcRdoToRpcPrepDataTool
theDataPreparator.RPCDataPreparator.RpcPrepDataContainer = RpcRdoToRpcPrepDataTool.TriggerOutputCollection
if MuonGeometryFlags.hasSTGC():
from MuonSTGC_CnvTools.MuonSTGC_CnvToolsConf import Muon__StgcRdoToPrepDataTool
#InputCollection is really the output sTGC coin collection...
StgcRdoToStgcPrepDataTool = Muon__StgcRdoToPrepDataTool(
name="TrigStgcRdoToPrepDataTool",
TriggerOutputCollection="TrigSTGC_Measurements",
InputCollection="TrigSTGC_triggerHits")
ToolSvc += StgcRdoToStgcPrepDataTool
theDataPreparator.STGCDataPreparator.StgcPrepDataProvider = StgcRdoToStgcPrepDataTool
theDataPreparator.STGCDataPreparator.StgcPrepDataContainer = StgcRdoToStgcPrepDataTool.TriggerOutputCollection