Functions
	TMDBConfig (flags)
	MuonBytestream2RdoConfig (flags)
	MuonRdo2PrdConfig (flags)
	RecoMuonSegmentSequence (flags)
	MuonRdoToMuonDigitToolCfg (flags, name="MuonRdoToMuonDigitTool", **kwargs)
	MuonRdo2DigitConfig (flags)
	NSWTriggerConfig (flags)
	RPCTriggerConfig (flags)
	TGCTriggerConfig (flags)
	TGCModifierConfig (flags)
	MuctpiConfig (flags)
	Lvl1MuonSimulationCfg (flags)

Variables
	flags = initConfigFlags()
	Files
	MaxEvents
	NumThreads
	triggerMenuSetup
	acc = MainServicesCfg(flags)
	withDetails
	True
	summariseProps
	printDefaults

Function Documentation

◆ Lvl1MuonSimulationCfg()

python.Lvl1MuonSimulationConfig.Lvl1MuonSimulationCfg ( flags )

Definition at line 399 of file Lvl1MuonSimulationConfig.py.

def Lvl1MuonSimulationCfg(flags):
    acc = ComponentAccumulator()
 
    acc.merge(MuonBytestream2RdoConfig(flags)) # data prep for muon bytestream data
    acc.merge(MuonRdo2DigitConfig(flags)) # input for rpc/tgc trigger simulation
    acc.merge(RPCTriggerConfig(flags)) # rpc trigger simulation, including bis78 to prepare for bis78-tgc coincidence
    acc.merge(TMDBConfig(flags)) # for tmdb decision to prepare for tile-muon coincidence
    acc.merge(NSWTriggerConfig(flags)) # nsw trigger simulation to prepare input for nsw-tgc coincidence
    acc.merge(TGCTriggerConfig(flags)) # tgc trigger simulation
    acc.merge(MuonRdo2PrdConfig(flags)) # data prep for nsw-tgc coincidence emulator
    acc.merge(RecoMuonSegmentSequence(flags)) # segment reco for nsw-tgc coincidence emulator
    acc.merge(TGCModifierConfig(flags)) # overwrite output from tgc by nsw-tgc coincidence emulator
    acc.merge(MuctpiConfig(flags)) # muctpi simulation
 
    return acc
 

◆ MuctpiConfig()

python.Lvl1MuonSimulationConfig.MuctpiConfig ( flags )

Definition at line 372 of file Lvl1MuonSimulationConfig.py.

def MuctpiConfig(flags):
    acc = ComponentAccumulator()
    rpcRecRoiTool = CompFactory.LVL1.TrigT1RPCRecRoiTool("TrigT1RPCRecRoiTool", UseRun3Config=True)
    tgcRecRoiTool = CompFactory.LVL1.TrigT1TGCRecRoiTool("TrigT1TGCRecRoiTool", UseRun3Config=True)
    trigThresholdDecTool = CompFactory.LVL1.TrigThresholdDecisionTool(name="TrigThresholdDecisionTool",
                                                                       RPCRecRoiTool = rpcRecRoiTool,
                                                                       TGCRecRoiTool = tgcRecRoiTool)
    muctpiTool = CompFactory.LVL1MUCTPIPHASE1.MUCTPI_AthTool(name="MUCTPI_AthTool",
                                                              MuCTPICTPLocation = 'L1MuCTPItoCTPLocation',
                                                              OverlapStrategyName = flags.Trigger.MUCTPI.OverlapStrategy,
                                                              LUTXMLFile = flags.Trigger.MUCTPI.LUTXMLFile,
                                                              BarrelRoIFile = flags.Trigger.MUCTPI.BarrelRoIFile,
                                                              EndcapForwardRoIFile = flags.Trigger.MUCTPI.EndcapForwardRoIFile,
                                                              Side0LUTFile = flags.Trigger.MUCTPI.Side0LUTFile,
                                                              Side1LUTFile = flags.Trigger.MUCTPI.Side1LUTFile,
                                                              InputSource = 'DIGITIZATION',
                                                              RPCRecRoiTool = rpcRecRoiTool,
                                                              TGCRecRoiTool = tgcRecRoiTool,
                                                              TrigThresholdDecisionTool = trigThresholdDecTool)
    muctpiAlg = CompFactory.LVL1MUCTPIPHASE1.MUCTPI_AthAlg(name="MUCTPI_AthAlg",
                                                         MUCTPI_AthTool = muctpiTool)
    acc.addEventAlgo(muctpiAlg)
    from TrigConfigSvc.TrigConfigSvcCfg import L1ConfigSvcCfg
    acc.merge(L1ConfigSvcCfg(flags))
    return acc
 
 

◆ MuonBytestream2RdoConfig()

python.Lvl1MuonSimulationConfig.MuonBytestream2RdoConfig ( flags )

Definition at line 44 of file Lvl1MuonSimulationConfig.py.

def MuonBytestream2RdoConfig(flags):
    acc = ComponentAccumulator()
    if flags.Input.isMC:
        return acc
 
    postFix = "_L1MuonSim"
    from MuonConfig.MuonBytestreamDecodeConfig import MuonCacheNames
    cacheCreator = CompFactory.MuonCacheCreator(RpcCacheKey = MuonCacheNames.RpcCache,
                                                TgcCacheKey = MuonCacheNames.TgcCache,
                                                MdtCsmCacheKey = MuonCacheNames.MdtCsmCache,
                                                CscCacheKey = (MuonCacheNames.CscCache if flags.Detector.GeometryCSC else ""))
    acc.addEventAlgo(cacheCreator)
    # for RPC
    RPCRodDecoder = CompFactory.Muon.RpcROD_Decoder(name = "RpcROD_Decoder" + postFix, NOBXS=flags.Trigger.L1MuonSim.RPCNBX)
    MuonRpcRawDataProviderTool = CompFactory.Muon.RPC_RawDataProviderTool(name = "RPC_RawDataProviderTool" + postFix,
                                                                             RpcContainerCacheKey = MuonCacheNames.RpcCache,
                                                                             WriteOutRpcSectorLogic = False,
                                                                             Decoder = RPCRodDecoder,
                                                                             RdoLocation = "RPCPAD_L1" )
    RpcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "RpcRawDataProvider" + postFix,
                                                              ProviderTool = MuonRpcRawDataProviderTool,
                                                              UseHashIds = False,
                                                              DecodePerRoI = True)
    acc.addEventAlgo(RpcRawDataProvider)
    # for TGC
    TGCRodDecoder = CompFactory.Muon.TGC_RodDecoderReadout(name = "TGC_RodDecoderReadout" + postFix)
    MuonTgcRawDataProviderTool = CompFactory.Muon.TGC_RawDataProviderTool(name = "TGC_RawDataProviderTool" + postFix,
                                                                             TgcContainerCacheKey = MuonCacheNames.TgcCache,
                                                                             Decoder = TGCRodDecoder,
                                                                             RdoLocation = "TGCRDO_L1")
    TgcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "TgcRawDataProvider" + postFix,
                                                              ProviderTool = MuonTgcRawDataProviderTool,
                                                              UseHashIds = True,
                                                              DecodePerRoI = True)
    acc.addEventAlgo(TgcRawDataProvider)
    # for sTGC
    if flags.Detector.GeometrysTGC:
        from MuonConfig.MuonBytestreamDecodeConfig import sTgcRODDecoderCfg
        MuonsTgcRawDataProviderTool = CompFactory.Muon.STGC_RawDataProviderTool(name    = "STGC_RawDataProviderTool"+postFix,
                                                                       Decoder = acc.popToolsAndMerge(sTgcRODDecoderCfg(flags,
                                                                                                     name = "sTgcROD_Decoder"+postFix)),
                                                                       RdoLocation = "sTGCRDO_L1")
        sTgcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name       = "sTgcRawDataProvider"+postFix,
                                                        ProviderTool = MuonsTgcRawDataProviderTool,
                                                        UseHashIds = False,
                                                        DecodePerRoI = False)
        acc.addEventAlgo(sTgcRawDataProvider)
 
    # for MM
    if flags.Detector.GeometryMM:
        from MuonConfig.MuonBytestreamDecodeConfig import MmRDODDecoderCfg
        Muon_MM_RawDataProviderTool = CompFactory.Muon.MM_RawDataProviderTool
        MuonMmRawDataProviderTool = Muon_MM_RawDataProviderTool(name  = "MM_RawDataProviderTool"+postFix,
                                                                  Decoder = acc.popToolsAndMerge(MmRDODDecoderCfg(flags,
                                                                                                 name="MM_RODDecoder"+postFix)),
                                                                  RdoLocation = "MMRDO_L1")
        MmRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "MmRawDataProvider"+postFix,
                                                                   ProviderTool = MuonMmRawDataProviderTool,
                                                                   UseHashIds = False,
                                                                   DecodePerRoI = False)
        acc.addEventAlgo(MmRawDataProvider)
 
    if flags.Trigger.L1MuonSim.EmulateNSW and flags.Trigger.L1MuonSim.NSWVetoMode:
        # for MDT
        MDTRodDecoder = CompFactory.MdtROD_Decoder(name = "MdtROD_Decoder" + postFix)
        MuonMdtRawDataProviderTool = CompFactory.Muon.MDT_RawDataProviderTool(name = f"MDT_RawDataProviderTool{postFix}",
                                                                                CsmContainerCacheKey = MuonCacheNames.MdtCsmCache,
                                                                                Decoder = MDTRodDecoder,
                                                                                RdoLocation = "MDTCSM_L1")
        MdtRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "MdtRawDataProvider" + postFix,
                                                                 ProviderTool = MuonMdtRawDataProviderTool,
                                                                 UseHashIds = False,
                                                                 DecodePerRoI = True)
        acc.addEventAlgo(MdtRawDataProvider)
        # for CSC
        if flags.Detector.GeometryCSC:
            CSCRodDecoder = CompFactory.Muon.CscROD_Decoder(name = "CscROD_Decoder" + postFix,
                                                            IsCosmics = False,
                                                            IsOldCosmics = False )
            MuonCscRawDataProviderTool = CompFactory.Muon.CSC_RawDataProviderToolMT(name = "CSC_RawDataProviderToolMT" + postFix,
                                                                                    CscContainerCacheKey = MuonCacheNames.CscCache,
                                                                                    Decoder = CSCRodDecoder,
                                                                                    RdoLocation = "CSCRDO_L1" )
            CscRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "CscRawDataProvider" + postFix,
                                                                     ProviderTool = MuonCscRawDataProviderTool,
                                                                     UseHashIds = True,
                                                                     DecodePerRoI = True,
                                                                     RequireDetectorManager = True,
                                                                     DetectorManagerKey = "MuonDetectorManager",
                                                                     IgnoreMissingRoIs = True)
            acc.addEventAlgo(CscRawDataProvider)
 
    return acc
 

◆ MuonRdo2DigitConfig()

python.Lvl1MuonSimulationConfig.MuonRdo2DigitConfig ( flags )

Definition at line 219 of file Lvl1MuonSimulationConfig.py.

def MuonRdo2DigitConfig(flags):
    acc = ComponentAccumulator()
 
    from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
    acc.merge( AtlasFieldCacheCondAlgCfg(flags) )
    # Read RPCPAD and TGCRDO from the input POOL file (for BS it comes from [Rpc|Tgc]RawDataProvider)
    suffix = "" if flags.Input.Format is Format.POOL else "_L1"
    RPCRdoName = "RPCPAD"+suffix
    TGCRdoName = "TGCRDO"+suffix
    MMRdoName = "MMRDO"+suffix
    sTGCRdoName = "sTGCRDO"+suffix
 
    if flags.Input.Format is Format.POOL:
        rdoInputs = [('TgcRdoContainer','TGCRDO')]
        
        if 'RPCPAD' in flags.Input.Collections:
            rdoInputs += [('RpcPadContainer','RPCPAD')]
        # Read MMRDO and sTGCRDO
        if flags.Detector.GeometrysTGC or flags.Detector.GeometryMM:
            rdoInputs += [
                ('Muon::MM_RawDataContainer','MMRDO'),
                ('Muon::STGC_RawDataContainer','sTGCRDO')
            ]
        if flags.Muon.enableNRPC and ("NRPCRDO" in flags.Input.Collections):
            rdoInputs += [
                ('xAOD::NRPCRDOContainer' , 'NRPCRDO'),
                ('xAOD::NRPCRDOAuxContainer',  'NRPCRDOAux.')
            ]
        from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
        acc.merge(SGInputLoaderCfg(flags, Load=rdoInputs))
 
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags))
 
    from MuonConfig.MuonByteStreamCnvTestConfig import RpcRdoToRpcDigitCfg, TgcRdoToTgcDigitCfg, STGC_RdoToDigitCfg, MM_RdoToDigitCfg
 
    acc.merge(RpcRdoToRpcDigitCfg(flags, RpcDigitContainer = "RPC_DIGITS_L1", RpcRdoContainer = RPCRdoName ))
    acc.merge(TgcRdoToTgcDigitCfg(flags, TgcDigitContainer = "TGC_DIGITS_L1", TgcRdoContainer = TGCRdoName ))
    if flags.Detector.GeometrysTGC:
        acc.merge(STGC_RdoToDigitCfg(flags, sTgcRdoContainer = sTGCRdoName, sTgcDigitContainer = "sTGC_DIGITS_L1"))
    if flags.Detector.GeometryMM:
          acc.merge(MM_RdoToDigitCfg(flags, MmRdoContainer = MMRdoName,  MmDigitContainer = "MM_DIGITS_L1" ))
 
    return acc
 

◆ MuonRdo2PrdConfig()

python.Lvl1MuonSimulationConfig.MuonRdo2PrdConfig ( flags )

Definition at line 138 of file Lvl1MuonSimulationConfig.py.

def MuonRdo2PrdConfig(flags):
    acc = ComponentAccumulator()
    if not flags.Trigger.L1MuonSim.EmulateNSW or not flags.Trigger.L1MuonSim.NSWVetoMode:
        return acc
    postFix = "_L1MuonSim"
    suffix = "" if flags.Input.isMC else "_L1"
    if flags.Input.Format is Format.POOL:
        rdoInputs = [
            ('RpcPadContainer','RPCPAD'),
            ('TgcRdoContainer','TGCRDO'),
            ('CscRawDataContainer','CSCRDO'),
            ('MdtCsmContainer','MDTCSM')
        ]
        from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
        acc.merge(SGInputLoaderCfg(flags, Load=rdoInputs))
    
    if flags.Detector.GeometryCSC:
        from MuonConfig.MuonRdoDecodeConfig import CscRDODecodeCfg
        acc.merge(CscRDODecodeCfg(flags,name= "CscRdoToCscPrepData" + postFix, RDOContainer = "CSCRDO"+suffix))
        CscClusterBuilderTool = CompFactory.CscThresholdClusterBuilderTool(name = "CscThresholdClusterBuilderTool" + postFix)
        CscClusterBuilder = CompFactory.CscThresholdClusterBuilder(name = "CscThresholdClusterBuilder"+postFix,
                                                                   cluster_builder = CscClusterBuilderTool)
        acc.addEventAlgo(CscClusterBuilder)
    
    from MuonConfig.MuonRdoDecodeConfig import MdtRDODecodeCfg
    acc.merge(MdtRDODecodeCfg(flags, name = "MdtRdoToMdtPrepData" + postFix,
                                     RDOContainer = "MDTCSM"+suffix ))
    
    from MuonConfig.MuonRdoDecodeConfig import RpcRDODecodeCfg
    acc.merge(RpcRDODecodeCfg(flags, name = "RpcRdoToRpcPrepData" + postFix,
                                     RDOContainer = "RPCPAD"+suffix))
    
    from MuonConfig.MuonRdoDecodeConfig import TgcRDODecodeCfg
    acc.merge(TgcRDODecodeCfg(flags, name = "TgcRdoToPrepData" + postFix,
                                     RDOContainer = "TGCRDO"+suffix))
    return acc
 

◆ MuonRdoToMuonDigitToolCfg()

python.Lvl1MuonSimulationConfig.MuonRdoToMuonDigitToolCfg	(		flags,
			name = "MuonRdoToMuonDigitTool",
		**	kwargs )

Definition at line 200 of file Lvl1MuonSimulationConfig.py.

def MuonRdoToMuonDigitToolCfg(flags, name="MuonRdoToMuonDigitTool", **kwargs ):
    result = ComponentAccumulator()
    kwargs.setdefault("DecodeSTGC_RDO", flags.Detector.GeometrysTGC)
    kwargs.setdefault("DecodeMM_RDO", flags.Detector.GeometryMM)
    kwargs.setdefault("DecodeNrpcRDO", flags.Muon.enableNRPC)
    from MuonConfig.MuonByteStreamCnvTestConfig import STgcRdoDecoderCfg, MMRdoDecoderCfg, MdtRdoDecoderCfg
    kwargs.setdefault( "stgcRdoDecoderTool", result.popToolsAndMerge(STgcRdoDecoderCfg(flags))
                         if flags.Detector.GeometrysTGC else "" )
    kwargs.setdefault("mmRdoDecoderTool", result.popToolsAndMerge(MMRdoDecoderCfg(flags))
                         if flags.Detector.GeometryMM else "" )
    kwargs.setdefault("mdtRdoDecoderTool", result.popToolsAndMerge(MdtRdoDecoderCfg(flags)))
    #Set N BCs and central BC consistently with RPC readout settings
    rpcrdo_decode = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
    kwargs.setdefault("rpcRdoDecoderTool", rpcrdo_decode)
 
    the_tool = CompFactory.MuonRdoToMuonDigitTool (name, **kwargs)
    result.setPrivateTools(the_tool)
    return result
 

◆ NSWTriggerConfig()

python.Lvl1MuonSimulationConfig.NSWTriggerConfig ( flags )

Definition at line 264 of file Lvl1MuonSimulationConfig.py.

def NSWTriggerConfig(flags):
    acc = ComponentAccumulator()
    if not flags.Detector.GeometrysTGC and not flags.Detector.GeometryMM:
        return acc
 
    if flags.Input.Format is Format.POOL and flags.Input.isMC:
        rdoInputs = [
            ('McEventCollection','TruthEvent'), # for MM trigger
            *( [('MuonSimDataCollection','sTGC_SDO')] if not flags.Muon.usePhaseIIGeoSetup else [] ),     # for sTGC Pad trigger
            ('TrackRecordCollection','MuonEntryLayer'), # for MM trigger
        ]
        from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
        acc.merge(SGInputLoaderCfg(flags, Load=rdoInputs))
 
    PadEmulatorTool = CompFactory.NSWL1.PadEmulatorTool("NSWL1__PadEmulatorTool", DoNtuple=flags.Trigger.L1MuonSim.WritesTGCBranches, IsMC = flags.Input.isMC, sTGC_DigitContainerName="sTGC_DIGITS_L1")
    MMTriggerTool = CompFactory.NSWL1.MMTriggerTool("NSWL1__MMTriggerTool",DoNtuple=flags.Trigger.L1MuonSim.WriteMMBranches, IsMC = flags.Input.isMC, MmDigitContainer="MM_DIGITS_L1")
    TriggerProcessorTool = CompFactory.NSWL1.TriggerProcessorTool("NSWL1__TriggerProcessorTool")
 
    # Include NswDcsDb Algorithm for data
    if not flags.Input.isMC:
        from MuonConfig.MuonCondAlgConfig import NswDcsDbAlgCfg
        acc.merge(NswDcsDbAlgCfg(flags))
 
    nswAlg = CompFactory.NSWL1.NSWL1Simulation("NSWL1Simulation",
                                               DoNtuple = flags.Trigger.L1MuonSim.WriteNSWDebugNtuple,
                                               DoMM = flags.Trigger.L1MuonSim.doMMTrigger,
                                               DoMMDiamonds = flags.Trigger.L1MuonSim.doMMTrigger,
                                               DosTGC = flags.Trigger.L1MuonSim.doPadTrigger or flags.Trigger.L1MuonSim.doStripTrigger,
                                               DoPad = flags.Trigger.L1MuonSim.doPadTrigger,
                                               PadEmulatorTool = PadEmulatorTool,
                                               DoStrip = flags.Trigger.L1MuonSim.doStripTrigger,
                                               MMTriggerTool = MMTriggerTool,
                                               TriggerProcessorTool = TriggerProcessorTool,
                                               NSWTrigRDOContainerName = "L1_NSWTrigContainer" )
    acc.addEventAlgo(nswAlg)
    return acc
 

◆ RecoMuonSegmentSequence()

python.Lvl1MuonSimulationConfig.RecoMuonSegmentSequence ( flags )

Definition at line 175 of file Lvl1MuonSimulationConfig.py.

def RecoMuonSegmentSequence(flags):
    acc = ComponentAccumulator()
    if not flags.Trigger.L1MuonSim.EmulateNSW or not flags.Trigger.L1MuonSim.NSWVetoMode:
        return acc
    postFix = "_L1MuonSim"
    theMuonLayerHough = CompFactory.MuonLayerHoughAlg("MuonLayerHoughAlg" + postFix,
                                                      TgcPrepDataContainer = "TGC_Measurements",
                                                      RpcPrepDataContainer = "RPC_Measurements",
                                                      CscPrepDataContainer = ("CSC_Clusters" if flags.Detector.GeometryCSC else ""),
                                                      MdtPrepDataContainer = "MDT_DriftCircles",
                                                      sTgcPrepDataContainer = ("STGC_Measurements" if flags.Detector.GeometrysTGC else ""),
                                                      MMPrepDataContainer = ("MM_Measurements" if flags.Detector.GeometryMM else "") )
    acc.addEventAlgo(theMuonLayerHough)
    theSegmentFinderAlg = CompFactory.MuonSegmentFinderAlg("MuonSegmentFinderAlg" + postFix)
    if not flags.Detector.GeometryCSC:
        theSegmentFinderAlg.CSC_clusterkey = ""
        theSegmentFinderAlg.Csc2dSegmentMaker = ""
        theSegmentFinderAlg.Csc4dSegmentMaker = ""
    acc.addEventAlgo(theSegmentFinderAlg)
    xAODMuonSegmentCnv = CompFactory.xAODMaker.MuonSegmentCnvAlg("MuonSegmentCnvAlg" + postFix)
    acc.addEventAlgo(xAODMuonSegmentCnv)
    return acc
 
 
 

◆ RPCTriggerConfig()

python.Lvl1MuonSimulationConfig.RPCTriggerConfig ( flags )

Definition at line 301 of file Lvl1MuonSimulationConfig.py.

def RPCTriggerConfig(flags):
    acc = ComponentAccumulator()
    rpcAlg = CompFactory.TrigT1RPC("TrigT1RPC",
                                Hardware          = True,
                                DataDetail        = False,
                                RPCbytestream     = False,
                                RPCbytestreamFile = "",
                                RPCDigitContainer = "RPC_DIGITS_L1",
                                useRun3Config = True,
                                NOBXS=flags.Trigger.L1MuonSim.RPCNBX,
                                BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
    acc.addEventAlgo(rpcAlg)
    from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
    acc.merge( RPCCablingConfigCfg(flags) ) # trigger roads
    return acc
 

◆ TGCModifierConfig()

python.Lvl1MuonSimulationConfig.TGCModifierConfig ( flags )

Definition at line 356 of file Lvl1MuonSimulationConfig.py.

def TGCModifierConfig(flags):
    acc = ComponentAccumulator()
    if not flags.Trigger.L1MuonSim.EmulateNSW:
        return acc
    recTool = CompFactory.LVL1.TrigT1TGCRecRoiTool("TrigT1TGCRecRoiToolLegacy")
    recTool.UseRun3Config=False # this is intentional
    tgcModifier = CompFactory.LVL1TGCTrigger.TGCOutputModifier("TGCOutputModifier",
                                                                TrigT1TGCRecRoiTool=recTool,
                                                                InputMuctpiLocation = "L1MuctpiStoreTGCint",
                                                                OutputMuctpiLocation = "L1MuctpiStoreTGC",
                                                                EmulateA = True,
                                                                EmulateC = True,
                                                                NSWVetoMode = flags.Trigger.L1MuonSim.NSWVetoMode )
    acc.addEventAlgo(tgcModifier)
    return acc
 

◆ TGCTriggerConfig()

python.Lvl1MuonSimulationConfig.TGCTriggerConfig ( flags )

Definition at line 317 of file Lvl1MuonSimulationConfig.py.

def TGCTriggerConfig(flags):
    acc = ComponentAccumulator()
    tgcAlg = CompFactory.LVL1TGCTrigger.LVL1TGCTrigger("LVL1TGCTrigger",
                                                       InputData_perEvent  = "TGC_DIGITS_L1",
                                                       InputRDO = "TGCRDO" if flags.Input.isMC else "TGCRDO_L1",
                                                       useRun3Config = True,
                                                       TileMuRcv_Input = "rerunTileMuRcvCnt",
                                                       TILEMU = True)
    if (flags.Detector.GeometrysTGC or flags.Detector.GeometryMM):
        tgcAlg.MaskFileName12 = "TrigT1TGCMaskedChannel.noFI._12.db"
        tgcAlg.USENSW = True
        tgcAlg.NSWSideInfo = "AC"
        tgcAlg.NSWTrigger_Input = "L1_NSWTrigContainer"
        tgcAlg.FORCENSWCOIN = not flags.Trigger.L1MuonSim.NSWVetoMode
        tgcAlg.USEBIS78 = flags.Trigger.L1MuonSim.doBIS78
    else:
        tgcAlg.MaskFileName12 = "TrigT1TGCMaskedChannel._12.db"
 
    if flags.Trigger.L1MuonSim.EmulateNSW:
        tgcAlg.MuctpiPhase1LocationTGC = "L1MuctpiStoreTGCint"
 
    if flags.Input.Format is Format.BS:
        from TriggerJobOpts.TriggerByteStreamConfig import ByteStreamReadCfg
        readBSConfig = ByteStreamReadCfg(flags, ['ByteStreamMetadataContainer/ByteStreamMetadata'])
        acc.merge(readBSConfig)
    else:
        tgcAlg.ByteStreamMetadataRHKey = ''
    acc.addEventAlgo(tgcAlg)
 
    from PathResolver import PathResolver
    bwCW_Run3_filePath=PathResolver.FindCalibFile("TrigT1TGC_CW/BW/CW_BW_Run3.v01.db")
    acc.merge(addFolders(flags, '<db>sqlite://;schema={0};dbname=OFLP200</db> /TGC/TRIGGER/CW_BW_RUN3'.format(bwCW_Run3_filePath),
                                tag='TgcTriggerCwBwRun3-01',
                                className='CondAttrListCollection'))
    acc.addCondAlgo(CompFactory.TGCTriggerCondAlg())
    from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
    acc.merge( TGCCablingConfigCfg(flags) )
    return acc
 

◆ TMDBConfig()

python.Lvl1MuonSimulationConfig.TMDBConfig ( flags )

Definition at line 8 of file Lvl1MuonSimulationConfig.py.

def TMDBConfig(flags):
    acc = ComponentAccumulator()
 
    # Read MuRcvRawChCnt from the input file (for POOL directly, for BS via converter)
    if flags.Input.Format is Format.POOL:
        from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
        acc.merge(SGInputLoaderCfg(flags, ["TileRawChannelContainer/MuRcvRawChCnt"]))
    else:
        from TriggerJobOpts.TriggerByteStreamConfig import ByteStreamReadCfg
        acc.merge(ByteStreamReadCfg(flags, ["TileRawChannelContainer/MuRcvRawChCnt"]))
 
    from TileConditions.TileInfoLoaderConfig import TileInfoLoaderCfg
    acc.merge( TileInfoLoaderCfg(flags) )
 
    from TileConditions.TileCablingSvcConfig import TileCablingSvcCfg
    acc.merge(TileCablingSvcCfg(flags))
 
    from TileConditions.TileEMScaleConfig import TileEMScaleCondAlgCfg
    acc.merge( TileEMScaleCondAlgCfg(flags) )
 
    tmdbAlg = CompFactory.TileMuonReceiverDecision('TileMuonReceiverDecision'
                                                   , TileRawChannelContainer = "MuRcvRawChCnt" # input
                                                   , TileMuonReceiverContainer = "rerunTileMuRcvCnt" # output
                                                   , ManualRunPeriod = 2 # forcing Run 2 format (=2) for now, until TGC implements Run 3 format (=3)
                                                   # run 2 thresholds
                                                   , MuonReceiverEneThreshCellD6Low = 500
                                                   , MuonReceiverEneThreshCellD6andD5Low = 500
                                                   , MuonReceiverEneThreshCellD6High = 600
                                                   , MuonReceiverEneThreshCellD6andD5High = 600
                                                   # run 3 thresholds
                                                   , MuonReceiverEneThreshCellD5 = 500
                                                   , MuonReceiverEneThreshCellD6 = 500
                                                   , MuonReceiverEneThreshCellD5andD6 = 500)
    acc.addEventAlgo(tmdbAlg)
    return acc
 