cscTriggerPrimitiveDigisPostLS3_cfi.py

import FWCore.ParameterSet.Config as cms

from L1Trigger.CSCCommonTrigger.CSCCommonTrigger_cfi import *
# Default parameters for CSCTriggerPrimitives generator
# for GEM-CSC-RPC integrated local trigger in Post-LS3 era
# =====================================================
cscTriggerPrimitiveDigisPostLS3 = cms.EDProducer("CSCTriggerPrimitivesProducer",
    CSCCommonTrigger,

    # if False, parameters will be read in from DB using EventSetup mechanism
    # else will use parameters from this config
    debugParameters = cms.bool(True),
    
    # Name of digi producer module(s)
    CSCComparatorDigiProducer = cms.InputTag("simMuonCSCDigis","MuonCSCComparatorDigi"),
    CSCWireDigiProducer = cms.InputTag("simMuonCSCDigis","MuonCSCWireDigi"),
    GEMCSCPadDigiProducer = cms.InputTag("simMuonGEMCSCPadDigis"),
    RPCDigiProducer = cms.InputTag("simMuonRPCDigis"),

    # for SLHC studies we don't want bad chambers checks so far
    checkBadChambers = cms.bool(False),
    fractionBrokenCSCs = cms.double(0.0),

    # Parameters common for all boards
    commonParam = cms.PSet(
        isTMB07 = cms.bool(True),
        isMTCC = cms.bool(False),
        
        # Flag for SLHC studies (upgraded ME11, MPC)
        # (if true, isTMB07 should be true as well)
        isSLHC = cms.bool(True),

        # ME1a configuration:
        # smartME1aME1b=f, gangedME1a=t
        #   default logic for current HW
        # smartME1aME1b=t, gangedME1a=f
        #   realistic upgrade scenario: 
        #   one ALCT finder and two CLCT finders per ME11
        #   with additional logic for A/CLCT matching with ME1a unganged
        # smartME1aME1b=t, gangedME1a=t
        #   the previous case with ME1a still being ganged
        # Note: gangedME1a has effect only if smartME1aME1b=t
        smartME1aME1b = cms.bool(True),
        gangedME1a = cms.bool(False),
        
        # flagis to optionally disable finding stubs in ME42 or ME1a
        disableME1a = cms.bool(False),
        disableME42 = cms.bool(False),
        
        # run integrated local triggers
        runME11ILT = cms.bool(True),
        runME21ILT = cms.bool(True),
        runME3141ILT = cms.bool(True),
    ),

    # Parameters for ALCT processors: old MC studies
    alctParamOldMC = cms.PSet(
        alctFifoTbins   = cms.uint32(16),
        alctFifoPretrig = cms.uint32(10),
        alctDriftDelay  = cms.uint32(3),
        alctNplanesHitPretrig = cms.uint32(2),
        alctNplanesHitPattern = cms.uint32(4),
        alctNplanesHitAccelPretrig = cms.uint32(2),
        alctNplanesHitAccelPattern = cms.uint32(4),
        alctTrigMode       = cms.uint32(3),
        alctAccelMode      = cms.uint32(1),
        alctL1aWindowWidth = cms.uint32(5),
        verbosity = cms.int32(0)
    ),

    # Parameters for ALCT processors: MTCC-II
    alctParamMTCC = cms.PSet(
        alctFifoTbins   = cms.uint32(16),
        alctFifoPretrig = cms.uint32(10),
        alctDriftDelay  = cms.uint32(3),
        alctNplanesHitPretrig = cms.uint32(2),
        alctNplanesHitPattern = cms.uint32(4),
        alctNplanesHitAccelPretrig = cms.uint32(2),
        alctNplanesHitAccelPattern = cms.uint32(4),
        alctTrigMode       = cms.uint32(2),
        alctAccelMode      = cms.uint32(0),
        alctL1aWindowWidth = cms.uint32(3),
        verbosity = cms.int32(0)
    ),

    # Parameters for ALCT processors: 2007 and later
    alctParam07 = cms.PSet(
        alctFifoTbins   = cms.uint32(16),
        alctFifoPretrig = cms.uint32(10),
        alctDriftDelay  = cms.uint32(2),
        alctNplanesHitPretrig = cms.uint32(3),
        alctNplanesHitPattern = cms.uint32(4),
        alctNplanesHitAccelPretrig = cms.uint32(3),
        alctNplanesHitAccelPattern = cms.uint32(4),
        alctTrigMode       = cms.uint32(2),
        alctAccelMode      = cms.uint32(0),
        alctL1aWindowWidth = cms.uint32(7),
        verbosity = cms.int32(0),

        # Configure early_tbins instead of hardcoding it
        alctEarlyTbins = cms.int32(4),

        # Use narrow pattern mask for ring 1 chambers
        alctNarrowMaskForR1 = cms.bool(True),

        # configured, not hardcoded, hit persistency
        alctHitPersist  = cms.uint32(6),
        
        # configure, not hardcode, up to how many BXs in the past
        # ghost cancellation in neighboring WGs may happen
        alctGhostCancellationBxDepth = cms.int32(1),
        
        # whether to compare the quality of stubs in neighboring WGs in the past
        # to the quality of a stub in current WG 
        # when doing ghost cancellation 
        alctGhostCancellationSideQuality = cms.bool(True),
        
        # how soon after pretrigger and alctDriftDelay can next pretrigger happen?
        alctPretrigDeadtime = cms.uint32(4)
    ),

    # Parameters for ALCT processors: SLHC studies
    alctSLHC = cms.PSet(
        alctFifoTbins   = cms.uint32(16),
        alctFifoPretrig = cms.uint32(10),
        alctDriftDelay  = cms.uint32(2),
        alctNplanesHitPretrig = cms.uint32(3),
        alctNplanesHitPattern = cms.uint32(4),
        alctNplanesHitAccelPretrig = cms.uint32(3),
        alctNplanesHitAccelPattern = cms.uint32(4),
        alctTrigMode       = cms.uint32(2),
        alctAccelMode      = cms.uint32(0),
        alctL1aWindowWidth = cms.uint32(7),
        verbosity = cms.int32(0),

        # Configure early_tbins instead of hardcoding it
        alctEarlyTbins = cms.int32(4),

        # Use narrow pattern mask for ring 1 chambers
        alctNarrowMaskForR1 = cms.bool(True),

        # configured, not hardcoded, hit persistency
        alctHitPersist  = cms.uint32(6),

                # configure, not hardcode, up to how many BXs in the past
        # ghost cancellation in neighboring WGs may happen
        alctGhostCancellationBxDepth = cms.int32(1),
        
        # whether to compare the quality of stubs in neighboring WGs in the past
        # to the quality of a stub in current WG 
        # when doing ghost cancellation 
        alctGhostCancellationSideQuality = cms.bool(True),
        
        # how soon after pretrigger and alctDriftDelay can next pretrigger happen?
        alctPretrigDeadtime = cms.uint32(0),
        
        # SLHC only for ME11:
        # whether to store the "corrected" ALCT stub time 
        # (currently it is median time of particular hits in a pattern) into the ASCCLCTDigi bx,
        # and temporary store the regular "key layer hit" time into the CSCCLCTDigi fullBX:
        alctUseCorrectedBx = cms.bool(True)
    ),

    # Parameters for CLCT processors: old MC studies
    clctParamOldMC = cms.PSet(
        clctFifoTbins   = cms.uint32(12),
        clctFifoPretrig = cms.uint32(7),
        clctHitPersist  = cms.uint32(6),
        clctDriftDelay  = cms.uint32(2),
        clctNplanesHitPretrig = cms.uint32(2),
        clctNplanesHitPattern = cms.uint32(4),
        clctPidThreshPretrig  = cms.uint32(2),
        clctMinSeparation     = cms.uint32(10),
        # Debug
        verbosity = cms.int32(0)
    ),

    # Parameters for CLCT processors: MTCC-II
    clctParamMTCC = cms.PSet(
        clctFifoTbins   = cms.uint32(12),
        clctFifoPretrig = cms.uint32(7),
        clctHitPersist  = cms.uint32(6),
        clctDriftDelay  = cms.uint32(2),
        clctNplanesHitPretrig = cms.uint32(4),
        clctNplanesHitPattern = cms.uint32(1),
        clctPidThreshPretrig  = cms.uint32(2),
        clctMinSeparation     = cms.uint32(10),
        # Debug
        verbosity = cms.int32(0)
    ),

    # Parameters for CLCT processors: 2007 and later
    clctParam07 = cms.PSet(
        clctFifoTbins   = cms.uint32(12),
        clctFifoPretrig = cms.uint32(7),
        clctHitPersist  = cms.uint32(4),
        clctDriftDelay  = cms.uint32(2),
        clctNplanesHitPretrig = cms.uint32(3),
        clctNplanesHitPattern = cms.uint32(4),
        # increase pattern ID threshold from 2 to 4 to trigger higher pt tracks  
        clctPidThreshPretrig  = cms.uint32(4),
        # decrease possible minimal #HS distance between two CLCTs in a BX from 10 to 5:
        clctMinSeparation     = cms.uint32(5),
        # Debug
        verbosity = cms.int32(0),

        # BX to start CLCT finding (poor man's dead-time shortening):
        clctStartBxShift  = cms.int32(0)
    ),

    # Parameters for CLCT processors: SLHC studies
    clctSLHC = cms.PSet(
        clctFifoTbins   = cms.uint32(12),
        clctFifoPretrig = cms.uint32(7),
        clctHitPersist  = cms.uint32(4),
        clctDriftDelay  = cms.uint32(2),
        clctNplanesHitPretrig = cms.uint32(3),
        clctNplanesHitPattern = cms.uint32(4),
        # increase pattern ID threshold from 2 to 4 to trigger higher pt tracks  
        clctPidThreshPretrig  = cms.uint32(4),
        # decrease possible minimal #HS distance between two CLCTs in a BX from 10 to 5:
        clctMinSeparation     = cms.uint32(5),
        # Debug
        verbosity = cms.int32(0),

        # BX to start CLCT finding (poor man's to shorten the dead-time):
        clctStartBxShift  = cms.int32(0),
        
        # Turns on algorithms of localized dead-time zones:
        useDeadTimeZoning = cms.bool(True),
        
        # Width (in #HS) of a fixed dead zone around a key HS:
        clctStateMachineZone = cms.uint32(8),
        
        # Enables the algo which instead of using the fixed dead zone width, 
        # varies it depending on the width of a triggered CLCT pattern
        # (if True, the clctStateMachineZone is ignored):
        useDynamicStateMachineZone = cms.bool(True),
        
        # Pretrigger HS +- clctPretriggerTriggerZone sets the trigger matching zone
        # which defines how far from pretrigger HS the TMB may look for a trigger HS
        # (it becomes important to do so with localized dead-time zoning): 
        clctPretriggerTriggerZone = cms.uint32(5),
        
        # whether to store the "corrected" CLCT stub time 
        # (currently it is median time of all hits in a pattern) into the CSCCLCTDigi bx,
        # and temporary store the regular "key layer hit" time into the CSCCLCTDigi fullBX:
        clctUseCorrectedBx = cms.bool(True)
    ),

    tmbParam = cms.PSet(
        mpcBlockMe1a    = cms.uint32(0),
        alctTrigEnable  = cms.uint32(0),
        clctTrigEnable  = cms.uint32(0),
        matchTrigEnable = cms.uint32(1),
        # reduce ALCT-CLCT matching window size from 7 to 3
        matchTrigWindowSize = cms.uint32(3),
        tmbL1aWindowSize = cms.uint32(7),
        # Debug
        verbosity = cms.int32(0),

        # Configure early_tbins instead of hardcoding it
        tmbEarlyTbins = cms.int32(4),
        
        # Flag for whether to readout only the earliest max two LCTs in a 
        # L1A readout window, as there is only room just for two in the TMB header.
        # If false, all LCTs would be readout in L1A window.
        tmbReadoutEarliest2 = cms.bool(True),

        # For CLCT-centric matching, whether to drop ALCTs that were matched
        # to CLCTs in this BX, and not use them in the following BX 
        # (default non-upgrade TMB behavior).
        tmbDropUsedAlcts = cms.bool(True)
    ),

    # to be used by ME11 chambers with upgraded TMB and ALCT
    tmbSLHC = cms.PSet(
        mpcBlockMe1a    = cms.uint32(0),
        alctTrigEnable  = cms.uint32(0),
        clctTrigEnable  = cms.uint32(0),
        matchTrigEnable = cms.uint32(1),
        # reduce ALCT-CLCT matching window size from 7 to 3
        matchTrigWindowSize = cms.uint32(3),
        tmbL1aWindowSize = cms.uint32(7),
        # Debug
        verbosity = cms.int32(0),

        # Configure early_tbins instead of hardcoding it
        tmbEarlyTbins = cms.int32(4),
        
        # Flag for whether to readout only the earliest max two LCTs in a 
        # L1A readout window, as there is only room just for two in the TMB header.
        # If false, all LCTs would be readout in L1A window.
        tmbReadoutEarliest2 = cms.bool(False),

        # For CLCT-centric matching, whether to drop ALCTs that were matched
        # to CLCTs in this BX, and not use them in the following BX 
        # (default non-upgrade TMB behavior).
        tmbDropUsedAlcts = cms.bool(False),

        # Switch to enable
        #  True = CLCT-centric matching (default non-upgrade behavior, 
        #         take CLCTs in BX look for matching ALCTs in window)
        #  False = ALCT-centric matching (recommended for SLHC, 
        #         take ALCTs in BX look for matching CLCTs in window)
        clctToAlct = cms.bool(False),

        # For ALCT-centric matching, whether to drop CLCTs that were matched
        # to ALCTs in this BX, and not use them in the following BX 
        tmbDropUsedClcts = cms.bool(False),
        
        # For CLCT-centric matching in ME11, break after finding 
        # the first BX with matching ALCT 
        matchEarliestAlctME11Only = cms.bool(False),
        
        # For ALCT-centric matching in ME11, break after finding 
        # the first BX with matching CLCT 
        matchEarliestClctME11Only = cms.bool(False),
        
        # 0 = default "non-X-BX" sorting algorithm, 
        #     where the first BX with match goes first
        # 1 = simple X-BX sorting algorithm, 
        #     where the central match BX goes first, 
        #     then the closest early, the slocest late, etc.
        tmbCrossBxAlgorithm = cms.uint32(1),
        
        # How many maximum LCTs per whole chamber per BX to keep
        # (supposedly, 1b and 1a can have max 2 each)
        maxME11LCTs = cms.uint32(2)
    ),

    # to be used by ME11 chambers with GEM-CSC ILT
    me11tmbSLHCGEM = cms.PSet(
        mpcBlockMe1a    = cms.uint32(0),
        alctTrigEnable  = cms.uint32(0),
        clctTrigEnable  = cms.uint32(0),
        matchTrigEnable = cms.uint32(1),
        matchTrigWindowSize = cms.uint32(3),
        tmbL1aWindowSize = cms.uint32(7),
        verbosity = cms.int32(0),
        tmbEarlyTbins = cms.int32(4),
        tmbReadoutEarliest2 = cms.bool(False),
        tmbDropUsedAlcts = cms.bool(False),
        clctToAlct = cms.bool(False),
        tmbDropUsedClcts = cms.bool(False),
        matchEarliestAlctME11Only = cms.bool(False),
        matchEarliestClctME11Only = cms.bool(False),
        tmbCrossBxAlgorithm = cms.uint32(2),
        maxME11LCTs = cms.uint32(2),

        ## run in debug mode
        debugLUTs = cms.bool(False),
        debugMatching = cms.bool(False),
        debugGEMDphi = cms.bool(False),

        ## use old dataformat
        useOldLCTDataFormatALCTGEM = cms.bool(True),
        useOldLCTDataFormatCLCTGEM = cms.bool(True),
        
        ## copad construction
        maxDeltaBXInCoPad = cms.int32(1),
        maxDeltaPadInCoPad = cms.int32(1),

        ## matching to pads in case LowQ CLCT
        maxDeltaBXPadEven = cms.int32(1),
        maxDeltaBXPadOdd = cms.int32(1),
        maxDeltaPadPadEven = cms.int32(2),
        maxDeltaPadPadOdd = cms.int32(3),

        ## matching to pads in case absent CLCT
        maxDeltaBXCoPadEven = cms.int32(0),
        maxDeltaBXCoPadOdd = cms.int32(0),
        maxDeltaPadCoPadEven = cms.int32(2),
        maxDeltaPadCoPadOdd = cms.int32(3),

        ## efficiency recovery switches
        dropLowQualityCLCTsNoGEMs_ME1a = cms.bool(False),
        dropLowQualityCLCTsNoGEMs_ME1b = cms.bool(True),
        dropLowQualityALCTsNoGEMs_ME1a = cms.bool(False),
        dropLowQualityALCTsNoGEMs_ME1b = cms.bool(False),
        buildLCTfromALCTandGEM_ME1a = cms.bool(True),
        buildLCTfromALCTandGEM_ME1b = cms.bool(True),
        buildLCTfromCLCTandGEM_ME1a = cms.bool(True),
        buildLCTfromCLCTandGEM_ME1b = cms.bool(True),
        doLCTGhostBustingWithGEMs = cms.bool(False),
        correctLCTtimingWithGEM = cms.bool(False),
        promoteALCTGEMpattern = cms.bool(True),
        promoteALCTGEMquality = cms.bool(True),
        promoteCLCTGEMquality_ME1a = cms.bool(True),
        promoteCLCTGEMquality_ME1b = cms.bool(True),
        
        ## rate reduction 
        doGemMatching = cms.bool(True),
        gemMatchDeltaEta = cms.double(0.08),
        gemMatchDeltaBX = cms.int32(1),
        gemMatchDeltaPhiOdd = cms.double(1),
        gemMatchDeltaPhiEven = cms.double(1),
        gemMatchMinEta = cms.double(1.55),
        gemMatchMaxEta = cms.double(2.15),
        gemClearNomatchLCTs = cms.bool(False),

        ## cross BX algorithm
        firstTwoLCTsInChamber = cms.bool(True),
    ),
                                                 
    # to be used by ME21 chambers with GEM-CSC ILT
    me21tmbSLHCGEM = cms.PSet(
        mpcBlockMe1a    = cms.uint32(0),
        alctTrigEnable  = cms.uint32(0),
        clctTrigEnable  = cms.uint32(0),
        matchTrigEnable = cms.uint32(1),
        matchTrigWindowSize = cms.uint32(3),
        tmbL1aWindowSize = cms.uint32(7),
        verbosity = cms.int32(0),
        tmbEarlyTbins = cms.int32(4),
        tmbReadoutEarliest2 = cms.bool(False),
        tmbDropUsedAlcts = cms.bool(False),
        clctToAlct = cms.bool(False),
        tmbDropUsedClcts = cms.bool(False),
        matchEarliestAlctME21Only = cms.bool(False),
        matchEarliestClctME21Only = cms.bool(False),
        tmbCrossBxAlgorithm = cms.uint32(2),
        maxME21LCTs = cms.uint32(2),

        ## run in debug mode
        debugLUTs = cms.bool(False),
        debugMatching = cms.bool(False),
        debugGEMDphi = cms.bool(False),

        ## use old dataformat
        useOldLCTDataFormatALCTGEM = cms.bool(True),
        useOldLCTDataFormatCLCTGEM = cms.bool(True),
        
        ## copad construction
        maxDeltaBXInCoPad = cms.int32(1),
        maxDeltaPadInCoPad = cms.int32(1),

        ## matching to pads in case LowQ CLCT
        maxDeltaBXPad = cms.int32(1),
        maxDeltaPadPad = cms.int32(2),
        maxDeltaWg = cms.int32(1),

        ## matching to pads in case absent CLCT
        maxDeltaBXCoPad = cms.int32(0),
        maxDeltaPadCoPad = cms.int32(2),

        ## efficiency recovery switches
        dropLowQualityALCTsNoGEMs = cms.bool(False),
        dropLowQualityCLCTsNoGEMs = cms.bool(True),
        buildLCTfromALCTandGEM = cms.bool(True),
        buildLCTfromCLCTandGEM = cms.bool(True),
        doLCTGhostBustingWithGEMs = cms.bool(False),
        correctLCTtimingWithGEM = cms.bool(False),
        promoteALCTGEMpattern = cms.bool(True),
        promoteALCTGEMquality = cms.bool(True),
        promoteCLCTGEMquality = cms.bool(True),

        ## rate reduction 
        doGemMatching = cms.bool(True),
        gemMatchDeltaEta = cms.double(0.08),
        gemMatchDeltaBX = cms.int32(1),
        gemMatchDeltaPhiOdd = cms.double(1),
        gemMatchDeltaPhiEven = cms.double(1),
        gemMatchMinEta = cms.double(1.5),
        gemMatchMaxEta = cms.double(2.45),
        gemClearNomatchLCTs = cms.bool(False),

        firstTwoLCTsInChamber = cms.bool(True),
    ),

    # to be used by ME31-ME41 chambers with RPC-CSC ILT
    me3141tmbSLHCRPC = cms.PSet(
        mpcBlockMe1a    = cms.uint32(0),
        alctTrigEnable  = cms.uint32(0),
        clctTrigEnable  = cms.uint32(0),
        matchTrigEnable = cms.uint32(1),
        matchTrigWindowSize = cms.uint32(3),
        tmbL1aWindowSize = cms.uint32(7),
        verbosity = cms.int32(0),
        tmbEarlyTbins = cms.int32(4),
        tmbReadoutEarliest2 = cms.bool(False),
        tmbDropUsedAlcts = cms.bool(False),
        clctToAlct = cms.bool(False),
        tmbDropUsedClcts = cms.bool(False),
        matchEarliestClctME3141Only = cms.bool(False),
        tmbCrossBxAlgorithm = cms.uint32(2),
        maxME3141LCTs = cms.uint32(2),

        ## run in debug mode
        debugLUTs = cms.bool(False),
        debugMatching = cms.bool(False),

        ## use old dataformat
        useOldLCTDataFormatCLCTRPC = cms.bool(True),
        useOldLCTDataFormatALCTRPC = cms.bool(True),

        ## matching to digis in case LowQ CLCT
        maxDeltaBXRPC = cms.int32(0),
        maxDeltaStripRPC = cms.int32(3),
        maxDeltaWg = cms.int32(1),

        ## efficiency recovery switches
        dropLowQualityCLCTsNoRPCs = cms.bool(True),
        buildLCTfromALCTandRPC = cms.bool(True),
        buildLCTfromCLCTandRPC = cms.bool(True),
        promoteCLCTRPCquality = cms.bool(True),
        promoteALCTRPCpattern = cms.bool(True),
        promoteALCTRPCquality = cms.bool(True),

        ## rate reduction 
        doRpcMatching = cms.bool(True),
        rpcMatchDeltaEta = cms.double(0.08),
        rpcMatchDeltaBX = cms.int32(1),
        rpcMatchDeltaPhiOdd = cms.double(1),
        rpcMatchDeltaPhiEven = cms.double(1),
        rpcMatchMinEta = cms.double(1.5),
        rpcClearNomatchLCTs = cms.bool(False),
    ),

    # MPC sorter config for SLHC studies
    mpcSLHC = cms.PSet(
        mpcMaxStubs = cms.uint32(3)
    )
)