def injectTICLintoPF(process):
if getattr(process, 'particleFlowTmp', None):
process.particleFlowTmp.src = ['particleFlowTmpBarrel', 'pfTICL']
if getattr(process, 'particleFlowTmpBarrel', None):
process.particleFlowTmpBarrel.vetoEndcap = True
_insertTrackImportersWithVeto = {}
_trackImporters = [
'GeneralTracksImporter', 'ConvBremTrackImporter',
'ConversionTrackImporter', 'NuclearInteractionTrackImporter'
]
for importer in _trackImporters:
for idx in _findIndicesByModule(process, importer):
_insertTrackImportersWithVeto[idx] = dict(
vetoMode=cms.uint32(2), # pfTICL candidate list
vetoSrc=cms.InputTag("pfTICL"))
phase2_hgcal.toModify(process.particleFlowBlock,
elementImporters=_insertTrackImportersWithVeto)
return process
def replaceTICLwithSimPF(process):
if hasattr(process,'particleFlowTmp'):
process.particleFlowTmp.src = ['particleFlowTmpBarrel', 'simPFProducer']
if hasattr(process,'particleFlowTmpBarrel'):
process.particleFlowTmpBarrel.vetoEndcap = False
_insertTrackImportersWithVeto = {}
_trackImporters = ['GeneralTracksImporter','ConvBremTrackImporter',
'ConversionTrackImporter','NuclearInteractionTrackImporter']
for importer in _trackImporters:
for idx in _findIndicesByModule(process,importer):
_insertTrackImportersWithVeto[idx] = dict(
vetoMode = cms.uint32(0), # HGCal-region PFTrack list for simPF
vetoSrc = cms.InputTag('hgcalTrackCollection:TracksInHGCal')
)
phase2_hgcal.toModify(
process.particleFlowBlock,
elementImporters = _insertTrackImportersWithVeto
)
return process
import FWCore.ParameterSet.Config as cms # Trigger Primitive Producer from SimCalorimetry.EcalTrigPrimProducers.ecalTriggerPrimitiveDigis_with_suppressed_cfi import * # esmodule creating records + corresponding empty essource from SimCalorimetry.EcalTrigPrimProducers.ecalTrigPrimESProducer_mc_cff import * #Common from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toModify( simEcalTriggerPrimitiveDigis, BarrelOnly = cms.bool(True) )
workerType=cms.string("PreMixingPixelDigiSimLinkWorker"),
labelSig=cms.InputTag("simSiPixelDigis:Tracker"),
pileInputTag=cms.InputTag("simSiPixelDigis:Tracker"),
collectionDM=cms.string("Phase2OTDigiSimLink"),
),
),
)
# ECAL
phase2_ecal.toModify(mixData,
workers=dict(ecal=dict(
doES=False,
EBPileInputTag="simEcalDigis:ebDigis",
EEPileInputTag="simEcalDigis:eeDigis",
)))
phase2_hgcal.toModify(mixData, workers=dict(ecal=dict(doEE=False)))
# HCAL
phase2_hcal.toModify(
mixData,
workers=dict(hcal=dict(
HBHEPileInputTag="simHcalDigis",
HOPileInputTag="simHcalDigis",
HFPileInputTag="simHcalDigis",
QIE10PileInputTag="simHcalDigis:HFQIE10DigiCollection",
QIE11PileInputTag="simHcalDigis:HBHEQIE11DigiCollection",
ZDCPileInputTag="simHcalUnsuppressedDigis",
)))
phase2_hgcal.toModify(
mixData,
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
electronMcSignalValidator,
electronCollectionEndcaps='ecalDrivenGsfElectronsHGC',
electronCoreCollection='ecalDrivenGsfElectronCoresHGC',
MaxAbsEta=3.0,
histosCfg=dict(
Nbineta=60,
Nbineta2D=60,
Etamin=-3.0,
Etamax=3.0,
NbinOPV=125,
OPV_min=-0.5,
OPV_max=249.5,
NbinELE=100,
ELE_min=-0.5,
ELE_max=999.5,
NbinCORE=100,
CORE_min=-0.5,
CORE_max=999.5,
NbinTRACK=100,
TRACK_min=-0.5,
TRACK_max=999.5,
NbinSEED=100,
SEED_min=-0.5,
SEED_max=9999.5,
),
)
'keep recoConversions_uncleanedOnlyAllConversions_*_*',
'keep recoTracks_uncleanedOnlyCkfOutInTracksFromConversions_*_*',
'keep recoTracks_uncleanedOnlyCkfInOutTracksFromConversions_*_*',
'keep *_PhotonIDProd_*_*',
'keep *_PhotonIDProdGED_*_*',
'keep *_hfRecoEcalCandidate_*_*',
'keep recoRecoEcalCandidates_hfRecoEcalCandidate_*_*',
'keep *_hfEMClusters_*_*',
'keep *_gedGsfElectronCores_*_*',
'keep *_gedGsfElectrons_*_*'
)
)
# mods for HGCAL
_phase2_hgcal_RecoEgamma_tokeep = [ 'keep *_ecalDrivenGsfElectronCores_*_*', 'keep *_ecalDrivenGsfElectrons_*_*' ]
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( RecoEgammaFEVT, outputCommands = RecoEgammaFEVT.outputCommands + _phase2_hgcal_RecoEgamma_tokeep
)
phase2_hgcal.toModify( RecoEgammaRECO, outputCommands = RecoEgammaRECO.outputCommands + _phase2_hgcal_RecoEgamma_tokeep )
phase2_hgcal.toModify( RecoEgammaAOD, outputCommands = RecoEgammaAOD.outputCommands + _phase2_hgcal_RecoEgamma_tokeep )
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
from Configuration.Eras.Modifier_peripheralPbPb_cff import peripheralPbPb
#HI-specific products needed in pp scenario special configurations
for e in [pA_2016, peripheralPbPb]:
for ec in [RecoEgammaAOD.outputCommands, RecoEgammaRECO.outputCommands, RecoEgammaFEVT.outputCommands]:
e.toModify( ec, func=lambda outputCommands: outputCommands.extend(['keep recoHIPhotonIsolationedmValueMap_photonIsolationHIProducerppGED_*_*',
'keep recoHIPhotonIsolationedmValueMap_photonIsolationHIProducerpp_*_*'
])
)
def _modifyPFEventContentForHGCalFEVT(obj):
obj.outputCommands.append('keep recoPFRecHits_particleFlowClusterECAL__*')
obj.outputCommands.append(
'keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*')
# mods for HGCAL
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
RecoParticleFlowFEVT,
outputCommands=RecoParticleFlowFEVT.outputCommands + [
'keep recoPFRecHits_particleFlowClusterECAL__*',
'keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*',
'keep recoPFRecHits_particleFlowRecHitHGC__*',
'keep recoPFRecHits_particleFlowRecHitHGC_Cleaned_*',
'keep recoPFClusters_particleFlowClusterHGCal__*',
'keep recoPFClusters_particleFlowClusterHGCalFromMultiCl__*',
'keep *_particleFlowSuperClusterHGCalFromMultiCl_*_*',
'keep *_simPFProducer_*_*',
'keep *_particleFlowTmpBarrel_*_*',
])
phase2_hgcal.toModify(
RecoParticleFlowRECO,
outputCommands=RecoParticleFlowRECO.outputCommands + [
'keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*',
'keep recoPFRecHits_particleFlowRecHitHGC_Cleaned_*',
'keep recoPFClusters_particleFlowClusterHGCal__*',
'keep recoPFClusters_particleFlowClusterHGCalFromMultiCl__*',
'keep *_particleFlowSuperClusterHGCalFromMultiCl_*_*',
'keep recoPFBlocks_simPFProducer_*_*',
from SimCalorimetry.EcalSimProducers.ecalElectronicsSim_cff import *
from SimCalorimetry.EcalSimProducers.esElectronicsSim_cff import *
from SimCalorimetry.EcalSimProducers.ecalNotContainmentSim_cff import *
from SimCalorimetry.EcalSimProducers.ecalCosmicsSim_cff import *
ecalDigitizer = cms.PSet(
ecal_digi_parameters,
apd_sim_parameters,
ecal_electronics_sim,
ecal_cosmics_sim,
ecal_sim_parameter_map,
ecal_notCont_sim,
es_electronics_sim,
hitsProducer = cms.string('g4SimHits'),
accumulatorType = cms.string("EcalDigiProducer"),
makeDigiSimLinks = cms.untracked.bool(False)
)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
if fastSim.isChosen():
ecalDigitizer.hitsProducer = cms.string("famosSimHits")
ecalDigitizer.doEB = cms.bool(True)
ecalDigitizer.doEE = cms.bool(True)
ecalDigitizer.doES = cms.bool(True)
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify( ecalDigitizer, doES = cms.bool(False) )
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( ecalDigitizer, doEE = cms.bool(False) )
)
def _appendStage2Digis(obj):
l1Stage2Digis = [
'keep *_gtStage2Digis__*',
'keep *_gmtStage2Digis_Muon_*',
'keep *_caloStage2Digis_Jet_*',
'keep *_caloStage2Digis_Tau_*',
'keep *_caloStage2Digis_EGamma_*',
'keep *_caloStage2Digis_EtSum_*',
]
obj.outputCommands += l1Stage2Digis
# adding them to all places where we had l1extraParticles
from Configuration.Eras.Modifier_stage2L1Trigger_cff import stage2L1Trigger
stage2L1Trigger.toModify(L1TriggerRAWDEBUG, func=_appendStage2Digis)
stage2L1Trigger.toModify(L1TriggerRECO, func=_appendStage2Digis)
stage2L1Trigger.toModify(L1TriggerAOD, func=_appendStage2Digis)
stage2L1Trigger.toModify(L1TriggerFEVTDEBUG, func=_appendStage2Digis)
# adding HGCal L1 trigger digis
def _appendHGCalDigis(obj):
l1HGCalDigis = [
'keep *_hgcalTriggerPrimitiveDigiProducer__*',
]
obj.outputCommands += l1HGCalDigis
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(L1TriggerFEVTDEBUG, func=_appendHGCalDigis)
# when activated, the filter does not filter event.
# the filter is however storing a bool in the event, that can be used to take the
# filtering decision a posteriori
taggingMode = cms.bool( False ),
debug = cms.bool( False ),
verbose = cms.int32( 1 ),
tpDigiCollection = cms.InputTag("ecalTPSkimNA"),
etValToBeFlagged = cms.double(127.49),
ebReducedRecHitCollection = cms.InputTag("reducedEcalRecHitsEB"),
eeReducedRecHitCollection = cms.InputTag("reducedEcalRecHitsEE"),
maskedEcalChannelStatusThreshold = cms.int32( 1 ),
doEEfilter = cms.untracked.bool( True ), # turn it on by default
makeProfileRoot = cms.untracked.bool( False ),
profileRootName = cms.untracked.string("deadCellFilterProfile.root" ),
useTTsum = cms.bool ( True ),
usekTPSaturated = cms.bool ( False)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( EcalDeadCellTriggerPrimitiveFilter,
doEEfilter = cms.untracked.bool(False)
)
phase2_hcal.toModify(SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_DMHcalDigis_*_*') )
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toModify(SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EETimeDigi_*') )
phase2_timing.toModify(SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EBTimeDigi_*') )
phase2_timing.toModify(SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EETimeDigi_*') )
phase2_timing.toModify(SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EBTimeDigi_*') )
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify( SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simEcalUnsuppressedDigis_*_*') )
phase2_common.toModify( SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simEcalUnsuppressedDigis_*_*') )
phase2_common.toModify( SimCalorimetryPREMIX.outputCommands, func=lambda outputCommands: outputCommands.append('drop ESDigiCollection_simEcalUnsuppressedDigis_*_*') )
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( SimCalorimetryPREMIX.outputCommands, func=lambda outputCommands: outputCommands.append('drop EEDigiCollection_simEcalDigis_*_*') )
# mods for HGCAL
_phase2_hgc_extraCommands = cms.PSet( # using PSet in order to customize with Modifier
v = cms.vstring('keep *_simHGCalUnsuppressedDigis_EE_*', 'keep *_simHGCalUnsuppressedDigis_HEfront_*', 'keep *_simHGCalUnsuppressedDigis_HEback_*', 'keep *_mix_MergedCaloTruth_*'),
)
# For phase2 premixing switch the sim digi collections to the ones including pileup
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
premix_stage2.toModify(_phase2_hgc_extraCommands,
v = ['keep *_mixData_HGCDigisEE_*', 'keep *_mixData_HGCDigisHEfront_*', 'keep *_mixData_HGCDigisHEback_*', 'keep *_mixData_MergedCaloTruth_*']
)
phase2_hgcal.toModify( SimCalorimetryRAW, outputCommands = SimCalorimetryRAW.outputCommands + _phase2_hgc_extraCommands.v )
phase2_hgcal.toModify( SimCalorimetryFEVTDEBUG, outputCommands = SimCalorimetryFEVTDEBUG.outputCommands + _phase2_hgc_extraCommands.v )
phase2_hgcal.toModify( SimCalorimetryRECO, outputCommands = SimCalorimetryRECO.outputCommands + _phase2_hgc_extraCommands.v )
phase2_hgcal.toModify( SimCalorimetryPREMIX, outputCommands = SimCalorimetryPREMIX.outputCommands + _phase2_hgc_extraCommands.v )
'keep EEDigiCollection_simEcalDigis_*_*',
'keep ESDigiCollection_simEcalUnsuppressedDigis_*_*',
'keep *_simHcalDigis_*_*',
)
)
#
# Add extra event content if running in Run 2
#
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify( SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simHcalUnsuppressedDigis_*_*') )
run2_common.toModify( SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simHcalUnsuppressedDigis_*_*') )
from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
phase2_hcal.toModify(SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_DMHcalDigis_*_*') )
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toModify(SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EETimeDigi_*') )
phase2_timing.toModify(SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EBTimeDigi_*') )
phase2_timing.toModify(SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EETimeDigi_*') )
phase2_timing.toModify(SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EBTimeDigi_*') )
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify( SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simEcalUnsuppressedDigis_*_*') )
phase2_common.toModify( SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simEcalUnsuppressedDigis_*_*') )
phase2_common.toModify( SimCalorimetryPREMIX.outputCommands, func=lambda outputCommands: outputCommands.append('drop ESDigiCollection_simEcalUnsuppressedDigis_*_*') )
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( SimCalorimetryPREMIX.outputCommands, func=lambda outputCommands: outputCommands.append('drop EEDigiCollection_simEcalDigis_*_*') )
# OrderedHitsFactoryPSet = cms.PSet(
# ComponentName = cms.string('StandardHitPairGenerator'),
# SeedingLayers = cms.string('MixedLayerPairs')
# ),
# TTRHBuilder = cms.string('WithTrackAngle'),
# # eta-phi region
# RegionPSet = cms.PSet(
# deltaPhiRegion = cms.double(0.7),
# originHalfLength = cms.double(15.0),
# useZInVertex = cms.bool(True),
# deltaEtaRegion = cms.double(0.3),
# ptMin = cms.double(1.5),
# originRadius = cms.double(0.2),
# VertexProducer = cms.InputTag("pixelVertices")
# )
)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
ecalDrivenElectronSeeds,
endcapSuperClusters = 'particleFlowSuperClusterHGCal',
SeedConfiguration = dict( allowHGCal = True )
)
# create ecal driven seeds for electron using HGCal Multiclusters
ecalDrivenElectronSeedsFromMultiCl = ecalDrivenElectronSeeds.clone(
endcapSuperClusters = 'particleFlowSuperClusterHGCalFromMultiCl')
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = cms.bool(True)
process.patMuons.computeMuonMVA = cms.bool(True)
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag("reducedEgamma","reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet(
# configure many IDs as InputTag <someName> = <someTag> you
# can comment out those you don't want to save some disk space
eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"),
eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"),
eidLoose = cms.InputTag("reducedEgamma","eidLoose"),
eidTight = cms.InputTag("reducedEgamma","eidTight"),
eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"),
)
process.patElectrons.addPFClusterIso = cms.bool(True)
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.patElectrons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso")
process.patElectrons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso")
process.elPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
process.patPhotons.addPFClusterIso = cms.bool(True)
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-")
process.patPhotons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso")
process.patPhotons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso")
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patPhotons.photonIDSources = cms.PSet(
PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDLoose'),
PhotonCutBasedIDTight = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDTight')
)
process.phPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma","reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(process.selectedPatMuons, cut = "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure( process )
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process, metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process,
labelName = "patCaloMet",
metSource = "caloMetM"
)
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter("GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0")
)
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(), process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0")
)
task.add(process.CHSCands)
process.pfMetCHS = cms.EDProducer("PFMETProducer",
src = cms.InputTag("CHSCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetCHS)
addMETCollection(process,
labelName = "patCHSMet",
metSource = "pfMetCHS"
)
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = cms.EDProducer("PFMETProducer",
src = cms.InputTag("TrkCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetTrk)
addMETCollection(process,
labelName = "patTrkMet",
metSource = "pfMetTrk"
)
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.patJets.userData.userInts.src = [ cms.InputTag("pileupJetId:fullId"), ]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [ cms.InputTag('QGTagger:qgLikelihood'), ]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL' ),
])
## CaloJets
process.caloJetMap = cms.EDProducer("RecoJetDeltaRValueMapProducer",
src = process.patJets.jetSource,
matched = cms.InputTag("ak4CaloJets"),
distMax = cms.double(0.4),
values = cms.vstring('pt','emEnergyFraction'),
valueLabels = cms.vstring('pt','emEnergyFraction'),
lazyParser = cms.bool(True) )
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [ cms.InputTag("caloJetMap:pt"), cms.InputTag("caloJetMap:emEnergyFraction") ]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
electron_ids = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_50ns_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_50ns_Trig_V1_cff']
switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
process.electronRegressionValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
for idmod in electron_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task)
#heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded
if hasattr(process,'heepIDVarValueMaps'):
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
#force HEEP to use miniAOD (otherwise it'll detect the AOD)
process.heepIDVarValueMaps.dataFormat = cms.int32(2)
#VID Photon IDs
photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_50ns_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_25ns_nonTrig_V2p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_50ns_nonTrig_V2p1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff']
switchOnVIDPhotonIdProducer(process,DataFormat.AOD, task)
process.egmPhotonIsolation.srcToIsolate = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
for iPSet in process.egmPhotonIsolation.isolationConeDefinitions:
iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.egmPhotonIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonRegressionValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.particleBasedIsolation = \
cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.photonMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection,None,False,task)
#---------------------------------------------------------------------------
#Adding Boosted Subjets taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
#---------------------------------------------------------------------------
#Adding tau reco for 80X legacy reMiniAOD
#make a copy of makePatTauTask to avoid labels and substitution problems
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
#add PFTau reco modules to cloned makePatTauTask
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
#replace original task by extended one for the miniAOD_80XLegacy era
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco)
# Adding puppi jets
if not hasattr(process, 'ak4PFJetsPuppi'): #MM: avoid confilct with substructure call
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX,
jets = cms.InputTag("ak4PFJetsPuppi")
)
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0)
)
task.add(process.patJetPuppiCharge)
noDeepFlavourDiscriminators = [x.value() for x in process.patJets.discriminatorSources if not "DeepFlavour" in x.value()]
addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'),
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''),
pfCandidates = cms.InputTag('puppi'), # using Puppi candidates as input for b tagging of Puppi jets
algo= 'AK', rParam = 0.4, btagDiscriminators = noDeepFlavourDiscriminators
)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi')
# update slimmed jets to include DeepFlavour (keep same name)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
# make clone for DeepFlavour-less slimmed jets, so output name is preserved
process.slimmedJetsNoDeepFlavour = process.slimmedJets.clone()
task.add(process.slimmedJetsNoDeepFlavour)
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsNoDeepFlavour'),
# updateJetCollection defaults to MiniAOD inputs but
# here it is made explicit (as in training or MINIAOD redoing)
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates = cms.InputTag('packedPFCandidates'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
muSource = cms.InputTag('slimmedMuons'),
elSource = cms.InputTag('slimmedElectrons'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = [
'pfDeepFlavourJetTags:probb',
'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:problepb',
'pfDeepFlavourJetTags:probc',
'pfDeepFlavourJetTags:probuds',
'pfDeepFlavourJetTags:probg',
],
postfix = 'SlimmedDeepFlavour',
printWarning = False
)
# slimmedJets with DeepFlavour (remove DeepFlavour-less)
delattr(process, 'slimmedJets')
process.slimmedJets = process.selectedUpdatedPatJetsSlimmedDeepFlavour.clone()
# delete module not used anymore (slimmedJets substitutes)
delattr(process, 'selectedUpdatedPatJetsSlimmedDeepFlavour')
task.add(process.slimmedJets)
task.add(process.slimmedJetsAK8)
addToProcessAndTask('slimmedJetsPuppi', process.slimmedJetsNoDeepFlavour.clone(), process, task)
process.slimmedJetsPuppi.src = cms.InputTag("selectedPatJetsPuppi")
process.slimmedJetsPuppi.packedPFCandidates = cms.InputTag("packedPFCandidates")
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies( process );
runMetCorAndUncForMiniAODProduction(process, metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(), process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
# EGamma objects from HGCal are not yet in GED
# so add companion collections for Phase-II MiniAOD production
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
phase2_hgcal.toModify(task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
outputCommands = cms.untracked.vstring('keep *_CkfElectronCandidates_*_*',
'keep *_GsfGlobalElectronTest_*_*',
'keep *_electronMergedSeeds_*_*',
'keep recoGsfTracks_electronGsfTracks_*_*',
'keep recoGsfTrackExtras_electronGsfTracks_*_*',
'keep recoTrackExtras_electronGsfTracks_*_*',
'keep TrackingRecHitsOwned_electronGsfTracks_*_*' )
)
_phase2_hgcal_TrackingRECO_tokeep = [
'keep recoGsfTracks_electronGsfTracksFromMultiCl_*_*',
'keep recoGsfTrackExtras_electronGsfTracksFromMultiCl_*_*',
'keep recoTrackExtras_electronGsfTracksFromMultiCl_*_*',
'keep TrackingRecHitsOwned_electronGsfTracksFromMultiCl_*_*'
]
#AOD content
TrackingToolsAOD = cms.PSet(
outputCommands = cms.untracked.vstring('keep recoTracks_GsfGlobalElectronTest_*_*',
'keep recoGsfTracks_electronGsfTracks_*_*'
)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( TrackingToolsRECO,
outputCommands = TrackingToolsRECO.outputCommands + _phase2_hgcal_TrackingRECO_tokeep)
phase2_hgcal.toModify( TrackingToolsAOD,
outputCommands = TrackingToolsAOD.outputCommands + ['keep recoGsfTracks_electronGsfTracksFromMultiCl_*_*'])
'keep recoPreshowerClusterShapes_multi5x5PreshowerClusterShape_*_*',
# Particle Flow superclusters (only SuperCluster and CaloCluster outputs, not association map from PFClusters)
'keep recoSuperClusters_particleFlowSuperClusterECAL_*_*',
'keep recoCaloClusters_particleFlowSuperClusterECAL_*_*',
'keep recoSuperClusters_particleFlowSuperClusterOOTECAL_*_*',
'keep recoCaloClusters_particleFlowSuperClusterOOTECAL_*_*'))
_phase2_hgcal_scCommandsAOD = [
'keep recoSuperClusters_particleFlowSuperClusterHGCal__*',
'keep recoCaloClusters_particleFlowSuperClusterHGCal__*',
'keep recoSuperClusters_particleFlowSuperClusterHGCalFromMultiCl__*',
'keep recoCaloClusters_particleFlowSuperClusterHGCalFromMultiCl__*'
]
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(RecoEcalAOD,
outputCommands=RecoEcalAOD.outputCommands +
_phase2_hgcal_scCommandsAOD)
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
from Configuration.Eras.Modifier_peripheralPbPb_cff import peripheralPbPb
from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017
from Configuration.Eras.Modifier_ppRef_2017_cff import ppRef_2017
#HI-specific products needed in pp scenario special configurations
for e in [pA_2016, peripheralPbPb, pp_on_AA, pp_on_XeXe_2017, ppRef_2017]:
e.toModify(
RecoEcalAOD.outputCommands,
func=lambda outputCommands: outputCommands.extend([
'keep recoSuperClusters_correctedIslandBarrelSuperClusters_*_*',
'keep recoSuperClusters_correctedIslandEndcapSuperClusters_*_*'
]))
RECOEventContent.outputCommands.extend(CommonEventContent.outputCommands)
from Configuration.Eras.Modifier_ctpps_cff import ctpps
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
from RecoLocalFastTime.Configuration.RecoLocalFastTime_EventContent_cff import *
from RecoMTD.Configuration.RecoMTD_EventContent_cff import *
ctpps.toModify(RECOEventContent,
outputCommands = RECOEventContent.outputCommands + RecoCTPPSRECO.outputCommands)
phase2_hgcal.toModify(RECOEventContent,
outputCommands = RECOEventContent.outputCommands + TICL_RECO.outputCommands)
#
#
# RAWRECO Data Tier definition
#
#
RAWRECOEventContent = cms.PSet(
outputCommands = cms.untracked.vstring('drop *'),
splitLevel = cms.untracked.int32(0),
)
RAWRECOEventContent.outputCommands.extend(RECOEventContent.outputCommands)
RAWRECOEventContent.outputCommands.extend(cms.untracked.vstring(
'keep FEDRawDataCollection_rawDataCollector_*_*',
'keep FEDRawDataCollection_source_*_*')
)
#
MinMva = cms.double(-10000.),
MaxTipBarrel = cms.double(10000.),
MaxTipEndcaps = cms.double(10000.),
MaxTkIso03 = cms.double(1.),
MaxHcalIso03Depth1Barrel = cms.double(10000.),
MaxHcalIso03Depth1Endcaps = cms.double(10000.),
MaxHcalIso03Depth2Endcaps = cms.double(10000.),
MaxEcalIso03Barrel = cms.double(10000.),
MaxEcalIso03Endcaps = cms.double(10000.),
TriggerResults = cms.InputTag("TriggerResults::HLT"),
NbinEta = cms.int32(50), NbinEta2D = cms.int32(50), EtaMin = cms.double(-2.5), EtaMax = cms.double(2.5),
NbinPhi = cms.int32(64), NbinPhi2D = cms.int32(32), PhiMax = cms.double(3.2), PhiMin = cms.double(-3.2),
NbinPt = cms.int32(50), NbinPtEff = cms.int32(19), NbinPt2D = cms.int32(50), PtMax = cms.double(100.0),
NbinP = cms.int32(50), NbinP2D = cms.int32(50), PMax = cms.double(300.0),
NbinEop = cms.int32(50), NbinEop2D = cms.int32(30), EopMax = cms.double(5.0), EopMaxSht = cms.double(3.0),
NbinDeta = cms.int32(100), DetaMin = cms.double(-0.005), DetaMax = cms.double(0.005),
NbinDphi = cms.int32(100), DphiMin = cms.double(-0.01), DphiMax = cms.double(0.01),
NbinDetaMatch = cms.int32(100), NbinDetaMatch2D = cms.int32(50), DetaMatchMin = cms.double(-0.05), DetaMatchMax = cms.double(0.05),
NbinDphiMatch = cms.int32(100), NbinDphiMatch2D = cms.int32(50), DphiMatchMin = cms.double(-0.2), DphiMatchMax = cms.double(0.2),
NbinFhits = cms.int32(30), FhitsMax = cms.double(30.0),
NbinLhits = cms.int32(5), LhitsMax = cms.double(10.0),
NbinXyz = cms.int32(50), NbinXyz2D = cms.int32(25),
NbinPopTrue = cms.int32(75), PopTrueMin = cms.double(0.0), PopTrueMax = cms.double(1.5),
NbinMee = cms.int32(100), MeeMin = cms.double(0.0), MeeMax = cms.double(150.),
NbinHoe = cms.int32(100), HoeMin = cms.double(0.0), HoeMax = cms.double(0.5)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( dqmElectronTagProbeAnalysis, ElectronCollection = cms.InputTag("ecalDrivenGsfElectrons") )
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag(
"muonPUPPIIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag(
"muonPUPPIIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag(
"muonPUPPIIsolation", "gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag(
"muonPUPPINoLeptonsIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag(
"muonPUPPINoLeptonsIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag(
"muonPUPPINoLeptonsIsolation",
"gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = cms.bool(True)
process.patMuons.computeMuonMVA = cms.bool(True)
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag(
"reducedEgamma", "reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet()
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
process.patElectrons,
addPFClusterIso=cms.bool(True),
ecalPFClusterIsoMap=cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap=cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(
process.patElectrons,
addPFClusterIso=cms.bool(True),
ecalPFClusterIsoMap=cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap=cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag(
"egmElectronPUPPIIsolation", "h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag(
"egmElectronPUPPIIsolation", "h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag(
"egmElectronPUPPIIsolation", "gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation", "h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation", "h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation",
"gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.elPFIsoDepositChargedPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag(
"egmPhotonPUPPIIsolation", "h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag(
"egmPhotonPUPPIIsolation", "h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag(
"egmPhotonPUPPIIsolation", "gamma-DR030-")
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
process.patPhotons,
addPFClusterIso=cms.bool(True),
ecalPFClusterIsoMap=cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap=cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(
process.patPhotons,
addPFClusterIso=cms.bool(True),
ecalPFClusterIsoMap=cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap=cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(
process.patOOTPhotons,
addPFClusterIso=cms.bool(True),
ecalPFClusterIsoMap=cms.InputTag("reducedEgamma",
"ootPhoEcalPFClusIso"),
hcalPFClusterIsoMap=cms.InputTag("reducedEgamma",
"ootPhoHcalPFClusIso"))
process.patPhotons.photonSource = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
process.phPFIsoDepositChargedPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma",
"reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string(
"pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))"
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
process.selectedPatMuons,
cut=
"pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )"
)
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string(
"pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure(process)
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone(process, outputModule='')
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process,
metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process, labelName="patCaloMet", metSource="caloMetM")
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter(
"GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0"))
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(
process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF")
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(),
process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag(
"patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag(
"patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag(
"patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag(
"patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0"))
task.add(process.CHSCands)
process.pfMetCHS = cms.EDProducer(
"PFMETProducer",
src=cms.InputTag("CHSCands"),
alias=cms.string('pfMet'),
globalThreshold=cms.double(0.0),
calculateSignificance=cms.bool(False),
)
task.add(process.pfMetCHS)
addMETCollection(process, labelName="patCHSMet", metSource="pfMetCHS")
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string(
"charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = cms.EDProducer(
"PFMETProducer",
src=cms.InputTag("TrkCands"),
alias=cms.string('pfMet'),
globalThreshold=cms.double(0.0),
calculateSignificance=cms.bool(False),
)
task.add(process.pfMetTrk)
addMETCollection(process, labelName="patTrkMet", metSource="pfMetTrk")
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [
cms.InputTag("pileupJetId:fullDiscriminant"),
]
process.patJets.userData.userInts.src = [
cms.InputTag("pileupJetId:fullId"),
]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [
cms.InputTag('QGTagger:qgLikelihood'),
]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll'),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB'),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL'),
])
## CaloJets
process.caloJetMap = cms.EDProducer(
"RecoJetDeltaRValueMapProducer",
src=process.patJets.jetSource,
matched=cms.InputTag("ak4CaloJets"),
distMax=cms.double(0.4),
values=cms.vstring('pt', 'emEnergyFraction'),
valueLabels=cms.vstring('pt', 'emEnergyFraction'),
lazyParser=cms.bool(True))
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [
cms.InputTag("caloJetMap:pt"),
cms.InputTag("caloJetMap:emEnergyFraction")
]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
process.patElectrons.addElectronID = cms.bool(True)
electron_ids = [
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
]
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
process.electronRegressionValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
for idmod in electron_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None,
False, task)
#heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded
if hasattr(process, 'heepIDVarValueMaps'):
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag(
'reducedEgamma', 'reducedGedGsfElectrons')
#force HEEP to use miniAOD (otherwise it'll detect the AOD)
process.heepIDVarValueMaps.dataFormat = cms.int32(2)
#add the HEEP trk isol to the slimmed electron, add it to the first FromFloatValMap modifier
for pset in process.slimmedElectrons.modifierConfig.modifications:
if pset.hasParameter(
"modifierName") and pset.modifierName == cms.string(
'EGExtraInfoModifierFromFloatValueMaps'):
pset.electron_config.heepTrkPtIso = cms.InputTag(
"heepIDVarValueMaps", "eleTrkPtIso")
break
#VID Photon IDs
process.patPhotons.addPhotonID = cms.bool(True)
photon_ids = [
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff'
]
switchOnVIDPhotonIdProducer(process, DataFormat.AOD, task)
process.egmPhotonIsolation.srcToIsolate = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
for iPSet in process.egmPhotonIsolation.isolationConeDefinitions:
iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma",
"reducedPhotonPfCandMap")
process.egmPhotonIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonRegressionValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.particleBasedIsolation = \
cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.photonMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection, None,
False, task)
#add the cut base IDs bitmaps of which cuts passed
from RecoEgamma.EgammaTools.egammaObjectModifications_tools import makeVIDBitsModifier
egamma_modifications.append(
makeVIDBitsModifier(process, "egmGsfElectronIDs", "egmPhotonIDs"))
#-- Adding boosted taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.load("RecoTauTag.Configuration.HPSPFTaus_cff")
#-- Adding customization for 94X 2017 legacy reMniAOD
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask)
run2_miniAOD_94XFall17.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID)
#-- Adding customization for 80X 2016 legacy reMiniAOD
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
run2_miniAOD_80XLegacy.toReplaceWith(process.makePatTausTask,
_makePatTausTaskWithTauReReco)
# Adding puppi jets
if not hasattr(
process,
'ak4PFJetsPuppi'): #MM: avoid confilct with substructure call
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer(
"JetTracksAssociatorAtVertex",
j2tParametersVX,
jets=cms.InputTag("ak4PFJetsPuppi"))
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer(
"JetChargeProducer",
src=cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var=cms.string('Pt'),
exp=cms.double(1.0))
task.add(process.patJetPuppiCharge)
noDeepFlavourDiscriminators = [
x.value() for x in process.patJets.discriminatorSources
if not "DeepFlavour" in x.value()
]
addJetCollection(
process,
postfix="",
labelName='Puppi',
jetSource=cms.InputTag('ak4PFJetsPuppi'),
jetCorrections=('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''),
pfCandidates=cms.InputTag(
'puppi'
), # using Puppi candidates as input for b tagging of Puppi jets
algo='AK',
rParam=0.4,
btagDiscriminators=noDeepFlavourDiscriminators)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi')
# update slimmed jets to include DeepFlavour (keep same name)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
# make clone for DeepFlavour-less slimmed jets, so output name is preserved
process.slimmedJetsNoDeepFlavour = process.slimmedJets.clone()
task.add(process.slimmedJetsNoDeepFlavour)
updateJetCollection(
process,
jetSource=cms.InputTag('slimmedJetsNoDeepFlavour'),
# updateJetCollection defaults to MiniAOD inputs but
# here it is made explicit (as in training or MINIAOD redoing)
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates=cms.InputTag('packedPFCandidates'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
muSource=cms.InputTag('slimmedMuons'),
elSource=cms.InputTag('slimmedElectrons'),
jetCorrections=('AK4PFchs',
cms.vstring(['L1FastJet', 'L2Relative',
'L3Absolute']), 'None'),
btagDiscriminators=[
'pfDeepFlavourJetTags:probb',
'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:problepb',
'pfDeepFlavourJetTags:probc',
'pfDeepFlavourJetTags:probuds',
'pfDeepFlavourJetTags:probg',
],
postfix='SlimmedDeepFlavour',
printWarning=False)
# slimmedJets with DeepFlavour (remove DeepFlavour-less)
delattr(process, 'slimmedJets')
process.slimmedJets = process.selectedUpdatedPatJetsSlimmedDeepFlavour.clone(
)
# delete module not used anymore (slimmedJets substitutes)
delattr(process, 'selectedUpdatedPatJetsSlimmedDeepFlavour')
task.add(process.slimmedJets)
task.add(process.slimmedJetsAK8)
addToProcessAndTask('slimmedJetsPuppiNoMultiplicities',
process.slimmedJetsNoDeepFlavour.clone(), process,
task)
process.slimmedJetsPuppiNoMultiplicities.src = cms.InputTag(
"selectedPatJetsPuppi")
process.slimmedJetsPuppiNoMultiplicities.packedPFCandidates = cms.InputTag(
"packedPFCandidates")
from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer
process.patPuppiJetSpecificProducer = patPuppiJetSpecificProducer.clone(
src=cms.InputTag("slimmedJetsPuppiNoMultiplicities"), )
task.add(process.patPuppiJetSpecificProducer)
updateJetCollection(
process,
labelName='PuppiJetSpecific',
jetSource=cms.InputTag('slimmedJetsPuppiNoMultiplicities'),
)
process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = [
'patPuppiJetSpecificProducer:puppiMultiplicity',
'patPuppiJetSpecificProducer:neutralPuppiMultiplicity',
'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity',
'patPuppiJetSpecificProducer:photonPuppiMultiplicity',
'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity',
'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity'
]
process.slimmedJetsPuppi = process.selectedUpdatedPatJetsPuppiJetSpecific.clone(
)
delattr(process, 'selectedUpdatedPatJetsPuppiJetSpecific')
task.add(process.slimmedJetsPuppi)
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies(process)
runMetCorAndUncForMiniAODProduction(process,
metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi")
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(),
process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag(
"patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag(
"patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag(
"patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag(
"patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag(
"patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
# EGamma objects from HGCal are not yet in GED
# so add companion collections for Phase-II MiniAOD production
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
phase2_hgcal.toModify(
task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
ret = []
for i, pset in enumerate(particleFlowBlock.elementImporters):
if pset.importerName.value() == name:
ret.append(i)
return ret
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
# kill tracks in the HGCal
_insertGeneralTracksImporter = {}
for idx in _findIndicesByModule('GeneralTracksImporter'):
_insertGeneralTracksImporter[idx] = dict(
importerName = cms.string('GeneralTracksImporterWithVeto'),
veto = cms.InputTag('hgcalTrackCollection:TracksInHGCal')
)
phase2_hgcal.toModify(
particleFlowBlock,
elementImporters = _insertGeneralTracksImporter
)
### for later
#_phase2_hgcal_Linkers.append(
# cms.PSet( linkerName = cms.string("SCAndHGCalLinker"),
# linkType = cms.string("SC:HGCAL"),
# useKDTree = cms.bool(False),
# SuperClusterMatchByRef = cms.bool(True) )
#)
#_phase2_hgcal_Linkers.append(
# cms.PSet( linkerName = cms.string("HGCalAndBREMLinker"),
# linkType = cms.string("HGCAL:BREM"),
# useKDTree = cms.bool(False) )
#)
#_phase2_hgcal_Linkers.append(
# cms.PSet( linkerName = cms.string("GSFAndHGCalLinker"),
from Configuration.Eras.Modifier_fastSim_cff import fastSim
if fastSim.isChosen():
# fastsim does not model castor
delattr(theDigitizers, "castor")
# fastsim does not digitize pixel and strip hits
delattr(theDigitizers, "pixel")
delattr(theDigitizers, "strip")
setattr(theDigitizers, "tracks", recoTrackAccumulator)
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hgceeDigitizer, hgchebackDigitizer, hgchefrontDigitizer
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
theDigitizers,
hgceeDigitizer=cms.PSet(hgceeDigitizer),
hgchebackDigitizer=cms.PSet(hgchebackDigitizer),
hgchefrontDigitizer=cms.PSet(hgchefrontDigitizer),
)
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify(theDigitizers, castor=None)
from SimGeneral.MixingModule.ecalTimeDigitizer_cfi import ecalTimeDigitizer
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing.toModify(theDigitizers, ecalTime=ecalTimeDigitizer.clone())
from SimFastTiming.Configuration.SimFastTiming_cff import fastTimeDigitizer
MicroEventContentMC = cms.PSet(
outputCommands = cms.untracked.vstring(MicroEventContent.outputCommands)
)
MicroEventContentMC.outputCommands += MicroEventContentGEN.outputCommands
MicroEventContentMC.outputCommands += [
'keep PileupSummaryInfos_slimmedAddPileupInfo_*_*',
# RUN
'keep L1GtTriggerMenuLite_l1GtTriggerMenuLite__*'
]
MiniAODOverrideBranchesSplitLevel = cms.untracked.VPSet( [
cms.untracked.PSet(branch = cms.untracked.string("patPackedCandidates_packedPFCandidates__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoGenParticles_prunedGenParticles__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patTriggerObjectStandAlones_slimmedPatTrigger__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patPackedGenParticles_packedGenParticles__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patJets_slimmedJets__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoVertexs_offlineSlimmedPrimaryVertices__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoCaloClusters_reducedEgamma_reducedESClusters_*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("EcalRecHitsSorted_reducedEgamma_reducedEBRecHits_*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("EcalRecHitsSorted_reducedEgamma_reducedEERecHits_*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoGenJets_slimmedGenJets__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patJets_slimmedJetsPuppi__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("EcalRecHitsSorted_reducedEgamma_reducedESRecHits_*"),splitLevel=cms.untracked.int32(99)),
])
_phase2_hgc_extraCommands = ["keep *_slimmedElectronsFromMultiCl_*_*", "keep *_slimmedPhotonsFromMultiCl_*_*"]
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(MicroEventContentMC, outputCommands = MicroEventContentMC.outputCommands + _phase2_hgc_extraCommands)
# isoFromDepsEcalReduced03 = cms.InputTag("eleIsoFromDepsEcalFromHitsByCrystalReduced03"),
# isoFromDepsEcalReduced04 = cms.InputTag("eleIsoFromDepsEcalFromHitsByCrystalReduced04"),
# isoFromDepsHcal03 = cms.InputTag("eleIsoFromDepsHcalFromTowers03"),
# isoFromDepsHcal04 = cms.InputTag("eleIsoFromDepsHcalFromTowers04"),
MaxPt = cms.double(100.0),
DeltaR = cms.double(0.05),
MaxAbsEta = cms.double(2.5),
MatchingID = cms.vint32(11,-11),
MatchingMotherID = cms.vint32(23,24,-24,32),
histosCfg = cms.PSet(electronMcSignalHistosCfg)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
electronMcSignalValidator,
# electronCollection = cms.InputTag("ecalDrivenGsfElectrons"),
# electronCoreCollection = cms.InputTag("ecalDrivenGsfElectronCores"),
electronCollection = 'ecalDrivenGsfElectronsFromMultiCl',
electronCoreCollection = 'ecalDrivenGsfElectronCoresFromMultiCl',
electronTrackCollection = 'electronGsfTracksFromMultiCl',
electronSeedCollection = 'electronMergedSeedsFromMultiCl',
MaxAbsEta = cms.double(3.0),
histosCfg = dict(
Nbineta = 60 ,
Nbineta2D = 60 ,
Etamin = -3.0 ,
Etamax = 3.0 ,
),
)
def _modifyPFEventContentForHGCalRECO( obj ):
obj.outputCommands.append('keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*')
def _modifyPFEventContentForHGCalFEVT( obj ):
obj.outputCommands.append('keep recoPFRecHits_particleFlowClusterECAL__*')
obj.outputCommands.append('keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*')
# mods for HGCAL
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( RecoParticleFlowFEVT, outputCommands = RecoParticleFlowFEVT.outputCommands + [
'keep recoPFRecHits_particleFlowClusterECAL__*',
'keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*',
'keep recoPFRecHits_particleFlowRecHitHGC__*',
'keep recoPFRecHits_particleFlowRecHitHGC_Cleaned_*',
'keep recoPFClusters_particleFlowClusterHGCal__*',
'keep *_simPFProducer_*_*',
'keep *_particleFlowTmpBarrel_*_*',
]
)
phase2_hgcal.toModify( RecoParticleFlowRECO, outputCommands = RecoParticleFlowRECO.outputCommands + [ 'keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*', 'keep recoPFRecHits_particleFlowRecHitHGC_Cleaned_*', 'keep recoPFClusters_particleFlowClusterHGCal__*', 'keep recoPFBlocks_simPFProducer_*_*', 'keep recoSuperClusters_simPFProducer_*_*','keep *_particleFlowTmpBarrel_*_*' ] )
phase2_hgcal.toModify( RecoParticleFlowAOD, outputCommands = RecoParticleFlowAOD.outputCommands + [ 'keep recoPFRecHits_particleFlowClusterECAL_Cleaned_*', 'keep recoPFRecHits_particleFlowRecHitHGC_Cleaned_*', 'keep recoPFClusters_particleFlowClusterHGCal__*', 'keep recoSuperClusters_simPFProducer_*_*' ] )
#timing
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toModify(
RecoParticleFlowFEVT,
outputCommands = RecoParticleFlowFEVT.outputCommands + [
'keep *_ecalBarrelClusterFastTimer_*_*'
])
phase2_timing.toModify(
'keep *_hfRecoEcalCandidate_*_*',
'keep recoRecoEcalCandidates_hfRecoEcalCandidate_*_*',
'keep *_hfEMClusters_*_*', 'keep *_gedGsfElectronCores_*_*',
'keep *_gedGsfElectrons_*_*'))
# mods for HGCAL
_phase2_hgcal_RecoEgamma_tokeep = [
'keep *_ecalDrivenGsfElectronCores_*_*',
'keep *_ecalDrivenGsfElectrons_*_*',
'keep *_ecalDrivenGsfElectronCoresFromMultiCl_*_*',
'keep *_ecalDrivenGsfElectronsFromMultiCl_*_*',
'keep *_photonCoreFromMultiCl_*_*', 'keep *_photonsFromMultiCl_*_*'
]
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(RecoEgammaFEVT,
outputCommands=RecoEgammaFEVT.outputCommands +
_phase2_hgcal_RecoEgamma_tokeep)
phase2_hgcal.toModify(RecoEgammaRECO,
outputCommands=RecoEgammaRECO.outputCommands +
_phase2_hgcal_RecoEgamma_tokeep)
phase2_hgcal.toModify(RecoEgammaAOD,
outputCommands=RecoEgammaAOD.outputCommands +
_phase2_hgcal_RecoEgamma_tokeep)
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
from Configuration.Eras.Modifier_peripheralPbPb_cff import peripheralPbPb
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017
from Configuration.Eras.Modifier_ppRef_2017_cff import ppRef_2017
#HI-specific products needed in pp scenario special configurations
for e in [pA_2016, peripheralPbPb, pp_on_AA_2018, pp_on_XeXe_2017, ppRef_2017]:
#------------------
# Producer for Box Particle Flow Super Clusters
from RecoEcal.EgammaClusterProducers.particleFlowSuperClusterECAL_cfi import *
# Producer for energy corrections
#from RecoEcal.EgammaClusterProducers.correctedDynamicHybridSuperClusters_cfi import *
# PFECAL super clusters, either hybrid-clustering clone (Box) or mustache.
particleFlowSuperClusteringSequence = cms.Sequence(particleFlowSuperClusterECAL)
particleFlowSuperClusterHGCal = particleFlowSuperClusterECAL.clone()
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
particleFlowSuperClusterHGCal,
PFClusters = cms.InputTag('particleFlowClusterHGCal'),
useRegression = cms.bool(False), #no HGCal regression yet
use_preshower = cms.bool(False),
PFBasicClusterCollectionEndcap = cms.string(""),
PFSuperClusterCollectionEndcap = cms.string(""),
PFSuperClusterCollectionEndcapWithPreshower = cms.string(""),
thresh_PFClusterEndcap = cms.double(1.5e-1), # 150 MeV threshold
dropUnseedable = cms.bool(True),
)
particleFlowSuperClusterHGCalFromMultiCl = particleFlowSuperClusterHGCal.clone()
phase2_hgcal.toModify(
particleFlowSuperClusterHGCalFromMultiCl,
PFClusters = cms.InputTag('particleFlowClusterHGCalFromMultiCl')
)
_phase2_hgcal_particleFlowSuperClusteringSequence = particleFlowSuperClusteringSequence.copy()
_phase2_hgcal_particleFlowSuperClusteringSequence += particleFlowSuperClusterHGCal
_phase2_hgcal_particleFlowSuperClusteringSequence += particleFlowSuperClusterHGCalFromMultiCl
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag(
"muonPUPPIIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag(
"muonPUPPIIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag(
"muonPUPPIIsolation", "gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag(
"muonPUPPINoLeptonsIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag(
"muonPUPPINoLeptonsIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag(
"muonPUPPINoLeptonsIsolation",
"gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = True
process.patMuons.computeMuonMVA = True
process.patMuons.computeSoftMuonMVA = True
process.patMuons.addTriggerMatching = True
from Configuration.Eras.Modifier_run2_muon_2016_cff import run2_muon_2016
from Configuration.Eras.Modifier_run2_muon_2017_cff import run2_muon_2017
from Configuration.Eras.Modifier_run2_muon_2018_cff import run2_muon_2018
run2_muon_2016.toModify(
process.patMuons,
effectiveAreaVec=[0.0735, 0.0619, 0.0465, 0.0433, 0.0577])
run2_muon_2017.toModify(
process.patMuons,
effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064])
run2_muon_2018.toModify(
process.patMuons,
effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064])
run2_muon_2016.toModify(
process.patMuons,
mvaTrainingFile=
"RecoMuon/MuonIdentification/data/mu_2016_BDTG.weights.xml")
process.patMuons.computePuppiCombinedIso = True
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag(
"reducedEgamma", "reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet()
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
(run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify(
process.patElectrons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:eleEcalPFClusIso",
hcalPFClusterIsoMap="reducedEgamma:eleHcalPFClusIso")
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag(
"egmElectronPUPPIIsolation", "h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag(
"egmElectronPUPPIIsolation", "h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag(
"egmElectronPUPPIIsolation", "gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation", "h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation", "h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation",
"gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.elPFIsoDepositChargedPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag(
"egmPhotonPUPPIIsolation", "h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag(
"egmPhotonPUPPIIsolation", "h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag(
"egmPhotonPUPPIIsolation", "gamma-DR030-")
(run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify(
process.patPhotons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:phoEcalPFClusIso",
hcalPFClusterIsoMap="reducedEgamma:phoHcalPFClusIso")
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(
process.patOOTPhotons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:ootPhoEcalPFClusIso",
hcalPFClusterIsoMap="reducedEgamma:ootPhoHcalPFClusIso")
process.patPhotons.photonSource = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
process.phPFIsoDepositChargedPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma",
"reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string(
"pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))"
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
process.selectedPatMuons,
cut=
"pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )"
)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from Configuration.Eras.Modifier_pp_on_PbPb_run3_cff import pp_on_PbPb_run3
(pp_on_AA_2018 | pp_on_PbPb_run3).toModify(
process.selectedPatMuons,
cut=
"pt > 5 || isPFMuon || (pt > 1.2 && (isGlobalMuon || isStandAloneMuon) )"
)
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string(
"pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure(process)
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone(process, outputModule='')
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process,
metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process, labelName="patCaloMet", metSource="caloMetM")
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter(
"GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0"))
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(
process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF")
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
process.slimmedMETs.addDeepMETs = True
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(),
process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag(
"patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag(
"patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag(
"patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag(
"patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0"))
task.add(process.CHSCands)
from RecoMET.METProducers.pfMet_cfi import pfMet
process.pfMetCHS = pfMet.clone(src='CHSCands')
task.add(process.pfMetCHS)
addMETCollection(process, labelName="patCHSMet", metSource="pfMetCHS")
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string(
"charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = pfMet.clone(src='TrkCands')
task.add(process.pfMetTrk)
addMETCollection(process, labelName="patTrkMet", metSource="pfMetTrk")
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [
cms.InputTag("pileupJetId:fullDiscriminant"),
]
process.patJets.userData.userInts.src = [
cms.InputTag("pileupJetId:fullId"),
]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [
cms.InputTag('QGTagger:qgLikelihood'),
]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll'),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB'),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL'),
])
## CaloJets
process.caloJetMap = cms.EDProducer(
"RecoJetDeltaRValueMapProducer",
src=process.patJets.jetSource,
matched=cms.InputTag("ak4CaloJets"),
distMax=cms.double(0.4),
values=cms.vstring('pt', 'emEnergyFraction'),
valueLabels=cms.vstring('pt', 'emEnergyFraction'),
lazyParser=cms.bool(True))
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [
cms.InputTag("caloJetMap:pt"),
cms.InputTag("caloJetMap:emEnergyFraction")
]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
process.patElectrons.addElectronID = cms.bool(True)
electron_ids = [
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV71_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
]
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = cms.InputTag(
'reducedEgamma', 'reducedGedGsfElectrons')
# To use older DataFormats, the electronMVAValueMapProducer MUST take a updated electron collection
# such that the conversion variables are filled correctly.
process.load("RecoEgamma.EgammaTools.gedGsfElectronsTo106X_cff")
run2_miniAOD_80XLegacy.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom80XTo106XTask))
run2_miniAOD_80XLegacy.toModify(
process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag('reducedEgamma',
'reducedGedGsfElectrons'),
src=cms.InputTag("gedGsfElectronsFrom80XTo106X"))
run2_miniAOD_94XFall17.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask))
run2_miniAOD_94XFall17.toModify(
process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag('reducedEgamma',
'reducedGedGsfElectrons'),
src=cms.InputTag("gedGsfElectronsFrom94XTo106X"))
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask))
pp_on_AA_2018.toModify(process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag(
'reducedEgamma', 'reducedGedGsfElectrons'),
src="gedGsfElectronsFrom94XTo106X")
for idmod in electron_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None,
False, task)
#VID Photon IDs
process.patPhotons.addPhotonID = cms.bool(True)
photon_ids = [
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff'
]
switchOnVIDPhotonIdProducer(process, DataFormat.AOD, task)
process.egmPhotonIDs.physicsObjectSrc = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.photonMVAValueMapProducer.src = cms.InputTag(
'reducedEgamma', 'reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection, None,
False, task)
#add the cut base IDs bitmaps of which cuts passed
from RecoEgamma.EgammaTools.egammaObjectModifications_tools import makeVIDBitsModifier
egamma_modifications.append(
makeVIDBitsModifier(process, "egmGsfElectronIDs", "egmPhotonIDs"))
#-- Adding boosted taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.load("RecoTauTag.Configuration.HPSPFTaus_cff")
#-- Adding customization for 94X 2017 legacy reMniAOD
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(
process.hpsPFTauBasicDiscriminatorsTask,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTTask,
process.hpsPFTauBasicDiscriminatorsdR03Task,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBdR03oldDMwLTTask,
process.hpsPFTauDiscriminationByMVA6rawElectronRejection,
process.hpsPFTauDiscriminationByMVA6ElectronRejection,
process.hpsPFTauDiscriminationByMuonRejection3)
from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL
(run2_miniAOD_94XFall17 | run2_miniAOD_UL).toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID)
#-- Adding DeepTauID
# deepTau v2p1
_updatedTauName = 'slimmedTausDeepIDsv2p1'
_noUpdatedTauName = 'slimmedTausNoDeepIDs'
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(process,
debug=False,
updatedTauName=_updatedTauName,
toKeep=['deepTau2017v2p1'])
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common #Phase2 Tau MVA
phase2_common.toModify(
tauIdEmbedder.toKeep,
func=lambda t: t.append('newDMPhase2v1')) #Phase2 Tau MVA
tauIdEmbedder.runTauID()
addToProcessAndTask(_noUpdatedTauName, process.slimmedTaus.clone(),
process, task)
delattr(process, 'slimmedTaus')
process.deepTau2017v2p1.taus = _noUpdatedTauName
process.slimmedTaus = getattr(process,
_updatedTauName).clone(src=_noUpdatedTauName)
process.deepTauIDTask = cms.Task(process.deepTau2017v2p1,
process.slimmedTaus)
task.add(process.deepTauIDTask)
if 'newDMPhase2v1' in tauIdEmbedder.toKeep:
process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2raw.PATTauProducer = _noUpdatedTauName
process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2.PATTauProducer = _noUpdatedTauName
task.add(process.rerunIsolationMVADBnewDMwLTPhase2Task)
#-- Rerun tauID against dead ECal towers to taus for the various re-MiniAOD eras
# to enable default behoviour with leading track extrapolation to ECAL
_makePatTausTaskWithDeadECalVeto = process.makePatTausTask.copy()
_makePatTausTaskWithDeadECalVeto.add(
process.hpsPFTauDiscriminationByDeadECALElectronRejection)
_run2_miniAOD_ANY = (run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17
| run2_miniAOD_UL)
_run2_miniAOD_ANY.toReplaceWith(process.makePatTausTask,
_makePatTausTaskWithDeadECalVeto)
#-- Adding customization for 80X 2016 legacy reMiniAOD and 2018 heavy ions
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
(run2_miniAOD_80XLegacy | pp_on_AA_2018).toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco)
# Adding puppi jets
process.load('CommonTools.PileupAlgos.Puppi_cff')
process.load('RecoJets.JetProducers.ak4PFJets_cfi')
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
_rerun_puppijets_task = task.copy()
_rerun_puppijets_task.add(process.puppi, process.ak4PFJetsPuppi)
(_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith(
task, _rerun_puppijets_task)
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer(
"JetTracksAssociatorAtVertex",
j2tParametersVX,
jets=cms.InputTag("ak4PFJetsPuppi"))
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer(
"JetChargeProducer",
src=cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var=cms.string('Pt'),
exp=cms.double(1.0))
task.add(process.patJetPuppiCharge)
noDeepFlavourDiscriminators = [
x.value() for x in process.patJets.discriminatorSources
if not "DeepFlavour" in x.value()
]
addJetCollection(process,
postfix="",
labelName='Puppi',
jetSource=cms.InputTag('ak4PFJetsPuppi'),
jetCorrections=('AK4PFPuppi',
['L2Relative', 'L3Absolute'], ''),
pfCandidates=cms.InputTag("particleFlow"),
algo='AK',
rParam=0.4,
btagDiscriminators=noDeepFlavourDiscriminators)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
from PhysicsTools.PatAlgos.slimming.applyDeepBtagging_cff import applyDeepBtagging
applyDeepBtagging(process)
addToProcessAndTask(
'slimmedJetsPuppi',
process.slimmedJetsNoDeepFlavour.clone(
src="selectedPatJetsPuppi",
packedPFCandidates="packedPFCandidates"), process, task)
task.add(process.slimmedJetsPuppi)
# Embed pixelClusterTagInfos in slimmedJets
process.patJets.addTagInfos = True
process.patJets.tagInfoSources = ["pixelClusterTagInfos"]
process.slimmedJetsNoDeepFlavour.dropTagInfos = '0'
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.addTagInfos = True
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.tagInfoSources = [
"pixelClusterTagInfos"
]
_run2_miniAOD_ANY.toModify(process.patJets, addTagInfos=False)
_run2_miniAOD_ANY.toModify(
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour,
addTagInfos=False)
## puppi met
process.load('RecoMET.METProducers.pfMetPuppi_cfi')
_rerun_puppimet_task = task.copy()
_rerun_puppimet_task.add(process.puppiNoLep, process.pfMetPuppi)
(_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith(
task, _rerun_puppimet_task)
runMetCorAndUncForMiniAODProduction(process,
metType="Puppi",
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi")
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(),
process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag(
"patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag(
"patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag(
"patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag(
"patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag(
"patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
process.load('RecoMET.METPUSubtraction.deepMETProducer_cfi')
addToProcessAndTask('deepMETsResolutionTune',
process.deepMETProducer.clone(), process, task)
addToProcessAndTask('deepMETsResponseTune',
process.deepMETProducer.clone(), process, task)
process.deepMETsResponseTune.graph_path = 'RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2018.pb'
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify(
process.deepMETsResolutionTune,
max_n_pf=12500,
graph_path="RecoMET/METPUSubtraction/data/deepmet/deepmet_v1_phase2.pb"
)
phase2_common.toModify(
process.deepMETsResponseTune,
max_n_pf=12500,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_phase2.pb")
from Configuration.Eras.Modifier_run2_jme_2016_cff import run2_jme_2016
run2_jme_2016.toModify(
process.deepMETsResponseTune,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2016.pb")
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
# EGamma objects from HGCal are not yet in GED
# so add companion collections for Phase-II MiniAOD production
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
phase2_hgcal.toModify(
task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
# L1 pre-firing weights for 2016 and 2017
from Configuration.Eras.Modifier_run2_L1prefiring_cff import run2_L1prefiring
from Configuration.Eras.Modifier_stage1L1Trigger_cff import stage1L1Trigger
from Configuration.Eras.Modifier_stage2L1Trigger_2017_cff import stage2L1Trigger_2017
process.load("PhysicsTools.PatUtils.L1ECALPrefiringWeightProducer_cff")
stage1L1Trigger.toModify(process.prefiringweight, DataEra="2016BtoH")
stage2L1Trigger_2017.toModify(process.prefiringweight, DataEra="2017BtoF")
run2_L1prefiring.toModify(task,
func=lambda t: t.add(process.prefiringweight))
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' ]
)
)
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()),
cms.InputTag("g4SimHits",hgchefrontDigitizer.hitCollection.value()) ],
subdets = theMixObjects.mixCH.subdets + [ hgceeDigitizer.hitCollection.value(),
hgchefrontDigitizer.hitCollection.value() ],
)
)
from Configuration.Eras.Modifier_phase2_hfnose_cff import phase2_hfnose
phase2_hfnose.toModify( theMixObjects,
mixCH = dict(
input = theMixObjects.mixCH.input + [ cms.InputTag("g4SimHits",hfnoseDigitizer.hitCollection.value()) ],
subdets = theMixObjects.mixCH.subdets + [ hfnoseDigitizer.hitCollection.value() ],
)
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","FastTimerHitsBarrel"), cms.InputTag("g4SimHits","FastTimerHitsEndcap") ],
HFDarkening = cms.bool(False),
minFCToDelay=cms.double(5.), # old TC model! set to 5 for the new one
debugCaloSamples=cms.bool(False),
ignoreGeantTime=cms.bool(False),
# settings for SimHit test injection
injectTestHits = cms.bool(False),
# if no time is specified for injected hits, t = 0 will be used
# (recommendation: enable "ignoreGeantTime" in that case to set t = tof)
# otherwise, need 1 time value per energy value
injectTestHitsEnergy = cms.vdouble(),
injectTestHitsTime = cms.vdouble(),
# format for cells: subdet, ieta, iphi, depth
# multiple quadruplets can be specified
# if instead only 1 value is given,
# it will be interpreted as an entire subdetector
injectTestHitsCells = cms.vint32()
)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify( hcalSimBlock, hitsProducer=cms.string('famosSimHits') )
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
run2_HCAL_2017.toModify( hcalSimBlock, TestNumbering = cms.bool(True) )
# remove HE processing for phase 2, completely put in HGCal land
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(hcalSimBlock, killHE = cms.bool(True) )
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify(hcalSimBlock, doNeutralDensityFilter = cms.bool(False))
import FWCore.ParameterSet.Config as cms
import RecoParticleFlow.PFProducer.pfLinker_cfi
import RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi
particleFlow = RecoParticleFlow.PFProducer.pfLinker_cfi.pfLinker.clone()
particleFlow.PFCandidate = [cms.InputTag("particleFlowTmp")]
particleFlowPtrs = RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi.particleFlowTmpPtrs.clone()
particleFlowPtrs.src = "particleFlow"
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(particleFlow, forceElectronsInHGCAL = True)
MinMva = cms.double(-10000.),
MaxTipBarrel = cms.double(10000.),
MaxTipEndcaps = cms.double(10000.),
MaxTkIso03 = cms.double(1.),
MaxHcalIso03Depth1Barrel = cms.double(10000.),
MaxHcalIso03Depth1Endcaps = cms.double(10000.),
MaxHcalIso03Depth2Endcaps = cms.double(10000.),
MaxEcalIso03Barrel = cms.double(10000.),
MaxEcalIso03Endcaps = cms.double(10000.),
TriggerResults = cms.InputTag("TriggerResults::HLT"),
NbinEta = cms.int32(50), NbinEta2D = cms.int32(50), EtaMin = cms.double(-2.5), EtaMax = cms.double(2.5),
NbinPhi = cms.int32(64), NbinPhi2D = cms.int32(32), PhiMax = cms.double(3.2), PhiMin = cms.double(-3.2),
NbinPt = cms.int32(50), NbinPtEff = cms.int32(19), NbinPt2D = cms.int32(50), PtMax = cms.double(100.0),
NbinP = cms.int32(50), NbinP2D = cms.int32(50), PMax = cms.double(300.0),
NbinEop = cms.int32(50), NbinEop2D = cms.int32(30), EopMax = cms.double(5.0), EopMaxSht = cms.double(3.0),
NbinDeta = cms.int32(100), DetaMin = cms.double(-0.005), DetaMax = cms.double(0.005),
NbinDphi = cms.int32(100), DphiMin = cms.double(-0.01), DphiMax = cms.double(0.01),
NbinDetaMatch = cms.int32(100), NbinDetaMatch2D = cms.int32(50), DetaMatchMin = cms.double(-0.05), DetaMatchMax = cms.double(0.05),
NbinDphiMatch = cms.int32(100), NbinDphiMatch2D = cms.int32(50), DphiMatchMin = cms.double(-0.2), DphiMatchMax = cms.double(0.2),
NbinFhits = cms.int32(30), FhitsMax = cms.double(30.0),
NbinLhits = cms.int32(5), LhitsMax = cms.double(10.0),
NbinXyz = cms.int32(50), NbinXyz2D = cms.int32(25),
NbinPopTrue = cms.int32(75), PopTrueMin = cms.double(0.0), PopTrueMax = cms.double(1.5),
NbinMee = cms.int32(100), MeeMin = cms.double(0.0), MeeMax = cms.double(150.),
NbinHoe = cms.int32(100), HoeMin = cms.double(0.0), HoeMax = cms.double(0.5)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( dqmElectronTagProbeAnalysis, ElectronCollection = cms.InputTag("ecalDrivenGsfElectrons") )
import FWCore.ParameterSet.Config as cms # Trigger Primitive Producer from SimCalorimetry.EcalEBTrigPrimProducers.ecalEBTriggerPrimitiveDigis_cfi import * # esmodule creating records + corresponding empty essource # when commented, one takes the configuration from the global tag # #Common from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toModify( simEcalEBTriggerPrimitiveDigis, BarrelOnly = cms.bool(True) )
# format for cells: subdet, ieta, iphi, depth
# multiple quadruplets can be specified
# if instead only 1 value is given,
# it will be interpreted as an entire subdetector
injectTestHitsCells=cms.vint32(),
HFRecalParameterBlock=HFRecalParameterBlock,
)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(hcalSimBlock, hitsProducer=cms.string('fastSimProducer'))
from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1
premix_stage1.toModify(
hcalSimBlock,
doNoise=False,
doEmpty=False,
doIonFeedback=False,
doThermalNoise=False,
doTimeSlew=False,
HcalPreMixStage1=True,
)
# test numbering not used in fastsim
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
(run2_HCAL_2017 & ~fastSim).toModify(hcalSimBlock,
TestNumbering=cms.bool(True))
# remove HE processing for phase 2, completely put in HGCal land
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(hcalSimBlock, killHE=cms.bool(True))
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = cms.bool(True)
process.patMuons.computeMuonMVA = cms.bool(True)
process.patMuons.computeSoftMuonMVA = cms.bool(True)
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag("reducedEgamma","reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet()
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.elPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-")
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(process.patOOTPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoHcalPFClusIso"))
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.phPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma","reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(process.selectedPatMuons, cut = "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure( process )
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process, metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process,
labelName = "patCaloMet",
metSource = "caloMetM"
)
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter("GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0")
)
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(), process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0")
)
task.add(process.CHSCands)
process.pfMetCHS = cms.EDProducer("PFMETProducer",
src = cms.InputTag("CHSCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetCHS)
addMETCollection(process,
labelName = "patCHSMet",
metSource = "pfMetCHS"
)
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = cms.EDProducer("PFMETProducer",
src = cms.InputTag("TrkCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetTrk)
addMETCollection(process,
labelName = "patTrkMet",
metSource = "pfMetTrk"
)
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.patJets.userData.userInts.src = [ cms.InputTag("pileupJetId:fullId"), ]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [ cms.InputTag('QGTagger:qgLikelihood'), ]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL' ),
])
## CaloJets
process.caloJetMap = cms.EDProducer("RecoJetDeltaRValueMapProducer",
src = process.patJets.jetSource,
matched = cms.InputTag("ak4CaloJets"),
distMax = cms.double(0.4),
values = cms.vstring('pt','emEnergyFraction'),
valueLabels = cms.vstring('pt','emEnergyFraction'),
lazyParser = cms.bool(True) )
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [ cms.InputTag("caloJetMap:pt"), cms.InputTag("caloJetMap:emEnergyFraction") ]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
process.patElectrons.addElectronID = cms.bool(True)
electron_ids = ['RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
]
switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
process.electronRegressionValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
for idmod in electron_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task)
#heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded
if hasattr(process,'heepIDVarValueMaps'):
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
#force HEEP to use miniAOD (otherwise it'll detect the AOD)
process.heepIDVarValueMaps.dataFormat = cms.int32(2)
#add the HEEP trk isol to the slimmed electron, add it to the first FromFloatValMap modifier
for pset in process.slimmedElectrons.modifierConfig.modifications:
if pset.hasParameter("modifierName") and pset.modifierName == cms.string('EGExtraInfoModifierFromFloatValueMaps'):
pset.electron_config.heepTrkPtIso = cms.InputTag("heepIDVarValueMaps","eleTrkPtIso")
break
#VID Photon IDs
process.patPhotons.addPhotonID = cms.bool(True)
photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff']
switchOnVIDPhotonIdProducer(process,DataFormat.AOD, task)
process.egmPhotonIsolation.srcToIsolate = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
for iPSet in process.egmPhotonIsolation.isolationConeDefinitions:
iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.egmPhotonIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonRegressionValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.particleBasedIsolation = \
cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.photonMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection,None,False,task)
#add the cut base IDs bitmaps of which cuts passed
from RecoEgamma.EgammaTools.egammaObjectModifications_tools import makeVIDBitsModifier
egamma_modifications.append(makeVIDBitsModifier(process,"egmGsfElectronIDs","egmPhotonIDs"))
#-- Adding boosted taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.load("RecoTauTag.Configuration.HPSPFTaus_cff")
#-- Adding customization for 94X 2017 legacy reMniAOD
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask)
run2_miniAOD_94XFall17.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID
)
#-- Adding customization for 80X 2016 legacy reMiniAOD
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
run2_miniAOD_80XLegacy.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco
)
# Adding puppi jets
if not hasattr(process, 'ak4PFJetsPuppi'): #MM: avoid confilct with substructure call
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX,
jets = cms.InputTag("ak4PFJetsPuppi")
)
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0)
)
task.add(process.patJetPuppiCharge)
noDeepFlavourDiscriminators = [x.value() for x in process.patJets.discriminatorSources if not "DeepFlavour" in x.value()]
addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'),
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''),
pfCandidates = cms.InputTag("particleFlow"),
algo= 'AK', rParam = 0.4, btagDiscriminators = noDeepFlavourDiscriminators
)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
from PhysicsTools.PatAlgos.slimming.applyDeepBtagging_cff import applyDeepBtagging
applyDeepBtagging( process )
addToProcessAndTask('slimmedJetsPuppiNoMultiplicities', process.slimmedJetsNoDeepFlavour.clone(), process, task)
process.slimmedJetsPuppiNoMultiplicities.src = cms.InputTag("selectedPatJetsPuppi")
process.slimmedJetsPuppiNoMultiplicities.packedPFCandidates = cms.InputTag("packedPFCandidates")
from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
process.patPuppiJetSpecificProducer = patPuppiJetSpecificProducer.clone(
src=cms.InputTag("slimmedJetsPuppiNoMultiplicities"),
)
task.add(process.patPuppiJetSpecificProducer)
updateJetCollection(
process,
labelName = 'PuppiJetSpecific',
jetSource = cms.InputTag('slimmedJetsPuppiNoMultiplicities'),
)
process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = ['patPuppiJetSpecificProducer:puppiMultiplicity', 'patPuppiJetSpecificProducer:neutralPuppiMultiplicity', 'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:photonPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity' ]
process.slimmedJetsPuppi = process.selectedUpdatedPatJetsPuppiJetSpecific.clone()
delattr(process, 'selectedUpdatedPatJetsPuppiJetSpecific')
task.add(process.slimmedJetsPuppi)
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies( process );
runMetCorAndUncForMiniAODProduction(process, metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(), process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
# EGamma objects from HGCal are not yet in GED
# so add companion collections for Phase-II MiniAOD production
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
phase2_hgcal.toModify(task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
'keep HcalUnpackerReport_hcalDigis_*_*'
)
)
RecoLocalCaloFEVT.outputCommands.extend(ecalLocalRecoFEVT.outputCommands)
RecoLocalCaloRECO.outputCommands.extend(ecalLocalRecoRECO.outputCommands)
RecoLocalCaloAOD.outputCommands.extend(ecalLocalRecoAOD.outputCommands)
def _updateOutput( era, outputPSets, commands):
for o in outputPSets:
era.toModify( o, outputCommands = o.outputCommands + commands )
# mods for HGCAL
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( RecoLocalCaloFEVT, outputCommands = RecoLocalCaloFEVT.outputCommands + [
'keep *_HGCalRecHit_*_*',
'keep *_HGCalUncalibRecHit_*_*',
'keep *_hgcalLayerClusters_*_*'
]
)
phase2_hgcal.toModify( RecoLocalCaloRECO, outputCommands = RecoLocalCaloRECO.outputCommands + ['keep *_HGCalRecHit_*_*','keep *_hgcalLayerClusters_*_*'] )
# don't modify AOD for HGCal yet, need "reduced" rechits collection first (i.e. requires reconstruction)
phase2_hgcal.toModify( RecoLocalCaloAOD, outputCommands = RecoLocalCaloAOD.outputCommands + ['keep *_HGCalRecHit_*_*','keep *_hgcalLayerClusters_*_*'] )
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
pA_2016.toModify( RecoLocalCaloAOD.outputCommands,
func=lambda outputCommands: outputCommands.extend(['keep *_zdcreco_*_*',
'keep ZDCDataFramesSorted_hcalDigis_*_*',
'keep ZDCDataFramesSorted_castorDigis_*_*',
'keep QIE10DataFrameHcalDataFrameContainer_hcalDigis_ZDC_*'
])
)
fastSim.toModify(theDigitizers,
# fastsim does not model castor
castor = None,
# fastsim does not digitize pixel and strip hits
pixel = None,
strip = None,
tracks = recoTrackAccumulator
)
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hgceeDigitizer, hgchebackDigitizer, hgchefrontDigitizer
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( theDigitizers,
hgceeDigitizer = cms.PSet(hgceeDigitizer),
hgchebackDigitizer = cms.PSet(hgchebackDigitizer),
hgchefrontDigitizer = cms.PSet(hgchefrontDigitizer),
)
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify( theDigitizers, castor = None )
from SimGeneral.MixingModule.ecalTimeDigitizer_cfi import ecalTimeDigitizer
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing.toModify( theDigitizers,
ecalTime = ecalTimeDigitizer.clone() )
from SimFastTiming.Configuration.SimFastTiming_cff import fastTimeDigitizer
phase2_timing_layer.toModify( theDigitizers,
fastTimingLayer = fastTimeDigitizer.clone() )
'keep LumiDetails_lumiProducer_*_*', 'keep LumiSummary_lumiProducer_*_*'))
def _appendStage2Digis(obj):
l1Stage2Digis = [
'keep *_gtStage2Digis_*_*',
'keep *_gmtStage2Digis_*_*',
'keep *_caloStage2Digis_*_*',
]
obj.outputCommands += l1Stage2Digis
# adding them to all places where we had l1extraParticles
from Configuration.Eras.Modifier_stage2L1Trigger_cff import stage2L1Trigger
stage2L1Trigger.toModify(L1TriggerRAWDEBUG, func=_appendStage2Digis)
stage2L1Trigger.toModify(L1TriggerRECO, func=_appendStage2Digis)
stage2L1Trigger.toModify(L1TriggerAOD, func=_appendStage2Digis)
stage2L1Trigger.toModify(L1TriggerFEVTDEBUG, func=_appendStage2Digis)
# adding HGCal L1 trigger digis
def _appendHGCalDigis(obj):
l1HGCalDigis = [
'keep *_hgcalTriggerPrimitiveDigiProducer__*',
]
obj.outputCommands += l1HGCalDigis
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(L1TriggerFEVTDEBUG, func=_appendHGCalDigis)
src = cms.VInputTag("particleFlowTmpBarrel",
"simPFProducer")
)
_phase2_hgcal_simPFSequence = cms.Sequence( pfTrack +
hgcalTrackCollection +
tpClusterProducer +
quickTrackAssociatorByHits +
simPFProducer )
_phase2_hgcal_particleFlowReco = cms.Sequence( _phase2_hgcal_simPFSequence * particleFlowReco.copy() )
_phase2_hgcal_particleFlowReco.replace( particleFlowTmpSeq, cms.Sequence( particleFlowTmpBarrel * particleFlowTmp ) )
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( quickTrackAssociatorByHits,
pixelSimLinkSrc = cms.InputTag("simSiPixelDigis","Pixel"),
stripSimLinkSrc = cms.InputTag("simSiPixelDigis","Tracker")
)
phase2_hgcal.toModify( tpClusterProducer,
pixelSimLinkSrc = cms.InputTag("simSiPixelDigis", "Pixel"),
phase2OTSimLinkSrc = cms.InputTag("simSiPixelDigis","Tracker")
)
phase2_hgcal.toReplaceWith( particleFlowTmp, _phase2_hgcal_particleFlowTmp )
phase2_hgcal.toReplaceWith( particleFlowReco, _phase2_hgcal_particleFlowReco )
from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017
pp_on_XeXe_2017.toModify(particleFlowDisplacedVertexCandidate,
tracksSelectorParameters = dict(pt_min = 999999.0,
nChi2_max = 0.0,
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()),
cms.InputTag("g4SimHits",hgchefrontDigitizer.hitCollection.value()) ],
subdets = theMixObjects.mixCH.subdets + [ hgceeDigitizer.hitCollection.value(),
hgchefrontDigitizer.hitCollection.value() ]
)
)
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","FastTimerHitsBarrel"), cms.InputTag("g4SimHits","FastTimerHitsEndcap") ],
subdets = theMixObjects.mixSH.subdets + [ 'FastTimerHitsBarrel','FastTimerHitsEndcap' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'FastTimerHitsBarrel','FastTimerHitsEndcap' ]
)
)
import FWCore.ParameterSet.Config as cms
import RecoParticleFlow.PFProducer.pfLinker_cfi
import RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi
particleFlow = RecoParticleFlow.PFProducer.pfLinker_cfi.pfLinker.clone()
particleFlow.PFCandidate = [cms.InputTag("particleFlowTmp")]
particleFlowPtrs = RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi.particleFlowTmpPtrs.clone(
)
particleFlowPtrs.src = "particleFlow"
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(particleFlow, forceElectronsInHGCAL=True)
'GainWidths', 'MCParams', 'RecoParams', 'RespCorrs', 'QIEData',
'QIETypes', 'Gains', 'Pedestals', 'PedestalWidths', 'ChannelQuality',
'ZSThresholds', 'TimeCorrs', 'LUTCorrs', 'LutMetadata',
'L1TriggerObjects', 'PFCorrs', 'ElectronicsMap', 'FrontEndMap',
'CovarianceMatrices', 'SiPMParameters', 'SiPMCharacteristics',
'TPChannelParameters', 'TPParameters', 'FlagHFDigiTimeParams'),
GainWidthsForTrigPrims=cms.bool(True))
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
from Configuration.Eras.Modifier_run2_HF_2017_cff import run2_HF_2017
from Configuration.Eras.Modifier_run2_HE_2017_cff import run2_HE_2017
from Configuration.Eras.Modifier_run2_HEPlan1_2017_cff import run2_HEPlan1_2017
from Configuration.Eras.Modifier_run3_HB_cff import run3_HB
run2_HCAL_2017.toModify(es_hardcode, useLayer0Weight=cms.bool(True))
run2_HF_2017.toModify(es_hardcode, useHFUpgrade=cms.bool(True))
run2_HE_2017.toModify(es_hardcode,
useHEUpgrade=cms.bool(True),
HEreCalibCutoff=cms.double(100.0))
run2_HEPlan1_2017.toModify(es_hardcode,
testHEPlan1=cms.bool(True),
useHEUpgrade=cms.bool(False),
HEreCalibCutoff=cms.double(20.0))
run3_HB.toModify(es_hardcode,
useHBUpgrade=cms.bool(True),
HBreCalibCutoff=cms.double(100.0))
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(es_hardcode, killHE=cms.bool(True))
theDigitizers,
# fastsim does not model castor
castor=None,
# fastsim does not digitize pixel and strip hits
pixel=None,
strip=None,
tracks=recoTrackAccumulator)
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
(fastSim & premix_stage2).toModify(theDigitizers, tracks=None)
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hgceeDigitizer, hgchebackDigitizer, hgchefrontDigitizer, HGCAL_noise_fC, HGCAL_noise_heback, HGCAL_chargeCollectionEfficiencies, HGCAL_ileakParam_toUse, HGCAL_cceParams_toUse, HGCAL_noises
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
theDigitizers,
hgceeDigitizer=cms.PSet(hgceeDigitizer),
hgchebackDigitizer=cms.PSet(hgchebackDigitizer),
hgchefrontDigitizer=cms.PSet(hgchefrontDigitizer),
)
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hfnoseDigitizer
from Configuration.Eras.Modifier_phase2_hfnose_cff import phase2_hfnose
phase2_hfnose.toModify(
theDigitizers,
hfnoseDigitizer=cms.PSet(hfnoseDigitizer),
)
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify(theDigitizers, castor=None)
from SimGeneral.MixingModule.ecalTimeDigitizer_cfi import ecalTimeDigitizer
ecalDrivenElectronSeedsParameters,
# OrderedHitsFactoryPSet = cms.PSet(
# ComponentName = cms.string('StandardHitPairGenerator'),
# SeedingLayers = cms.string('MixedLayerPairs')
# ),
# TTRHBuilder = cms.string('WithTrackAngle'),
# # eta-phi region
# RegionPSet = cms.PSet(
# deltaPhiRegion = cms.double(0.7),
# originHalfLength = cms.double(15.0),
# useZInVertex = cms.bool(True),
# deltaEtaRegion = cms.double(0.3),
# ptMin = cms.double(1.5),
# originRadius = cms.double(0.2),
# VertexProducer = cms.InputTag("pixelVertices")
# )
)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
ecalDrivenElectronSeeds,
endcapSuperClusters = cms.InputTag('particleFlowSuperClusterHGCal')
)
phase2_hgcal.toModify(
ecalDrivenElectronSeeds.SeedConfiguration,
allowHGCal = cms.bool(True)
)
vtxChi2 = cms.double(0.0005),
MinApproachLow = cms.double(-.25), #Track pair min distance at approaching point on X-Y
MinApproachHigh = cms.double(1.0), #Track pair min distance at approaching point on X-Y
rCut = cms.double(2.0),#analytical track cross point
dz = cms.double(5.0),#track pair inner position difference
# kinematic vertex fit parameters
maxDelta = cms.double(0.01),#delta of parameters
maxReducedChiSq = cms.double(225.),#maximum chi^2 per degree of freedom before fit is terminated
minChiSqImprovement = cms.double(50.),#threshold for "significant improvement" in the fit termination logic
maxNbrOfIterations = cms.int32(40),#maximum number of convergence iterations
UsePvtx = cms.bool(True),
AllowD0 = cms.bool(True), #Allow d0*charge cut
AllowDeltaPhi = cms.bool(False),
AllowTrackBC = cms.bool(False), #Allow to match track-basic cluster
AllowDeltaCot = cms.bool(True), #Allow pairing using delta cot theta cut
AllowMinApproach = cms.bool(True), #Allow pairing using min approach cut
AllowOppCharge = cms.bool(True), #use opposite charge tracks to pair
AllowVertex = cms.bool(True),
bypassPreselGsf = cms.bool(True), #bypass preselection for gsf + X pairs
bypassPreselEcal = cms.bool(False), #bypass preselection for ecal-seeded + X pairs
bypassPreselEcalEcal = cms.bool(True), #bypass preselection for ecal-seeded + ecal-seeded pairs
AllowSingleLeg = cms.bool(False), #Allow single track conversion
AllowRightBC = cms.bool(False) #Require second leg matching basic cluster
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( allConversions, bypassPreselGsf = cms.bool(False) )
_toGet_noEmap = _toGet[:]
_toGet_noEmap.remove('ElectronicsMap')
from Configuration.Eras.Modifier_hcalHardcodeConditions_cff import hcalHardcodeConditions
hcalHardcodeConditions.toModify( es_hardcode,
toGet = cms.untracked.vstring(_toGet),
GainWidthsForTrigPrims = cms.bool(True)
)
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
from Configuration.Eras.Modifier_run2_HF_2017_cff import run2_HF_2017
from Configuration.Eras.Modifier_run2_HE_2017_cff import run2_HE_2017
from Configuration.Eras.Modifier_run2_HEPlan1_2017_cff import run2_HEPlan1_2017
from Configuration.Eras.Modifier_run3_HB_cff import run3_HB
from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
run2_HCAL_2017.toModify( es_hardcode, useLayer0Weight = cms.bool(True) )
run2_HF_2017.toModify( es_hardcode, useHFUpgrade = cms.bool(True) )
run2_HE_2017.toModify( es_hardcode, useHEUpgrade = cms.bool(True), HEreCalibCutoff = cms.double(100.0) )
run2_HEPlan1_2017.toModify( es_hardcode, testHEPlan1 = cms.bool(True), useHEUpgrade = cms.bool(False), HEreCalibCutoff = cms.double(20.0) )
run3_HB.toModify( es_hardcode, useHBUpgrade = cms.bool(True), HBreCalibCutoff = cms.double(100.0) )
# now that we have an emap
phase2_hcal.toModify( es_hardcode, toGet = cms.untracked.vstring(_toGet_noEmap) )
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( es_hardcode, killHE = cms.bool(True) )
noiseThreshold=cms.double(3), # in units of sigmas of the noise
# Floating point compression
exponentBits=cms.uint32(4),
mantissaBits=cms.uint32(4),
rounding=cms.bool(True),
# Trigger cell calibration
fCperMIP=cms.double(fCPerMIP_200),
fCperMIPnose=cms.vdouble(fCPerMIPnose),
dEdXweights=layerWeights,
dEdXweightsNose=layerWeightsNose,
ThicknessCorrections=cms.vdouble(frontend_thickness_corrections),
thickCorr=cms.double(thicknessCorrection_200),
thickCorrNose=cms.vdouble(thicknessCorrectionNose),
)
# isolate these refs in case they aren't available in some other WF
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(
vfe_proc,
noiseSilicon=cms.PSet(refToPSet_=cms.string("HGCAL_noise_fC")),
noiseScintillator=cms.PSet(refToPSet_=cms.string("HGCAL_noise_heback")),
)
hgcalVFEProducer = cms.EDProducer(
"HGCalVFEProducer",
eeDigis=cms.InputTag('simHGCalUnsuppressedDigis:EE'),
fhDigis=cms.InputTag('simHGCalUnsuppressedDigis:HEfront'),
bhDigis=cms.InputTag('simHGCalUnsuppressedDigis:HEback'),
noseDigis=cms.InputTag('simHFNoseUnsuppressedDigis:HFNose'),
ProcessorParameters=vfe_proc.clone())
import FWCore.ParameterSet.Config as cms
EcalDeadCellTriggerPrimitiveFilter = cms.EDFilter(
'EcalDeadCellTriggerPrimitiveFilter',
# when activated, the filter does not filter event.
# the filter is however storing a bool in the event, that can be used to take the
# filtering decision a posteriori
taggingMode=cms.bool(False),
debug=cms.bool(False),
verbose=cms.int32(1),
tpDigiCollection=cms.InputTag("ecalTPSkimNA"),
etValToBeFlagged=cms.double(127.49),
ebReducedRecHitCollection=cms.InputTag("reducedEcalRecHitsEB"),
eeReducedRecHitCollection=cms.InputTag("reducedEcalRecHitsEE"),
maskedEcalChannelStatusThreshold=cms.int32(1),
doEEfilter=cms.untracked.bool(True), # turn it on by default
useTTsum=cms.bool(True),
usekTPSaturated=cms.bool(False))
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(EcalDeadCellTriggerPrimitiveFilter, doEEfilter=False)
collectionDM = cms.string("Phase2OTDigiSimLink"),
),
),
)
# ECAL
phase2_ecal.toModify(mixData,
workers = dict(
ecal = dict(
doES = False,
EBPileInputTag = "simEcalDigis:ebDigis",
EEPileInputTag = "simEcalDigis:eeDigis",
)
)
)
phase2_hgcal.toModify(mixData, workers=dict(ecal=dict(doEE=False)))
# HCAL
phase2_hcal.toModify(mixData,
workers = dict(
hcal = dict(
HBHEPileInputTag = "simHcalDigis",
HOPileInputTag = "simHcalDigis",
HFPileInputTag = "simHcalDigis",
QIE10PileInputTag = "simHcalDigis:HFQIE10DigiCollection",
QIE11PileInputTag = "simHcalDigis:HBHEQIE11DigiCollection",
ZDCPileInputTag = "simHcalUnsuppressedDigis",
)
)
)
outputCommands = cms.untracked.vstring('keep PileupSummaryInfos_*_*_*',
'keep int_*_bunchSpacing_*',
'keep *_genPUProtons_*_*')
)
# mods for HGCAL
_phase2_hgc_extraCommands = cms.PSet( # using PSet in order to customize with Modifier
v = cms.vstring('keep *_mix_HGCDigisEE_*', 'keep *_mix_HGCDigisHEfront_*', 'keep *_mix_HGCDigisHEback_*', 'keep *_mix_MergedCaloTruth_*'),
)
# For phase2 premixing switch the sim digi collections to the ones including pileup
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
premix_stage2.toModify(_phase2_hgc_extraCommands,
v = ['keep *_mixData_HGCDigisEE_*', 'keep *_mixData_HGCDigisHEfront_*', 'keep *_mixData_HGCDigisHEback_*', 'keep *_mixData_MergedCaloTruth_*']
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( SimGeneralRAW, outputCommands = SimGeneralRAW.outputCommands + _phase2_hgc_extraCommands.v )
phase2_hgcal.toModify( SimGeneralFEVTDEBUG, outputCommands = SimGeneralFEVTDEBUG.outputCommands + _phase2_hgc_extraCommands.v )
phase2_hgcal.toModify( SimGeneralRECO, outputCommands = SimGeneralRECO.outputCommands + _phase2_hgc_extraCommands.v )
_phase2_timing_extraCommands = [ 'keep *_mix_FTLBarrel_*','keep *_mix_FTLEndcap_*','keep *_mix_InitialVertices_*' ]
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toModify( SimGeneralRAW, outputCommands = SimGeneralRAW.outputCommands + _phase2_timing_extraCommands )
phase2_timing.toModify( SimGeneralFEVTDEBUG, outputCommands = SimGeneralFEVTDEBUG.outputCommands + _phase2_timing_extraCommands )
phase2_timing.toModify( SimGeneralRECO, outputCommands = SimGeneralRECO.outputCommands + _phase2_timing_extraCommands )
_pp_on_AA_extraCommands = ['keep CrossingFramePlaybackInfoNew_mix_*_*','keep *_heavyIon_*_*']
from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
for e in [pp_on_XeXe_2017, pp_on_AA_2018]:
e.toModify( SimGeneralRAW, outputCommands = SimGeneralRAW.outputCommands + _pp_on_AA_extraCommands )
e.toModify( SimGeneralFEVTDEBUG, outputCommands = SimGeneralFEVTDEBUG.outputCommands + _pp_on_AA_extraCommands )
dqmElectronAnalysisSelectionEt = dqmElectronAnalysis.clone() ;
dqmElectronAnalysisSelectionEt.Selection = 1 ;
dqmElectronAnalysisSelectionEt.OutputFolderName = cms.string("Egamma/Electrons/Ele3_Et10") ;
dqmElectronAnalysisSelectionEtIso = dqmElectronAnalysis.clone() ;
dqmElectronAnalysisSelectionEtIso.Selection = 2 ;
dqmElectronAnalysisSelectionEtIso.OutputFolderName = cms.string("Egamma/Electrons/Ele4_Et10TkIso1") ;
#dqmElectronAnalysisSelectionEtIsoElID = dqmElectronAnalysis.clone() ;
#dqmElectronAnalysisSelectionEtIsoElID.Selection = 3 ;
#dqmElectronAnalysisSelectionEtIsoElID.OutputFolderName = cms.string("Egamma/Electrons/Ele4_Et10TkIso1ElID") ;
from DQMOffline.EGamma.electronTagProbeAnalyzer_cfi import *
dqmElectronTagProbeAnalysis.MinEt = cms.double(10.) ;
dqmElectronTagProbeAnalysis.MaxTkIso03 = cms.double(1.) ;
dqmElectronTagProbeAnalysis.OutputFolderName = cms.string("Egamma/Electrons/Ele5_TagAndProbe") ;
electronAnalyzerSequence = cms.Sequence(
mergedSuperClusters
* dqmElectronGeneralAnalysis
* dqmElectronAnalysisAllElectrons
* dqmElectronAnalysisSelectionEt
* dqmElectronAnalysisSelectionEtIso
# * dqmElectronAnalysisSelectionEtIsoElID
* dqmElectronTagProbeAnalysis
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( mergedSuperClusters, src = cms.VInputTag( cms.InputTag("particleFlowSuperClusterECAL","particleFlowSuperClusterECALBarrel"), cms.InputTag("particleFlowSuperClusterHGCal","") ) )
v=cms.vstring('keep *_simHGCalUnsuppressedDigis_EE_*',
'keep *_simHGCalUnsuppressedDigis_HEfront_*',
'keep *_simHGCalUnsuppressedDigis_HEback_*',
'keep *_mix_MergedCaloTruth_*'), )
# For phase2 premixing switch the sim digi collections to the ones including pileup
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
premix_stage2.toModify(_phase2_hgc_extraCommands,
v=[
'keep *_mixData_HGCDigisEE_*',
'keep *_mixData_HGCDigisHEfront_*',
'keep *_mixData_HGCDigisHEback_*',
'keep *_mixData_MergedCaloTruth_*'
])
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(SimGeneralRAW,
outputCommands=SimGeneralRAW.outputCommands +
_phase2_hgc_extraCommands.v)
phase2_hgcal.toModify(SimGeneralFEVTDEBUG,
outputCommands=SimGeneralFEVTDEBUG.outputCommands +
_phase2_hgc_extraCommands.v)
phase2_hgcal.toModify(SimGeneralRECO,
outputCommands=SimGeneralRECO.outputCommands +
_phase2_hgc_extraCommands.v)
phase2_hgcal.toModify(SimGeneralPREMIX,
outputCommands=SimGeneralPREMIX.outputCommands +
_phase2_hgc_extraCommands.v)
_phase2_timing_extraCommands = [
'keep *_mix_FTLBarrel_*', 'keep *_mix_FTLEndcap_*',
'keep *_mix_InitialVertices_*'
]
pixel = None,
strip = None,
tracks = recoTrackAccumulator
)
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
(fastSim & premix_stage2).toModify(theDigitizers,
tracks = None
)
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hgceeDigitizer, hgchebackDigitizer, hgchefrontDigitizer, HGCAL_noise_fC, HGCAL_noise_MIP, HGCAL_chargeCollectionEfficiencies, HGCAL_noises
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( theDigitizers,
hgceeDigitizer = cms.PSet(hgceeDigitizer),
hgchebackDigitizer = cms.PSet(hgchebackDigitizer),
hgchefrontDigitizer = cms.PSet(hgchefrontDigitizer),
)
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hfnoseDigitizer
from Configuration.Eras.Modifier_phase2_hfnose_cff import phase2_hfnose
phase2_hfnose.toModify( theDigitizers,
hfnoseDigitizer = cms.PSet(hfnoseDigitizer),
)
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify( theDigitizers, castor = None )
from SimGeneral.MixingModule.ecalTimeDigitizer_cfi import ecalTimeDigitizer
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
pp_on_AA.toModify(MicroEventContentMC, outputCommands = MicroEventContentMC.outputCommands + _pp_on_AA_MC_extraCommands)
from Configuration.Eras.Modifier_strips_vfp30_2016_cff import strips_vfp30_2016
strips_vfp30_2016.toModify(MicroEventContentMC, outputCommands = MicroEventContentMC.outputCommands + [
'keep *_simAPVsaturation_SimulatedAPVDynamicGain_*'
])
MiniAODOverrideBranchesSplitLevel = cms.untracked.VPSet( [
cms.untracked.PSet(branch = cms.untracked.string("patPackedCandidates_packedPFCandidates__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoGenParticles_prunedGenParticles__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patTriggerObjectStandAlones_slimmedPatTrigger__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patPackedGenParticles_packedGenParticles__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patJets_slimmedJets__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoVertexs_offlineSlimmedPrimaryVertices__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoVertexs_offlineSlimmedPrimaryVerticesWithBS__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoCaloClusters_reducedEgamma_reducedESClusters_*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("EcalRecHitsSorted_reducedEgamma_reducedEBRecHits_*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("EcalRecHitsSorted_reducedEgamma_reducedEERecHits_*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("recoGenJets_slimmedGenJets__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("patJets_slimmedJetsPuppi__*"),splitLevel=cms.untracked.int32(99)),
cms.untracked.PSet(branch = cms.untracked.string("EcalRecHitsSorted_reducedEgamma_reducedESRecHits_*"),splitLevel=cms.untracked.int32(99)),
])
_phase2_hgc_extraCommands = ["keep *_slimmedElectronsFromMultiCl_*_*", "keep *_slimmedPhotonsFromMultiCl_*_*"]
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(MicroEventContentMC, outputCommands = MicroEventContentMC.outputCommands + _phase2_hgc_extraCommands)
_phase2_timing_extraCommands = ["keep *_offlineSlimmedPrimaryVertices4D_*_*"]
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toModify(MicroEventContentMC, outputCommands = MicroEventContentMC.outputCommands + _phase2_timing_extraCommands)
'hgcalTrackCollection:TracksInHGCal')
#_phase2_hgcal_Importers[2].source_ee = cms.InputTag('particleFlowSuperClusterHGCal')
#_phase2_hgcal_Importers.append(
# cms.PSet( importerName = cms.string("HGCalClusterImporter"),
# source = cms.InputTag("particleFlowClusterHGCal"),
# BCtoPFCMap = cms.InputTag('particleFlowSuperClusterHGCal:PFClusterAssociationEBEE') ),
#)
_phase2_hgcal_Linkers = deepcopy(particleFlowBlock.linkDefinitions)
### for later
#_phase2_hgcal_Linkers.append(
# cms.PSet( linkerName = cms.string("SCAndHGCalLinker"),
# linkType = cms.string("SC:HGCAL"),
# useKDTree = cms.bool(False),
# SuperClusterMatchByRef = cms.bool(True) )
#)
#_phase2_hgcal_Linkers.append(
# cms.PSet( linkerName = cms.string("HGCalAndBREMLinker"),
# linkType = cms.string("HGCAL:BREM"),
# useKDTree = cms.bool(False) )
#)
#_phase2_hgcal_Linkers.append(
# cms.PSet( linkerName = cms.string("GSFAndHGCalLinker"),
# linkType = cms.string("GSF:HGCAL"),
# useKDTree = cms.bool(False) )
#)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(particleFlowBlock,
linkDefinitions=_phase2_hgcal_Linkers,
elementImporters=_phase2_hgcal_Importers)
EminFineTrack = cms.double(10000.0),
FineCaloNames = cms.vstring('ECAL', 'HCal', 'HGCal', 'HFNoseVol', 'VCAL'),
FineCaloLevels = cms.vint32(4, 4, 8, 3, 3),
UseFineCalo = cms.vint32(2, 3),
)
## enable fine calorimeter functionality: must occur *before* common PSet is used below
from Configuration.ProcessModifiers.fineCalo_cff import fineCalo
fineCalo.toModify(common_MCtruth,
DoFineCalo = True
)
## enable CaloBoundary information for all Phase2 workflows
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify(common_MCtruth,
SaveCaloBoundaryInformation = True
)
g4SimHits = cms.EDProducer("OscarMTProducer",
g4GeometryDD4hepSource = cms.bool(False),
NonBeamEvent = cms.bool(False),
EventVerbose = cms.int32(0),
UseMagneticField = cms.bool(True),
UseCommandBaseScorer = cms.bool(False),
StoreRndmSeeds = cms.bool(False),
RestoreRndmSeeds = cms.bool(False),
PhysicsTablesDirectory = cms.untracked.string('PhysicsTables'),
StorePhysicsTables = cms.untracked.bool(False),
RestorePhysicsTables = cms.untracked.bool(False),
UseParametrisedEMPhysics = cms.untracked.bool(True),
ThresholdForGeometryExceptions = cms.double(0.1), ## in GeV
MinApproachHigh = cms.double(1.0), #Track pair min distance at approaching point on X-Y
rCut = cms.double(2.0),#analytical track cross point
dz = cms.double(5.0),#track pair inner position difference
# kinematic vertex fit parameters
maxDelta = cms.double(0.01),#delta of parameters
maxReducedChiSq = cms.double(225.),#maximum chi^2 per degree of freedom before fit is terminated
minChiSqImprovement = cms.double(50.),#threshold for "significant improvement" in the fit termination logic
maxNbrOfIterations = cms.int32(40),#maximum number of convergence iterations
UsePvtx = cms.bool(True),
AllowD0 = cms.bool(True), #Allow d0*charge cut
AllowDeltaPhi = cms.bool(False),
AllowTrackBC = cms.bool(False), #Allow to match track-basic cluster
AllowDeltaCot = cms.bool(True), #Allow pairing using delta cot theta cut
AllowMinApproach = cms.bool(True), #Allow pairing using min approach cut
AllowOppCharge = cms.bool(True), #use opposite charge tracks to pair
AllowVertex = cms.bool(True),
bypassPreselGsf = cms.bool(True), #bypass preselection for gsf + X pairs
bypassPreselEcal = cms.bool(False), #bypass preselection for ecal-seeded + X pairs
bypassPreselEcalEcal = cms.bool(True), #bypass preselection for ecal-seeded + ecal-seeded pairs
AllowSingleLeg = cms.bool(False), #Allow single track conversion
AllowRightBC = cms.bool(False) #Require second leg matching basic cluster
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( allConversions, bypassPreselGsf = cms.bool(False) )
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(allConversions, src = 'gsfGeneralConversionTrackMerger')
