def L1TReEmulFromRAW(process):
L1TReEmulFromRAW2016(process)
stage2L1Trigger_2017.toModify(process.simOmtfDigis,
srcRPC='omtfStage2Digis',
srcCSC='omtfStage2Digis',
srcDTPh='omtfStage2Digis',
srcDTTh='omtfStage2Digis')
stage2L1Trigger.toModify(
process.simEmtfDigis,
CSCInput=cms.InputTag('emtfStage2Digis'),
RPCInput=cms.InputTag('muonRPCDigis'),
CPPFInput=cms.InputTag('emtfStage2Digis'),
GEMEnable=cms.bool(False),
GEMInput=cms.InputTag('muonGEMPadDigis'),
CPPFEnable=cms.bool(
True
), # Use CPPF-emulated clustered RPC hits from CPPF as the RPC hits
)
run3_GEM.toModify(
process.simMuonGEMPadDigis,
InputCollection='muonGEMDigis',
)
run3_GEM.toModify(process.simTwinMuxDigis,
RPC_Source='rpcTwinMuxRawToDigi',
DTDigi_Source='simDtTriggerPrimitiveDigis',
DTThetaDigi_Source='simDtTriggerPrimitiveDigis')
print("# L1TReEmul sequence: ")
print("# {0}".format(process.L1TReEmul))
print("# {0}".format(process.schedule))
return process
def L1TReEmulMCFromRAW(process):
L1TReEmulFromRAW(process)
stage2L1Trigger.toModify(process.simEmtfDigis, CSCInput = 'simCscTriggerPrimitiveDigis:MPCSORTED')
stage2L1Trigger.toModify(process.simOmtfDigis, srcCSC = 'simCscTriggerPrimitiveDigis:MPCSORTED')
# Temporary fix for OMTF inputs in MC re-emulation
run3_GEM.toModify(process.simOmtfDigis,
srcRPC = 'muonRPCDigis',
srcDTPh = 'simDtTriggerPrimitiveDigis',
srcDTTh = 'simDtTriggerPrimitiveDigis'
)
return process
def L1TReEmulMCFromRAW(process):
L1TReEmulFromRAW(process)
stage2L1Trigger.toModify(process.simEmtfDigis, CSCInput = 'simCscTriggerPrimitiveDigis:MPCSORTED')
stage2L1Trigger.toModify(process.simOmtfDigis, srcCSC = 'simCscTriggerPrimitiveDigis:MPCSORTED')
# Correct input collections for MC re-emulation
run3_GEM.toModify(process.simBmtfDigis,
DTDigi_Source = 'simTwinMuxDigis',
DTDigi_Theta_Source = 'simDtTriggerPrimitiveDigis'
)
run3_GEM.toModify(process.simKBmtfStubs,
srcPhi = "simTwinMuxDigis",
srcTheta = "simDtTriggerPrimitiveDigis"
)
run3_GEM.toModify(process.simOmtfDigis,
srcRPC = 'muonRPCDigis',
srcDTPh = 'simDtTriggerPrimitiveDigis',
srcDTTh = 'simDtTriggerPrimitiveDigis'
)
run3_GEM.toModify(process.simEmtfDigis,
RPCInput = 'muonRPCDigis',
GEMEnable = False, # Will be enabled when GEM is in use.
GEMInput = 'simMuonGEMPadDigiClusters',
CPPFEnable = False, # Use CPPF-emulated clustered RPC hits from CPPF as the RPC hits. Set to "False" for MC
UseRun3CCLUT_OTMB = False, # TODO: Enable UseRun3CCLUT_OTMB once it's ready.
)
return process
def setCrossingFrameOn(process):
process.mix.mixObjects.mixCH.crossingFrames = cms.untracked.vstring(
'CaloHitsTk', 'CastorBU', 'CastorFI', 'CastorPL', 'CastorTU',
'EcalHitsEB', 'EcalHitsEE', 'EcalHitsES', 'EcalTBH4BeamHits',
'HcalHits', 'HcalTB06BeamHits', 'ZDCHITS')
process.mix.mixObjects.mixTracks.makeCrossingFrame = cms.untracked.bool(
True)
process.mix.mixObjects.mixVertices.makeCrossingFrame = cms.untracked.bool(
True)
process.mix.mixObjects.mixHepMC.makeCrossingFrame = cms.untracked.bool(
True)
process.mix.mixObjects.mixSH.crossingFrames = cms.untracked.vstring(
'BSCHits', 'FP420SI', 'MuonCSCHits', 'MuonDTHits', 'MuonRPCHits',
'TotemHitsRP', 'TotemHitsT1', 'TotemHitsT2Gem',
'TrackerHitsPixelBarrelHighTof', 'TrackerHitsPixelBarrelLowTof',
'TrackerHitsPixelEndcapHighTof', 'TrackerHitsPixelEndcapLowTof',
'TrackerHitsTECHighTof', 'TrackerHitsTECLowTof',
'TrackerHitsTIBHighTof', 'TrackerHitsTIBLowTof',
'TrackerHitsTIDHighTof', 'TrackerHitsTIDLowTof',
'TrackerHitsTOBHighTof', 'TrackerHitsTOBLowTof')
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['MuonGEMHits']))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['MuonGEMHits']))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['MuonME0Hits']))
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['FastTimerHitsBarrel', 'FastTimerHitsEndcap']))
return (process)
#
minHit = cms.double(-0.5),
maxHit = cms.double(74.5),
nintHit = cms.int32(75),
#
minPhi = cms.double(-3.1416),
maxPhi = cms.double(3.1416),
nintPhi = cms.int32(36),
#
minDxy = cms.double(-3),
maxDxy = cms.double(3),
nintDxy = cms.int32(100),
#
minDz = cms.double(-10),
maxDz = cms.double(10),
nintDz = cms.int32(100),
# TP originating vertical position
minVertpos = cms.double(0),
maxVertpos = cms.double(5),
nintVertpos = cms.int32(100),
# TP originating z position
minZpos = cms.double(-10),
maxZpos = cms.double(10),
nintZpos = cms.int32(100)
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( muonTrackValidator, useGEMs = cms.bool(True) )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( muonTrackValidator, useME0 = cms.bool(True) )
input = cms.VInputTag(cms.InputTag("CFWriter","g4SimHits")),
type = cms.string('SimVertexPCrossingFrame')
)
mixPCFHepMCProducts = cms.PSet(
input = cms.VInputTag(cms.InputTag("CFWriter","generator")),
type = cms.string('HepMCProductPCrossingFrame')
)
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hgceeDigitizer, hgchefrontDigitizer
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonGEMHits") ],
subdets = theMixObjects.mixSH.subdets + [ 'MuonGEMHits' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ]
)
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonME0Hits") ],
subdets = theMixObjects.mixSH.subdets + [ 'MuonME0Hits' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonME0Hits' ]
)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( theMixObjects,
mixCH = dict(
input = theMixObjects.mixCH.input + [ cms.InputTag("g4SimHits",hgceeDigitizer.hitCollection.value()),
import FWCore.ParameterSet.Config as cms
from Validation.CSCRecHits.cscRecHitPSet import *
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
cscRecHitValidation = DQMEDAnalyzer('CSCRecHitValidation',
cscRecHitPSet,
doSim=cms.bool(True),
useGEMs=cms.bool(False),
simHitsTag=cms.InputTag(
"mix", "g4SimHitsMuonCSCHits"))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(cscRecHitValidation, useGEMs=True)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(cscRecHitValidation, simHitsTag="mix:MuonSimHitsMuonCSCHits")
for _entry in [FEVTDEBUGEventContent,FEVTDEBUGHLTEventContent,FEVTEventContent]:
phase2_tracker.toModify(_entry, outputCommands = _entry.outputCommands + [
'keep Phase2TrackerDigiedmDetSetVector_mix_*_*',
'keep *_TTClustersFromPhase2TrackerDigis_*_*',
'keep *_TTStubsFromPhase2TrackerDigis_*_*'
])
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
for _entry in [FEVTDEBUGEventContent,FEVTDEBUGHLTEventContent,FEVTEventContent]:
run2_GEM_2017.toModify(_entry, outputCommands = _entry.outputCommands + ['keep *_muonGEMDigis_*_*'])
run3_GEM.toModify(_entry, outputCommands = _entry.outputCommands + ['keep *_muonGEMDigis_*_*'])
phase2_muon.toModify(_entry, outputCommands = _entry.outputCommands + ['keep *_muonGEMDigis_*_*'])
pp_on_AA_2018.toModify(_entry, outputCommands = _entry.outputCommands + ['keep FEDRawDataCollection_rawDataRepacker_*_*'])
from RecoLocalFastTime.Configuration.RecoLocalFastTime_EventContent_cff import RecoLocalFastTimeFEVT, RecoLocalFastTimeRECO, RecoLocalFastTimeAOD
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
def _addOutputCommands(mod, newCommands):
phase2_timing_layer.toModify(mod, outputCommands = mod.outputCommands + newCommands.outputCommands)
_addOutputCommands(FEVTDEBUGEventContent,RecoLocalFastTimeFEVT)
_addOutputCommands(FEVTDEBUGHLTEventContent,RecoLocalFastTimeFEVT)
_addOutputCommands(FEVTEventContent,RecoLocalFastTimeFEVT)
_addOutputCommands(RECOSIMEventContent,RecoLocalFastTimeRECO)
_addOutputCommands(AODSIMEventContent,RecoLocalFastTimeAOD)
from RecoMTD.Configuration.RecoMTD_EventContent_cff import RecoMTDFEVT, RecoMTDRECO, RecoMTDAOD
ctpps.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + RecoCTPPSFEVT.outputCommands)
phase2_hgcal.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + TICL_FEVT.outputCommands)
phase2_tracker.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + [
'keep Phase2TrackerDigiedmDetSetVector_mix_*_*',
'keep *_TTClustersFromPhase2TrackerDigis_*_*',
'keep *_TTStubsFromPhase2TrackerDigis_*_*',
'keep *_TrackerDTC_*_*',
'keep *_*_Level1TTTracks_*'])
phase2_muon.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
run2_GEM_2017.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
run3_GEM.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
pp_on_AA.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + ['keep FEDRawDataCollection_rawDataRepacker_*_*'])
phase2_timing_layer.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + RecoLocalFastTimeFEVT.outputCommands)
phase2_timing_layer.toModify(FEVTEventContent,
outputCommands = FEVTEventContent.outputCommands + RecoMTDFEVT.outputCommands)
FEVTHLTALLEventContent = cms.PSet(
outputCommands = cms.untracked.vstring('drop *'),
splitLevel = cms.untracked.int32(0),
)
FEVTHLTALLEventContent.outputCommands.extend(FEVTEventContent.outputCommands)
FEVTHLTALLEventContent.outputCommands.append('keep *_*_*_HLT')
#
#
InputObjects=cms.InputTag("SETMuonSeed"),
MuonTrajectoryBuilder=cms.string("DirectMuonTrajectoryBuilder"),
STATrajBuilderParameters=cms.PSet(SeedTransformerParameters=cms.PSet(
Fitter=cms.string('KFFitterSmootherSTA'),
RescaleError=cms.double(1.0),
MuonRecHitBuilder=cms.string('MuonRecHitBuilder'),
Propagator=cms.string('SteppingHelixPropagatorAny'),
NMinRecHits=cms.uint32(2),
# careful - used with UseSegmentsInTrajectory in SETMuonSeed_cfi.py
# UseSubRecHits = cms.bool(True)
UseSubRecHits=cms.bool(False))))
_enableGEMMeasurement = dict(EnableGEMMeasurement=True)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(standAloneMuons,
STATrajBuilderParameters=dict(
FilterParameters=_enableGEMMeasurement,
BWFilterParameters=_enableGEMMeasurement))
_enableME0Measurement = dict(EnableME0Measurement=True)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(standAloneMuons,
STATrajBuilderParameters=dict(
FilterParameters=_enableME0Measurement,
BWFilterParameters=_enableME0Measurement))
_disableME0Measurement = dict(EnableME0Measurement=False)
from Configuration.Eras.Modifier_phase2_GE0_cff import phase2_GE0
phase2_GE0.toModify(standAloneMuons,
STATrajBuilderParameters=dict(
FilterParameters=_disableME0Measurement,
BWFilterParameters=_disableME0Measurement))
nPhi = cms.int32(72)
)
muonDetIdAssociator = cms.ESProducer("DetIdAssociatorESProducer",
ComponentName = cms.string('MuonDetIdAssociator'),
etaBinSize = cms.double(0.125),
nEta = cms.int32(48),
nPhi = cms.int32(48),
includeBadChambers = cms.bool(False),
includeGEM = cms.bool(False),
includeME0 = cms.bool(False)
)
# If running in Run 2, include bad chambers
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify( muonDetIdAssociator, includeBadChambers = True )
# include GEM & ME0 for phase2
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( muonDetIdAssociator, includeGEM = True )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( muonDetIdAssociator, includeME0 = True )
phase2_muon.toModify( hcalDetIdAssociator, hcalRegion = 1 )
preshowerDetIdAssociator = cms.ESProducer("DetIdAssociatorESProducer",
ComponentName = cms.string('PreshowerDetIdAssociator'),
etaBinSize = cms.double(0.1),
nEta = cms.int32(60),
nPhi = cms.int32(30)
)
cms.InputTag('cscpacker', 'CSCRawData'),
cms.InputTag('csctfpacker', 'CSCTFRawData'),
cms.InputTag('dtpacker'),
cms.InputTag('dttfpacker'),
cms.InputTag('ecalPacker'),
cms.InputTag('esDigiToRaw'),
cms.InputTag('gctDigiToRaw'),
cms.InputTag('hcalRawDataVME'),
cms.InputTag('l1GtEvmPack'),
cms.InputTag('l1GtPack'),
cms.InputTag('rpcpacker'),
cms.InputTag('siPixelRawData')
),
)
#
# Make changes if using the Stage 1 trigger
#
from Configuration.Eras.Modifier_stage1L1Trigger_cff import stage1L1Trigger
stage1L1Trigger.toModify( rawDataCollector.RawCollectionList, func = lambda list: list.append(cms.InputTag("l1tDigiToRaw")) )
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
run2_HCAL_2017.toModify( rawDataCollector.RawCollectionList, func = lambda list: list.append(cms.InputTag("hcalRawDatauHTR")) )
# GEM settings
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify( rawDataCollector.RawCollectionList, func = lambda list: list.append(cms.InputTag("gemPacker")) )
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( rawDataCollector.RawCollectionList, func = lambda list: list.append(cms.InputTag("gemPacker")) )
run2_common.toModify(SimMuonRAW.outputCommands,
func=lambda outputCommands: outputCommands.append(
'keep *_simMuonRPCDigis_*_*'))
#RECO content
SimMuonRECO = cms.PSet(outputCommands=cms.untracked.vstring(
'keep StripDigiSimLinkedmDetSetVector_simMuonCSCDigis_*_*',
'keep DTLayerIdDTDigiSimLinkMuonDigiCollection_simMuonDTDigis_*_*',
'keep RPCDigiSimLinkedmDetSetVector_simMuonRPCDigis_*_*'))
#AOD content
SimMuonAOD = cms.PSet(outputCommands=cms.untracked.vstring())
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
SimMuonFEVTDEBUG,
outputCommands=SimMuonFEVTDEBUG.outputCommands + [
'keep *_simMuonGEMDigis_*_*', 'keep *_simMuonGEMPadDigis_*_*',
'keep *_simMuonGEMPadDigiClusters_*_*'
])
run3_GEM.toModify(SimMuonRAW,
outputCommands=SimMuonRAW.outputCommands +
['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'])
run3_GEM.toModify(SimMuonRECO,
outputCommands=SimMuonRECO.outputCommands +
['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'])
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
SimMuonFEVTDEBUG,
outputCommands=SimMuonFEVTDEBUG.outputCommands + [
'keep *_simMuonME0PseudoDigis_*_*',
'keep *_simMuonME0PseudoReDigis_*_*', 'keep *_simMuonME0Digis_*_*',
'keep *_simMuonME0PadDigis_*_*', 'keep *_simMuonME0PadDigiClusters_*_*'
'SteppingHelixPropagatorAnyNoError',
'SteppingHelixPropagatorAlongNoError',
'SteppingHelixPropagatorOppositeNoError',
'SteppingHelixPropagatorL2AnyNoError',
'SteppingHelixPropagatorL2AlongNoError',
'SteppingHelixPropagatorL2OppositeNoError',
'PropagatorWithMaterial',
'PropagatorWithMaterialOpposite',
'SmartPropagator',
'SmartPropagatorOpposite',
'SmartPropagatorAnyOpposite',
'SmartPropagatorAny',
'SmartPropagatorRK',
'SmartPropagatorAnyRK',
'StraightLinePropagator'),
RPCLayers=cms.bool(True),
CSCLayers=cms.untracked.bool(True),
GEMLayers=cms.untracked.bool(False),
ME0Layers=cms.bool(False),
UseMuonNavigation=cms.untracked.bool(True)))
# run3_GEM
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(MuonServiceProxy,
ServiceParameters=dict(GEMLayers=cms.untracked.bool(True)))
# phase2_muon
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(MuonServiceProxy,
ServiceParameters=dict(ME0Layers=cms.bool(True)))
# to reproduce events using the RandomEngineStateProducer (source excluded),
# decomment the following one
# ,restoreStateLabel = cms.untracked.string('randomEngineStateProducer')
)
randomEngineStateProducer = cms.EDProducer("RandomEngineStateProducer")
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(RandomNumberGeneratorService, simMuonGEMDigis = cms.PSet(
initialSeed = cms.untracked.uint32(1234567),
engineName = FullSimEngine) )
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
RandomNumberGeneratorService,
simMuonGEMDigis = cms.PSet(
initialSeed = cms.untracked.uint32(1234567),
engineName = FullSimEngine)
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
RandomNumberGeneratorService,
simMuonME0Digis = cms.PSet(
initialSeed = cms.untracked.uint32(1234567),
engineName = FullSimEngine),
simMuonME0PseudoDigis = cms.PSet(
initialSeed = cms.untracked.uint32(1234567),
engineName = FullSimEngine),
simMuonME0PseudoReDigis = cms.PSet(
initialSeed = cms.untracked.uint32(7654321),
engineName = FullSimEngine),
## muonAssociatorByHits using only digiSimLinks (and TrackingParticles),
## not accessing the PSimHits directly. Useful if you run on RECOSIM without RAWSIM
from SimMuon.MCTruth.MuonAssociatorByHits_cfi import muonAssociatorByHitsCommonParameters
muonAssociatorByHitsNoSimHitsHelper = cms.EDProducer("MuonToTrackingParticleAssociatorEDProducer",
muonAssociatorByHitsCommonParameters
)
# don't read simhits, they're not there
muonAssociatorByHitsNoSimHitsHelper.CSCsimHitsTag = ""
muonAssociatorByHitsNoSimHitsHelper.RPCsimhitsTag = ""
muonAssociatorByHitsNoSimHitsHelper.GEMsimhitsTag = ""
muonAssociatorByHitsNoSimHitsHelper.DTsimhitsTag = ""
### The following was used when running only on RECO
# don't normalize on the total number of hits (which is unknown, if I don't have simHits)
#muonAssociatorByHitsNoSimHitsHelper.AbsoluteNumberOfHits_muon = True
#muonAssociatorByHitsNoSimHitsHelper.AbsoluteNumberOfHits_track = True
#
### currently this is dealt with in the code itself (MuonAssociatorByHitsHelper.cc)
### to allow ranking the simToReco matches according to the number of shared hits:
### this is relevant for the definition of duplicates
# use only muon system
muonAssociatorByHitsNoSimHitsHelper.UseTracker = False
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( muonAssociatorByHitsNoSimHitsHelper, useGEMs = cms.bool(True) )
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify( muonAssociatorByHitsNoSimHitsHelper, usePhase2Tracker = cms.bool(True) )
phase2_tracker.toModify( muonAssociatorByHitsNoSimHitsHelper, pixelSimLinkSrc = "simSiPixelDigis:Pixel" )
## unganging in ME1/a
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify( cscTriggerPrimitiveDigis,
debugParameters = True,
checkBadChambers = False,
commonParam = dict(gangedME1a = False),
)
## GEM-CSC ILT in ME1/1
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( cscTriggerPrimitiveDigis,
GEMPadDigiProducer = cms.InputTag("simMuonGEMPadDigis"),
GEMPadDigiClusterProducer = cms.InputTag("simMuonGEMPadDigiClusters"),
commonParam = dict(isSLHC = True,
runME11Up = cms.bool(True),
runME11ILT = cms.bool(True),
useClusters = cms.bool(False),
enableAlctSLHC = cms.bool(True)),
clctSLHC = dict(clctNplanesHitPattern = 3),
me11tmbSLHCGEM = me11tmbSLHCGEM,
copadParamGE11 = copadParamGE11
)
## GEM-CSC ILT in ME2/1, CSC in ME3/1 and ME4/1
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( cscTriggerPrimitiveDigis,
commonParam = dict(runME21Up = cms.bool(True),
runME21ILT = cms.bool(True),
runME31Up = cms.bool(True),
runME41Up = cms.bool(True)),
tmbSLHC = dict(ignoreAlctCrossClct = cms.bool(True)),
clctSLHC = dict(useDynamicStateMachineZone = cms.bool(True)),
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
run2_HCAL_2017.toModify(
rawDataCollector.RawCollectionList,
func=lambda list: list.append(cms.InputTag("hcalRawDatauHTR")))
# GEM settings
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(
rawDataCollector.RawCollectionList,
func=lambda list: list.append(cms.InputTag("gemPacker")))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(rawDataCollector.RawCollectionList,
func=lambda list: list.append(cms.InputTag("gemPacker")))
# For Run2 it is needed to include the general ctpps era ctpps_2016
from Configuration.Eras.Modifier_ctpps_2021_cff import ctpps_2021
ctpps_2021.toModify(
rawDataCollector.RawCollectionList,
func=lambda list: list.extend(
[cms.InputTag("ctppsTotemRawData"),
cms.InputTag("ctppsPixelRawData")]))
# Phase-2 Tracker
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify(
rawDataCollector.RawCollectionList,
outputCommands = cms.untracked.vstring(
'keep *_mix_g4SimHitsMuonDTHits_*',
'keep *_mix_g4SimHitsMuonCSCHits_*',
'keep *_mix_g4SimHitsMuonRPCHits_*',
)
)
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonGEMDigis_*_*'] )
run2_GEM_2017.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] )
run2_GEM_2017.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] )
run2_GEM_2017.toModify( SimMuonPREMIX, outputCommands = SimMuonPREMIX.outputCommands + ['keep *_mix_g4SimHitsMuonGEMHits_*'] )
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonGEMDigis_*_*'] )
run3_GEM.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] )
run3_GEM.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] )
run3_GEM.toModify( SimMuonPREMIX, outputCommands = SimMuonPREMIX.outputCommands + ['keep *_mix_g4SimHitsMuonGEMHits_*'] )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonME0PseudoDigis_*_*',
'keep *_simMuonME0PseudoReDigis_*_*',
'keep *_simMuonME0Digis_*_*'] )
phase2_muon.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] )
phase2_muon.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] )
phase2_muon.toModify( SimMuonPREMIX, outputCommands = SimMuonPREMIX.outputCommands + ['keep *_mix_g4SimHitsMuonME0Hits_*'] )
# FastSim uses different naming convention
from Configuration.Eras.Modifier_fastSim_cff import fastSim
def setCrossingFrameOn(process):
process.mix.mixObjects.mixCH.crossingFrames = cms.untracked.vstring(
'CaloHitsTk',
'CastorBU',
'CastorFI',
'CastorPL',
'CastorTU',
'EcalHitsEB',
'EcalHitsEE',
'EcalHitsES',
'EcalTBH4BeamHits',
'HcalHits',
'HcalTB06BeamHits',
'ZDCHITS')
process.mix.mixObjects.mixTracks.makeCrossingFrame = cms.untracked.bool(True)
process.mix.mixObjects.mixVertices.makeCrossingFrame = cms.untracked.bool(True)
process.mix.mixObjects.mixHepMC.makeCrossingFrame = cms.untracked.bool(True)
process.mix.mixObjects.mixSH.crossingFrames = cms.untracked.vstring(
'BSCHits',
'FP420SI',
'MuonCSCHits',
'MuonDTHits',
'MuonRPCHits',
'TotemHitsRP',
'TotemHitsT1',
'TotemHitsT2Gem',
'TrackerHitsPixelBarrelHighTof',
'TrackerHitsPixelBarrelLowTof',
'TrackerHitsPixelEndcapHighTof',
'TrackerHitsPixelEndcapLowTof',
'TrackerHitsTECHighTof',
'TrackerHitsTECLowTof',
'TrackerHitsTIBHighTof',
'TrackerHitsTIBLowTof',
'TrackerHitsTIDHighTof',
'TrackerHitsTIDLowTof',
'TrackerHitsTOBHighTof',
'TrackerHitsTOBLowTof')
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify( process.mix.mixObjects,
mixSH = dict(
crossingFrames = process.mix.mixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ]
)
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( process.mix.mixObjects,
mixSH = dict(
crossingFrames = process.mix.mixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ]
)
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( process.mix.mixObjects,
mixSH = dict(
crossingFrames = process.mix.mixObjects.mixSH.crossingFrames + [ 'MuonME0Hits' ]
)
)
return(process)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(trackingParticles,
# for unknown reasons, fastsim needs this flag on
allowDifferentSimHitProcesses = True,
# fastsim labels for simhits, simtracks, simvertices
simHitCollections = cms.PSet(
muon = cms.VInputTag( cms.InputTag('MuonSimHits','MuonDTHits'),
cms.InputTag('MuonSimHits','MuonCSCHits'),
cms.InputTag('MuonSimHits','MuonRPCHits') ),
trackerAndPixel = cms.VInputTag( cms.InputTag('famosSimHits','TrackerHits') )
),
simTrackCollection = 'famosSimHits',
simVertexCollection = 'famosSimHits'
)
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(trackingParticles, simHitCollections = dict(
muon = trackingParticles.simHitCollections.muon+[cms.InputTag("g4SimHits","MuonGEMHits")]))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(trackingParticles, simHitCollections = dict(
muon = trackingParticles.simHitCollections.muon+[cms.InputTag("g4SimHits","MuonGEMHits")]))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( trackingParticles, simHitCollections = dict(
muon = trackingParticles.simHitCollections.muon+[cms.InputTag("g4SimHits","MuonME0Hits")]))
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify( trackingParticles, simHitCollections = dict( tracker = []) )
# ,restoreStateLabel = cms.untracked.string('randomEngineStateProducer')
)
randomEngineStateProducer = cms.EDProducer("RandomEngineStateProducer")
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(RandomNumberGeneratorService,
simMuonGEMDigis=cms.PSet(
initialSeed=cms.untracked.uint32(1234567),
engineName=FullSimEngine))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(RandomNumberGeneratorService,
simMuonGEMDigis=cms.PSet(
initialSeed=cms.untracked.uint32(1234567),
engineName=FullSimEngine))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
RandomNumberGeneratorService,
simMuonME0Digis=cms.PSet(initialSeed=cms.untracked.uint32(1234567),
engineName=FullSimEngine),
simMuonME0PseudoDigis=cms.PSet(initialSeed=cms.untracked.uint32(1234567),
engineName=FullSimEngine),
simMuonME0PseudoReDigis=cms.PSet(initialSeed=cms.untracked.uint32(7654321),
engineName=FullSimEngine),
simMuonME0PseudoReDigisCoarse=cms.PSet(
initialSeed=cms.untracked.uint32(2234567), engineName=FullSimEngine),
)
# customisation function.
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify( SimMuonRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simMuonCSCDigis_*_*') )
run2_common.toModify( SimMuonRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simMuonRPCDigis_*_*') )
#RECO content
SimMuonRECO = cms.PSet(
outputCommands = cms.untracked.vstring('keep StripDigiSimLinkedmDetSetVector_simMuonCSCDigis_*_*',
'keep DTLayerIdDTDigiSimLinkMuonDigiCollection_simMuonDTDigis_*_*',
'keep RPCDigiSimLinkedmDetSetVector_simMuonRPCDigis_*_*')
)
#AOD content
SimMuonAOD = cms.PSet(
outputCommands = cms.untracked.vstring()
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonGEMDigis_*_*',
'keep *_simMuonGEMPadDigis_*_*',
'keep *_simMuonGEMPadDigiClusters_*_*'] )
run3_GEM.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] )
run3_GEM.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonME0PseudoDigis_*_*',
'keep *_simMuonME0PseudoReDigis_*_*',
'keep *_simMuonME0Digis_*_*',
'keep *_simMuonME0PadDigis_*_*',
'keep *_simMuonME0PadDigiClusters_*_*'] )
phase2_muon.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] )
phase2_muon.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] )
# to save the status of the last event (useful for crashes)
,saveFileName = cms.untracked.string('')
# to restore the status of the last event,
# comment the line above and decomment the following one
# ,restoreFileName = cms.untracked.string('RandomEngineState.log')
# to reproduce events using the RandomEngineStateProducer (source excluded),
# decomment the following one
# ,restoreStateLabel = cms.untracked.string('randomEngineStateProducer')
)
randomEngineStateProducer = cms.EDProducer("RandomEngineStateProducer")
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
RandomNumberGeneratorService,
simMuonGEMDigis = cms.PSet(
initialSeed = cms.untracked.uint32(1234567),
engineName = cms.untracked.string('HepJamesRandom'))
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
RandomNumberGeneratorService,
simMuonME0Digis = cms.PSet(
initialSeed = cms.untracked.uint32(1234567),
engineName = cms.untracked.string('HepJamesRandom')),
simMuonME0PseudoDigis = cms.PSet(
initialSeed = cms.untracked.uint32(1234567),
engineName = cms.untracked.string('HepJamesRandom')),
simMuonME0PseudoReDigis = cms.PSet(
initialSeed = cms.untracked.uint32(7654321),
engineName = cms.untracked.string('HepJamesRandom')),
import FWCore.ParameterSet.Config as cms
# AOD content
RecoLocalMuonAOD = cms.PSet(outputCommands=cms.untracked.vstring())
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
run2_GEM_2017.toModify(RecoLocalMuonAOD,
outputCommands=RecoLocalMuonAOD.outputCommands +
['keep *_gemRecHits_*_*', 'keep *_gemSegments_*_*'])
run3_GEM.toModify(RecoLocalMuonAOD,
outputCommands=RecoLocalMuonAOD.outputCommands +
['keep *_gemRecHits_*_*', 'keep *_gemSegments_*_*'])
phase2_muon.toModify(RecoLocalMuonAOD,
outputCommands=RecoLocalMuonAOD.outputCommands +
['keep *_me0RecHits_*_*', 'keep *_me0Segments_*_*'])
# RECO content
RecoLocalMuonRECO = cms.PSet(outputCommands=cms.untracked.vstring(
'keep *_muonDTDigis_*_*', 'keep *_dttfDigis_*_*', 'keep *_dt1DRecHits_*_*',
'keep *_dt4DSegments_*_*', 'keep *_dt4DSegmentsT0Seg_*_*',
'keep *_csc2DRecHits_*_*', 'keep *_cscSegments_*_*',
'keep RPCDetIdRPCDigiMuonDigiCollection_muonRPCDigis_*_*',
'keep *_rpcRecHits_*_*'))
RecoLocalMuonRECO.outputCommands.extend(RecoLocalMuonAOD.outputCommands)
# Full Event content
RecoLocalMuonFEVT = cms.PSet(outputCommands=cms.untracked.vstring(
'keep RPCDetIdRPCDigiMuonDigiCollection_*_*_*'))
RecoLocalMuonFEVT.outputCommands.extend(RecoLocalMuonRECO.outputCommands)
#
minHit = cms.double(-0.5),
maxHit = cms.double(74.5),
nintHit = cms.int32(75),
#
minPhi = cms.double(-3.1416),
maxPhi = cms.double(3.1416),
nintPhi = cms.int32(36),
#
minDxy = cms.double(-3),
maxDxy = cms.double(3),
nintDxy = cms.int32(100),
#
minDz = cms.double(-10),
maxDz = cms.double(10),
nintDz = cms.int32(100),
# TP originating vertical position
minVertpos = cms.double(0),
maxVertpos = cms.double(5),
nintVertpos = cms.int32(100),
# TP originating z position
minZpos = cms.double(-10),
maxZpos = cms.double(10),
nintZpos = cms.int32(100)
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( muonTrackValidator, useGEMs = cms.bool(True) )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( muonTrackValidator, useME0 = cms.bool(True) )
import FWCore.ParameterSet.Config as cms
# Import from the generic cfi file for CSC unpacking
from EventFilter.CSCRawToDigi.muonCSCDCCUnpacker_cfi import muonCSCDCCUnpacker
muonCSCDigis = muonCSCDCCUnpacker.clone(
# This mask is needed by the examiner
ExaminerMask = 0x1FEBF7F6
)
## in Run-3 include GEMs
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( muonCSCDigis,
useGEMs = False,
useCSCShowers = True
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(L1TriggerFEVTDEBUG, func=_appendHGCalDigis)
# adding GEM trigger primitives
def _appendGEMDigis(obj):
l1GEMDigis = [
'keep *_simMuonGEMPadDigis_*_*',
'keep *_simMuonGEMPadDigiClusters_*_*',
]
obj.outputCommands += l1GEMDigis
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(L1TriggerFEVTDEBUG, func=_appendGEMDigis)
# adding ME0 trigger primitives
def _appendME0Digis(obj):
l1ME0Digis = [
'keep *_simMuonME0PadDigis__*',
'keep *_me0TriggerDigis__*',
'keep *_simMuonME0PseudoReDigisCoarse__*',
'keep *_me0RecHitsCoarse__*',
'keep *_me0TriggerPseudoDigis__*',
'keep *_me0TriggerConvertedPseudoDigis__*',
]
obj.outputCommands += l1ME0Digis
simHitCollections=cms.PSet(muon=cms.VInputTag(
cms.InputTag('MuonSimHits', 'MuonDTHits'),
cms.InputTag('MuonSimHits', 'MuonCSCHits'),
cms.InputTag('MuonSimHits', 'MuonRPCHits')),
trackerAndPixel=cms.VInputTag(
cms.InputTag('famosSimHits',
'TrackerHits'))),
simTrackCollection='famosSimHits',
simVertexCollection='famosSimHits')
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(
trackingParticles,
simHitCollections=dict(muon=trackingParticles.simHitCollections.muon +
[cms.InputTag("g4SimHits", "MuonGEMHits")]))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
trackingParticles,
simHitCollections=dict(muon=trackingParticles.simHitCollections.muon +
[cms.InputTag("g4SimHits", "MuonGEMHits")]))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
trackingParticles,
simHitCollections=dict(muon=trackingParticles.simHitCollections.muon +
[cms.InputTag("g4SimHits", "MuonME0Hits")]))
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify(trackingParticles, simHitCollections=dict(tracker=[]))
## unganging in ME1/a
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify( cscTriggerPrimitiveDigis,
debugParameters = True,
checkBadChambers = False,
commonParam = dict(gangedME1a = False)
)
## GEM-CSC ILT in ME1/1
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( cscTriggerPrimitiveDigis,
GEMPadDigiProducer = cms.InputTag("simMuonGEMPadDigis"),
commonParam = dict(isSLHC = cms.bool(True),
smartME1aME1b = cms.bool(True),
runME11ILT = cms.bool(True)),
clctSLHC = dict(clctNplanesHitPattern = 3),
me11tmbSLHCGEM = me11tmbSLHCGEM,
copadParam = copadParam
)
## GEM-CSC ILT in ME2/1, CSC-RPC ILT in ME3/1 and ME4/1
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( cscTriggerPrimitiveDigis,
RPCDigiProducer = cms.InputTag("simMuonRPCDigis"),
commonParam = dict(runME21ILT = cms.bool(True),
runME3141ILT = cms.bool(False)),
alctSLHCME21 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 3),
clctSLHCME21 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 3),
alctSLHCME3141 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 3),
clctSLHCME3141 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 3),
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hgceeDigitizer, hgchefrontDigitizer, hfnoseDigitizer
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonGEMHits") ],
subdets = theMixObjects.mixSH.subdets + [ 'MuonGEMHits' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ]
)
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonGEMHits") ],
subdets = theMixObjects.mixSH.subdets + [ 'MuonGEMHits' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ]
)
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonME0Hits") ],
subdets = theMixObjects.mixSH.subdets + [ 'MuonME0Hits' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonME0Hits' ]
)
)
from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1
(premix_stage1 & phase2_muon).toModify(theMixObjects,
mixSH = dict(
pcrossingFrames = theMixObjects.mixSH.pcrossingFrames + [ 'MuonME0Hits' ]
#
# ... reco::Track collection
# tracksTag = cms.InputTag("standAloneMuons"),
# tracksTag = cms.InputTag("standAloneMuons","UpdatedAtVtx"),
# tracksTag = cms.InputTag("standAloneSETMuons"),
# tracksTag = cms.InputTag("standAloneSETMuons","UpdatedAtVtx"),
# tracksTag = cms.InputTag("cosmicMuons"),
tracksTag = cms.InputTag("globalMuons"),
# tracksTag = cms.InputTag("tevMuons","firstHit"),
# tracksTag = cms.InputTag("tevMuons","picky"),
# tracksTag = cms.InputTag("globalSETMuons"),
# tracksTag = cms.InputTag("globalCosmicMuons"),
# tracksTag = cms.InputTag("generalTracks"),
# tracksTag = cms.InputTag("ctfWithMaterialTracksP5LHCNavigation"),
# tracksTag = cms.InputTag("hltL2Muons"),
# tracksTag = cms.InputTag("hltL2Muons","UpdatedAtVtx"),
# tracksTag = cms.InputTag("hltL3Muons")
# tracksTag = cms.InputTag("hltL3Muons","L2Seeded")
# tracksTag = cms.InputTag("hltL3TkTracksFromL2")
#
# ... TrackingParticle collection
tpTag = cms.InputTag("mix","MergedTrackTruth"),
ignoreMissingTrackCollection = cms.untracked.bool(False),
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( muonAssociatorByHits, useGEMs = cms.bool(True) )
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify( muonAssociatorByHits, usePhase2Tracker = cms.bool(True) )
phase2_tracker.toModify( muonAssociatorByHits, pixelSimLinkSrc = "simSiPixelDigis:Pixel" )
promoteALCTRPCquality=cms.bool(True),
)
## unganging in ME1/a
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify(cscTriggerPrimitiveDigis,
debugParameters=True,
checkBadChambers=False,
commonParam=dict(gangedME1a=False))
## GEM-CSC ILT in ME1/1
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(cscTriggerPrimitiveDigis,
GEMPadDigiProducer=cms.InputTag("simMuonGEMPadDigis"),
commonParam=dict(isSLHC=cms.bool(True),
smartME1aME1b=cms.bool(True),
runME11ILT=cms.bool(True)),
clctSLHC=dict(clctNplanesHitPattern=3),
me11tmbSLHCGEM=me11tmbSLHCGEM)
## GEM-CSC ILT in ME2/1, CSC-RPC ILT in ME3/1 and ME4/1
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(cscTriggerPrimitiveDigis,
RPCDigiProducer=cms.InputTag("simMuonRPCDigis"),
commonParam=dict(runME21ILT=cms.bool(True),
runME3141ILT=cms.bool(False)),
alctSLHCME21=cscTriggerPrimitiveDigis.alctSLHC.clone(
alctNplanesHitPattern=3),
clctSLHCME21=cscTriggerPrimitiveDigis.clctSLHC.clone(
clctNplanesHitPattern=3),
alctSLHCME3141=cscTriggerPrimitiveDigis.alctSLHC.clone(
'TrackerHitsTOBHighTof',
'TrackerHitsTECLowTof',
'TrackerHitsTECHighTof',
'TrackerHitsPixelBarrelLowTof',
'TrackerHitsPixelBarrelHighTof',
'TrackerHitsPixelEndcapLowTof',
'TrackerHitsPixelEndcapHighTof'),
#
# to associate to reco::Muon segments
inputDTRecSegment4DCollection = cms.InputTag("dt4DSegments"),
inputCSCSegmentCollection = cms.InputTag("cscSegments"),
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
run3_GEM.toModify(muonAssociatorByHitsCommonParameters, useGEMs = True)
phase2_tracker.toModify(muonAssociatorByHitsCommonParameters,
usePhase2Tracker = True,
pixelSimLinkSrc = "simSiPixelDigis:Pixel",
)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(muonAssociatorByHitsCommonParameters,
simtracksTag = "fastSimProducer",
DTsimhitsTag = "MuonSimHits:MuonDTHits",
CSCsimHitsTag = "MuonSimHits:MuonCSCHits",
RPCsimhitsTag = "MuonSimHits:MuonRPCHits",
simtracksXFTag = "mix:fastSimProducer",
DTsimhitsXFTag = "mix:MuonSimHitsMuonDTHits",
CSCsimHitsXFTag = "mix:MuonSimHitsMuonCSCHits",
RPCsimhitsXFTag = "mix:MuonSimHitsMuonRPCHits",
signalOnlyTP=cms.bool(True),
intimeOnlyTP=cms.bool(False),
minRapidityTP=cms.double(-2.6),
minHitTP=cms.int32(3),
ptMinTP=cms.double(0.2),
ptMaxTP=cms.double(1e100),
maxRapidityTP=cms.double(2.6),
tipTP=cms.double(1000)))
trackingParticleSelection = cms.Sequence(mergedtruth)
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(
trackingParticleSelection,
simHitCollections=dict(
muon=trackingParticleSelection.simHitCollections.muon +
["g4SimHitsMuonGEMHits"]))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(trackingParticleSelection,
simHitCollections=dict(
muon=trackingParticleSelection.simHitCollections.muon +
["g4SimHitsMuonGEMHits"]))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
trackingParticleSelection,
simHitCollections=dict(
muon=trackingParticleSelection.simHitCollections.muon +
["g4SimHitsMuonME0Hits"]))
# arbitration cleaning
runArbitrationCleaner=cms.bool(True),
arbitrationCleanerOptions=cms.PSet(
ME1a=cms.bool(True),
Overlap=cms.bool(True),
Clustering=cms.bool(True),
OverlapDPhi=cms.double(0.0786), # 4.5 degrees
OverlapDTheta=cms.double(0.02), # 1.14 degrees
ClusterDPhi=cms.double(0.6), # 34 degrees
ClusterDTheta=cms.double(0.02) # 1.14
),
# tracker muon arbitration
arbitrateTrackerMuons=cms.bool(True))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(muons1stStep, TrackAssociatorParameters=dict(useGEM=True))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(muons1stStep, TrackAssociatorParameters=dict(useME0=True))
from Configuration.Eras.Modifier_phase2_GE0_cff import phase2_GE0
phase2_GE0.toModify(muons1stStep, TrackAssociatorParameters=dict(useME0=False))
muonEcalDetIds = cms.EDProducer("InterestingEcalDetIdProducer",
inputCollection=cms.InputTag("muons1stStep"))
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(muons1stStep, minPt=0.8)
from Configuration.ProcessModifiers.recoFromReco_cff import recoFromReco
recoFromReco.toModify(muons1stStep, fillShowerDigis=False)
import FWCore.ParameterSet.Config as cms from EventFilter.GEMRawToDigi.muonGEMDigisDefault_cfi import muonGEMDigisDefault as _muonGEMDigisDefault muonGEMDigis = _muonGEMDigisDefault.clone() from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM from Configuration.Eras.Modifier_phase2_GEM_cff import phase2_GEM run2_GEM_2017.toModify(muonGEMDigis, useDBEMap = True) run3_GEM.toModify(muonGEMDigis, useDBEMap = True) phase2_GEM.toModify(muonGEMDigis, useDBEMap = False, readMultiBX = True)
## unganging in ME1/a
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify(cscTriggerPrimitiveDigis,
debugParameters=True,
checkBadChambers=False,
commonParam=dict(gangedME1a=False),
mpcParams=mpcParamsRun2)
## GEM-CSC ILT in ME1/1
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
cscTriggerPrimitiveDigis,
GEMPadDigiProducer=cms.InputTag("simMuonGEMPadDigis"),
GEMPadDigiClusterProducer=cms.InputTag("simMuonGEMPadDigiClusters"),
commonParam=dict(isSLHC=True,
runME11Up=cms.bool(True),
runME11ILT=cms.bool(True),
useClusters=cms.bool(False),
enableAlctSLHC=cms.bool(True)),
clctSLHC=dict(clctNplanesHitPattern=3),
me11tmbSLHCGEM=me11tmbSLHCGEM,
copadParamGE11=copadParamGE11)
## GEM-CSC ILT in ME2/1, CSC in ME3/1 and ME4/1
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(cscTriggerPrimitiveDigis,
commonParam=dict(runME21Up=cms.bool(True),
runME21ILT=cms.bool(True),
runME31Up=cms.bool(True),
runME41Up=cms.bool(True)),
tmbSLHC=dict(ignoreAlctCrossClct=cms.bool(False)),
alctSLHCME21=cscTriggerPrimitiveDigis.alctSLHC.clone(
debugParameters=True,
checkBadChambers=False,
commonParam=dict(gangedME1a=False),
mpcParam=auxPSets.mpcParamRun2.clone())
## turn on upgrade CSC algorithm without GEMs
## originally intended for Phase-2, but moved up to Run-3
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify(cscTriggerPrimitiveDigis,
keepShowers=True,
commonParam=dict(run3=True,
runCCLUT_OTMB=True,
runPhase2=True,
runME11Up=True,
runME21Up=True,
runME31Up=True,
runME41Up=True))
## GEM-CSC integrated local trigger in ME1/1
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
cscTriggerPrimitiveDigis,
GEMPadDigiClusterProducer=cms.InputTag("simMuonGEMPadDigiClusters"),
commonParam=dict(runME11ILT=True))
## GEM-CSC integrated local trigger in ME2/1
## enable the Phase-2 ALCT processors
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(cscTriggerPrimitiveDigis,
commonParam=dict(runME21ILT=True, enableAlctPhase2=True))
# calo muons
minCaloCompatibility = cms.double(0.6),
# arbitration cleaning
runArbitrationCleaner = cms.bool(True),
arbitrationCleanerOptions = cms.PSet( ME1a = cms.bool(True),
Overlap = cms.bool(True),
Clustering = cms.bool(True),
OverlapDPhi = cms.double(0.0786), # 4.5 degrees
OverlapDTheta = cms.double(0.02), # 1.14 degrees
ClusterDPhi = cms.double(0.6), # 34 degrees
ClusterDTheta = cms.double(0.02) # 1.14
),
# tracker muon arbitration
arbitrateTrackerMuons = cms.bool(True)
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( muons1stStep, TrackAssociatorParameters = dict(useGEM = cms.bool(True) ) )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( muons1stStep, TrackAssociatorParameters = dict(useME0 = cms.bool(True) ) )
muonEcalDetIds = cms.EDProducer("InterestingEcalDetIdProducer",
inputCollection = cms.InputTag("muons1stStep")
)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(muons1stStep, minPt = 0.8)
),
select = cms.PSet(
lipTP = cms.double(1000),
chargedOnlyTP = cms.bool(True),
pdgIdTP = cms.vint32(),
signalOnlyTP = cms.bool(True),
intimeOnlyTP = cms.bool(False),
minRapidityTP = cms.double(-2.6),
minHitTP = cms.int32(3),
ptMinTP = cms.double(0.2),
ptMaxTP = cms.double(1e100),
maxRapidityTP = cms.double(2.6),
tipTP = cms.double(1000)
)
)
trackingParticleSelection = cms.Sequence(mergedtruth)
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(trackingParticleSelection, simHitCollections = dict(
muon = trackingParticleSelection.simHitCollections.muon+["g4SimHitsMuonGEMHits"]))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(trackingParticleSelection, simHitCollections = dict(
muon = trackingParticleSelection.simHitCollections.muon+["g4SimHitsMuonGEMHits"]))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( trackingParticleSelection, simHitCollections = dict(
muon = trackingParticleSelection.simHitCollections.muon+["g4SimHitsMuonME0Hits"]))
valMuonGEMPadDigis = simMuonGEMPadDigis.clone(InputCollection="muonGEMDigis")
valMuonGEMPadDigiClusters = simMuonGEMPadDigiClusters.clone(
InputCollection="valMuonGEMPadDigis")
# Lookup tables for the CSC TP emulator
from CalibMuon.CSCCalibration.CSCL1TPLookupTableEP_cff import *
# CSC TPG
from L1Trigger.CSCTriggerPrimitives.cscTriggerPrimitiveDigis_cfi import *
valCscStage2Digis = cscTriggerPrimitiveDigis.clone(
CSCComparatorDigiProducer="muonCSCDigis:MuonCSCComparatorDigi",
CSCWireDigiProducer="muonCSCDigis:MuonCSCWireDigi",
GEMPadDigiClusterProducer="",
commonParam=dict(runME11ILT=False))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(valCscStage2Digis,
GEMPadDigiClusterProducer="valMuonGEMPadDigiClusters")
# EMTF
from L1Trigger.L1TMuonEndCap.simEmtfDigis_cfi import *
valEmtfStage2Digis = simEmtfDigis.clone(CSCInput="emtfStage2Digis",
RPCInput="muonRPCDigis",
GEMInput='valMuonGEMPadDigiClusters')
# uGMT
from L1Trigger.L1TMuon.simGmtStage2Digis_cfi import *
valGmtCaloSumDigis = simGmtCaloSumDigis.clone(
caloStage2Layer2Label="valCaloStage2Layer1Digis")
valGmtStage2Digis = simGmtStage2Digis.clone(
barrelTFInput="gmtStage2Digis:BMTF",
overlapTFInput="gmtStage2Digis:OMTF",
forwardTFInput="gmtStage2Digis:EMTF",
simHcalTriggerPrimitiveDigis.inputUpgradeLabel = [
'unpackHcal', # upgrade HBHE
'unpackHcal' # upgrade HF
]
from L1Trigger.Configuration.SimL1Emulator_cff import *
simDtTriggerPrimitiveDigis.digiTag = 'unpackDT'
simCscTriggerPrimitiveDigis.CSCComparatorDigiProducer = 'unpackCSC:MuonCSCComparatorDigi'
simCscTriggerPrimitiveDigis.CSCWireDigiProducer = 'unpackCSC:MuonCSCWireDigi'
simTwinMuxDigis.RPC_Source = 'unpackRPCTwinMux'
simTwinMuxDigis.DTDigi_Source = "unpackTwinMux:PhIn"
simTwinMuxDigis.DTThetaDigi_Source = "unpackTwinMux:ThIn"
run3_GEM.toModify(simMuonGEMPadDigis, InputCollection='unpackGEM')
# -----------------------------------------------------------
# change when availalbe simTwinMux and reliable DTTPs, CSCTPs
cutlist = ['simDtTriggerPrimitiveDigis', 'simCscTriggerPrimitiveDigis']
for b in cutlist:
SimL1EmulatorCore.remove(b)
# -----------------------------------------------------------
# BMTF
simBmtfDigis.DTDigi_Source = "simTwinMuxDigis"
simBmtfDigis.DTDigi_Theta_Source = "unpackBmtf"
# OMTF
simOmtfDigis.srcRPC = 'unpackRPC'
simOmtfDigis.srcDTPh = "unpackBmtf"
'TrackerHitsTIDLowTof', 'TrackerHitsTIDHighTof',
'TrackerHitsTOBLowTof', 'TrackerHitsTOBHighTof',
'TrackerHitsTECLowTof', 'TrackerHitsTECHighTof',
'TrackerHitsPixelBarrelLowTof',
'TrackerHitsPixelBarrelHighTof',
'TrackerHitsPixelEndcapLowTof',
'TrackerHitsPixelEndcapHighTof'),
#
# to associate to reco::Muon segments
inputDTRecSegment4DCollection=cms.InputTag("dt4DSegments"),
inputCSCSegmentCollection=cms.InputTag("cscSegments"),
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
run3_GEM.toModify(muonAssociatorByHitsCommonParameters, useGEMs=True)
phase2_tracker.toModify(
muonAssociatorByHitsCommonParameters,
usePhase2Tracker=True,
pixelSimLinkSrc="simSiPixelDigis:Pixel",
)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(muonAssociatorByHitsCommonParameters,
simtracksTag="fastSimProducer",
DTsimhitsTag="MuonSimHits:MuonDTHits",
CSCsimHitsTag="MuonSimHits:MuonCSCHits",
RPCsimhitsTag="MuonSimHits:MuonRPCHits",
simtracksXFTag="mix:fastSimProducer",
DTsimhitsXFTag="mix:MuonSimHitsMuonDTHits",
CSCsimHitsXFTag="mix:MuonSimHitsMuonCSCHits",
commonParam=dict(runME11ILT=False))
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify(valCscStage2Digis,
keepShowers=True,
commonParam=dict(run3=True,
runCCLUT_OTMB=True,
runPhase2=True,
runME11Up=True,
runME21Up=True,
runME31Up=True,
runME41Up=True))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(valCscStage2Digis,
GEMPadDigiClusterProducer="valMuonGEMPadDigiClusters",
commonParam=dict(runME11ILT=True))
# EMTF
from L1Trigger.L1TMuonEndCap.simEmtfDigis_cfi import *
valEmtfStage2Digis = simEmtfDigis.clone(CSCInput="emtfStage2Digis",
RPCInput="muonRPCDigis",
GEMInput='valMuonGEMPadDigiClusters')
run3_GEM.toModify(valEmtfStage2Digis,
UseRun3CCLUT_OTMB=cms.bool(True),
Era=cms.string('Run3_2021'))
# EMTF shower
from L1Trigger.L1TMuonEndCap.simEmtfShowers_cfi import *
valEmtfStage2Showers = simEmtfShowers.clone(
CSCShowerInput=cms.InputTag('valCscStage2Digis'))
# ... reco::Track collection
# tracksTag = cms.InputTag("standAloneMuons"),
# tracksTag = cms.InputTag("standAloneMuons","UpdatedAtVtx"),
# tracksTag = cms.InputTag("standAloneSETMuons"),
# tracksTag = cms.InputTag("standAloneSETMuons","UpdatedAtVtx"),
# tracksTag = cms.InputTag("cosmicMuons"),
tracksTag=cms.InputTag("globalMuons"),
# tracksTag = cms.InputTag("tevMuons","firstHit"),
# tracksTag = cms.InputTag("tevMuons","picky"),
# tracksTag = cms.InputTag("globalSETMuons"),
# tracksTag = cms.InputTag("globalCosmicMuons"),
# tracksTag = cms.InputTag("generalTracks"),
# tracksTag = cms.InputTag("ctfWithMaterialTracksP5LHCNavigation"),
# tracksTag = cms.InputTag("hltL2Muons"),
# tracksTag = cms.InputTag("hltL2Muons","UpdatedAtVtx"),
# tracksTag = cms.InputTag("hltL3Muons")
# tracksTag = cms.InputTag("hltL3Muons","L2Seeded")
# tracksTag = cms.InputTag("hltL3TkTracksFromL2")
#
# ... TrackingParticle collection
tpTag=cms.InputTag("mix", "MergedTrackTruth"),
ignoreMissingTrackCollection=cms.untracked.bool(False),
)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(muonAssociatorByHits, useGEMs=cms.bool(True))
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify(muonAssociatorByHits, usePhase2Tracker=cms.bool(True))
phase2_tracker.toModify(muonAssociatorByHits,
pixelSimLinkSrc="simSiPixelDigis:Pixel")
standAloneSETMuons = cms.EDProducer("StandAloneMuonProducer",
MuonTrackLoaderForSTA,
MuonServiceProxy,
InputObjects = cms.InputTag("SETMuonSeed"),
MuonTrajectoryBuilder = cms.string("DirectMuonTrajectoryBuilder"),
STATrajBuilderParameters = cms.PSet(
SeedTransformerParameters = cms.PSet(
Fitter = cms.string('KFFitterSmootherSTA'),
RescaleError = cms.double(1.0),
MuonRecHitBuilder = cms.string('MuonRecHitBuilder'),
Propagator = cms.string('SteppingHelixPropagatorAny'),
NMinRecHits = cms.uint32(2),
# careful - used with UseSegmentsInTrajectory in SETMuonSeed_cfi.py
# UseSubRecHits = cms.bool(True)
UseSubRecHits = cms.bool(False)
)
)
)
_enableGEMMeasurement = dict( EnableGEMMeasurement = cms.bool(True) )
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify( standAloneMuons, STATrajBuilderParameters = dict(
FilterParameters = _enableGEMMeasurement,
BWFilterParameters = _enableGEMMeasurement ) )
_enableME0Measurement = dict( EnableME0Measurement = cms.bool(True) )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( standAloneMuons, STATrajBuilderParameters = dict(
FilterParameters = _enableME0Measurement,
BWFilterParameters = _enableME0Measurement ) )
