python.Lvl1MuonSimulationConfig Namespace Reference

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

Variables
	flags
	Files
	MaxEvents
	NumThreads
	triggerMenuSetup
	acc
	withDetails
	True
	summariseProps
	printDefaults

Function Documentation

Lvl1MuonSimulationCfg()

def python.Lvl1MuonSimulationConfig.Lvl1MuonSimulationCfg

(

flags

)

Definition at line 401 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()

def python.Lvl1MuonSimulationConfig.MuctpiConfig

(

flags

)

Definition at line 374 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()

def 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_RawDataProviderToolMT(name = "RPC_RawDataProviderToolMT" + postFix,
                                                                             RpcContainerCacheKey = MuonCacheNames.RpcCache,
                                                                             WriteOutRpcSectorLogic = False,
                                                                             Decoder = RPCRodDecoder,
                                                                             RdoLocation = "RPCPAD_L1" )
    RpcRawDataProvider = CompFactory.Muon.RpcRawDataProvider(name = "RpcRawDataProvider" + postFix,
                                                              ProviderTool = MuonRpcRawDataProviderTool)
    acc.addEventAlgo(RpcRawDataProvider)
    # for TGC
    TGCRodDecoder = CompFactory.Muon.TGC_RodDecoderReadout(name = "TGC_RodDecoderReadout" + postFix)
    MuonTgcRawDataProviderTool = CompFactory.Muon.TGC_RawDataProviderToolMT(name = "TGC_RawDataProviderToolMT" + postFix,
                                                                             TgcContainerCacheKey = MuonCacheNames.TgcCache,
                                                                             Decoder = TGCRodDecoder,
                                                                             RdoLocation = "TGCRDO_L1")
    TgcRawDataProvider = CompFactory.Muon.TgcRawDataProvider(name = "TgcRawDataProvider" + postFix,
                                                              ProviderTool = MuonTgcRawDataProviderTool)
    acc.addEventAlgo(TgcRawDataProvider)
    # for sTGC
    if flags.Detector.GeometrysTGC:
        Muon__STGC_RawDataProviderToolMT=CompFactory.Muon.STGC_RawDataProviderToolMT
        from MuonConfig.MuonBytestreamDecodeConfig import sTgcRODDecoderCfg
        MuonsTgcRawDataProviderTool = Muon__STGC_RawDataProviderToolMT(name    = "STGC_RawDataProviderToolMT"+postFix,
                                                                       Decoder = acc.popToolsAndMerge(sTgcRODDecoderCfg(flags,
                                                                                                     name = "sTgcROD_Decoder"+postFix)),
                                                                       RdoLocation = "sTGCRDO_L1")
        Muon__sTgcRawDataProvider=CompFactory.Muon.sTgcRawDataProvider
        sTgcRawDataProvider = Muon__sTgcRawDataProvider(name       = "sTgcRawDataProvider"+postFix,
                                                        ProviderTool = MuonsTgcRawDataProviderTool )
        acc.addEventAlgo(sTgcRawDataProvider)
 
    # for MM
    if flags.Detector.GeometryMM:
        from MuonConfig.MuonBytestreamDecodeConfig import MmRDODDecoderCfg
        Muon_MM_RawDataProviderToolMT = CompFactory.Muon.MM_RawDataProviderToolMT
        MuonMmRawDataProviderTool = Muon_MM_RawDataProviderToolMT(name  = "MM_RawDataProviderToolMT"+postFix,
                                                                  Decoder = acc.popToolsAndMerge(MmRDODDecoderCfg(flags,
                                                                                                 name="MM_RODDecoder"+postFix)),
                                                                  RdoLocation = "MMRDO_L1")
        Muon__MmRawDataProvider = CompFactory.Muon.MM_RawDataProvider
        MmRawDataProvider = Muon__MmRawDataProvider(name = "MmRawDataProvider"+postFix, ProviderTool = MuonMmRawDataProviderTool )
        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_RawDataProviderToolMT(name = "MDT_RawDataProviderToolMT" + postFix,
                                                                                CsmContainerCacheKey = MuonCacheNames.MdtCsmCache,
                                                                                Decoder = MDTRodDecoder,
                                                                                RdoLocation = "MDTCSM_L1")
        MdtRawDataProvider = CompFactory.Muon.MdtRawDataProvider(name = "MdtRawDataProvider" + postFix,
                                                                 ProviderTool = MuonMdtRawDataProviderTool)
        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.CscRawDataProvider(name = "CscRawDataProvider" + postFix,
                                                                     ProviderTool = MuonCscRawDataProviderTool)
            acc.addEventAlgo(CscRawDataProvider)
 
    return acc
 

MuonRdo2DigitConfig()

def python.Lvl1MuonSimulationConfig.MuonRdo2DigitConfig

(

flags

)

Definition at line 206 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 = [
            ('RpcPadContainer','RPCPAD'),
            ('TgcRdoContainer','TGCRDO')
        ]
        # 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()

def python.Lvl1MuonSimulationConfig.MuonRdo2PrdConfig

(

flags

)

Definition at line 125 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()

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

Definition at line 187 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()

def python.Lvl1MuonSimulationConfig.NSWTriggerConfig

(

flags

)

Definition at line 251 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
            ('TrackRecordCollection','MuonEntryLayer'), # for MM trigger
            ('MuonSimDataCollection','sTGC_SDO') # for sTGC Pad 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")
    PadTdsTool = CompFactory.NSWL1.PadTdsOfflineTool("NSWL1__PadTdsOfflineTool", IsMC = flags.Input.isMC, sTGC_DigitContainerName="sTGC_DIGITS_L1")
    PadTriggerLogicTool = CompFactory.NSWL1.PadTriggerLogicOfflineTool("NSWL1__PadTriggerLogicOfflineTool")
    StripTdsTool = CompFactory.NSWL1.StripTdsOfflineTool("NSWL1__StripTdsOfflineTool", IsMC=flags.Input.isMC, sTGC_DigitContainerName="sTGC_DIGITS_L1")
    StripClusterTool = CompFactory.NSWL1.StripClusterTool("NSWL1__StripClusterTool", IsMC=flags.Input.isMC)
    StripSegmentTool = CompFactory.NSWL1.StripSegmentTool("NSWL1__StripSegmentTool")
    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))
 
    dosTGC =  flags.Trigger.L1MuonSim.doPadTrigger or flags.Trigger.L1MuonSim.doStripTrigger
    if dosTGC:
        from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
        stgcRegSel = acc.popToolsAndMerge(regSelTool_STGC_Cfg( flags ))  # noqa: F841 (adds a conditions algo as a side-effect)
 
    nswAlg = CompFactory.NSWL1.NSWL1Simulation("NSWL1Simulation",
                                               DoNtuple = flags.Trigger.L1MuonSim.WriteNSWDebugNtuple,
                                               DoMM = flags.Trigger.L1MuonSim.doMMTrigger,
                                               DoMMDiamonds = flags.Trigger.L1MuonSim.doMMTrigger,
                                               DosTGC = dosTGC,
                                               DoPad = flags.Trigger.L1MuonSim.doPadTrigger,
                                               PadEmulatorTool = PadEmulatorTool,
                                               DoStrip = flags.Trigger.L1MuonSim.doStripTrigger,
                                               PadTdsTool = PadTdsTool,
                                               PadTriggerTool = PadTriggerLogicTool,
                                               StripTdsTool = StripTdsTool,
                                               StripClusterTool = StripClusterTool,
                                               StripSegmentTool = StripSegmentTool,
                                               MMTriggerTool = MMTriggerTool,
                                               TriggerProcessorTool = TriggerProcessorTool,
                                               NSWTrigRDOContainerName = "L1_NSWTrigContainer" )
    acc.addEventAlgo(nswAlg)
    return acc
 

RecoMuonSegmentSequence()

def python.Lvl1MuonSimulationConfig.RecoMuonSegmentSequence

(

flags

)

Definition at line 162 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()

def python.Lvl1MuonSimulationConfig.RPCTriggerConfig

(

flags

)

Definition at line 303 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()

def python.Lvl1MuonSimulationConfig.TGCModifierConfig

(

flags

)

Definition at line 358 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()

def python.Lvl1MuonSimulationConfig.TGCTriggerConfig

(

flags

)

Definition at line 319 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()

def 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
 

Variable Documentation

acc

python.Lvl1MuonSimulationConfig.acc

Definition at line 429 of file Lvl1MuonSimulationConfig.py.

Files

python.Lvl1MuonSimulationConfig.Files

Definition at line 421 of file Lvl1MuonSimulationConfig.py.

flags

python.Lvl1MuonSimulationConfig.flags

Definition at line 420 of file Lvl1MuonSimulationConfig.py.

MaxEvents

python.Lvl1MuonSimulationConfig.MaxEvents

Definition at line 422 of file Lvl1MuonSimulationConfig.py.

NumThreads

python.Lvl1MuonSimulationConfig.NumThreads

Definition at line 423 of file Lvl1MuonSimulationConfig.py.

printDefaults

python.Lvl1MuonSimulationConfig.printDefaults

Definition at line 439 of file Lvl1MuonSimulationConfig.py.

summariseProps

python.Lvl1MuonSimulationConfig.summariseProps

Definition at line 439 of file Lvl1MuonSimulationConfig.py.

triggerMenuSetup

python.Lvl1MuonSimulationConfig.triggerMenuSetup

Definition at line 424 of file Lvl1MuonSimulationConfig.py.

True

python.Lvl1MuonSimulationConfig.True

Definition at line 439 of file Lvl1MuonSimulationConfig.py.

withDetails

python.Lvl1MuonSimulationConfig.withDetails

Definition at line 439 of file Lvl1MuonSimulationConfig.py.