def loadPF2PAT(process,mcInfo,JetMetCorrections,postfix): #-- PAT standard config ------------------------------------------------------- process.load("PhysicsTools.PatAlgos.patSequences_cff") #-- Jet corrections ----------------------------------------------------------- process.patJetCorrFactors.corrSample = JetMetCorrections #-- PF2PAT config ------------------------------------------------------------- from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process,runPF2PAT=True, jetAlgo='AK5',runOnMC=mcInfo,postfix=postfix) process.patJetsPF.embedGenJetMatch = False process.patJetsPF.embedPFCandidates = False
def addPF2PAT(process, dataVersion, postfix="PFlow", doTauHLTMatching=True, matchingTauTrigger=None, ): # if hasattr(process, "patDefaultSequence"): # raise Exception("PAT should not exist before calling addPF2PAT at the moment") # Hack to not to crash if something in PAT assumes process.out hasOut = hasattr(process, "out") outputCommands = [] outputCommandsBackup = [] if hasOut: outputCommandsBackup = process.out.outputCommands[:] else: process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('dummy.root'), outputCommands = cms.untracked.vstring() ) outputCommands = [] # Jet modifications # PhysicsTools/PatExamples/test/patTuple_42x_jec_cfg.py jetCorrFactors = patJetCorrLevels(dataVersion, True) jetCorrPayload = "AK5PFchs" process.load("PhysicsTools.PatAlgos.patSequences_cff") pfTools.usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", jetCorrections=(jetCorrPayload, jetCorrFactors), runOnMC=dataVersion.isMC(), postfix=postfix) outputCommands = [ # "keep *_selectedPatPhotons%s_*_*" % postfix, # 'keep *_selectedPatElectrons%s_*_*' % postfix, 'keep *_selectedPatMuons%s_*_*' % postfix, 'keep *_selectedPatJets%s*_*_*' % postfix, 'keep *_selectedPatTaus%s_*_*' % postfix, 'keep *_selectedPatPFParticles%s_*_*' % postfix, 'keep *_selectedPatJets%s_pfCandidates_*' % postfix, 'drop *_*PF_caloTowers_*', 'drop *_*JPT_pfCandidates_*', 'drop *_*Calo_pfCandidates_*', 'keep *_patMETs%s_*_*' % postfix, ] # Enable PFnoPU getattr(process, "pfPileUp"+postfix).Enable = True getattr(process, "pfPileUp"+postfix).checkClosestZVertex = False getattr(process, "pfPileUp"+postfix).Vertices = "offlinePrimaryVertices" # Jet modifications # L1FastJet # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#OffsetJEC # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCor2011 # https://hypernews.cern.ch/HyperNews/CMS/get/jes/184.html kt6name = "kt6PFJets"+postfix process.load('RecoJets.Configuration.RecoPFJets_cff') from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets setattr(process, kt6name, kt4PFJets.clone( rParam = 0.6, src = 'pfNoElectron'+postfix, doRhoFastjet = True, doAreaFastJet = cms.bool(True), )) getattr(process, "patPF2PATSequence"+postfix).replace( getattr(process, "pfNoElectron"+postfix), getattr(process, "pfNoElectron"+postfix) * getattr(process, kt6name)) getattr(process, "patJetCorrFactors"+postfix).rho = cms.InputTag(kt6name, "rho") getattr(process, "patJetCorrFactors"+postfix).useRho = True # ak5PFJets getattr(process, "pfJets"+postfix).doAreaFastjet = cms.bool(True) getattr(process, "pfJets"+postfix).doRhoFastjet = False # getattr(process, "pfJets"+postfix).Vertices = cms.InputTag("goodPrimaryVertices") setPatJetDefaults(getattr(process, "patJets"+postfix)) # Use HPS taus # Add and recalculate the discriminators addHChTauDiscriminators() if not hasattr(process, "hpsPFTauDiscriminationForChargedHiggsByLeadingTrackPtCut"): import RecoTauTag.RecoTau.PFRecoTauDiscriminationForChargedHiggs_cfi as HChPFTauDiscriminators import RecoTauTag.RecoTau.CaloRecoTauDiscriminationForChargedHiggs_cfi as HChCaloTauDiscriminators tauAlgos = ["hpsPFTau"] # tauAlgos = ["pfTaus"+postfix] HChPFTauDiscriminators.addPFTauDiscriminationSequenceForChargedHiggs(process, tauAlgos) HChPFTauDiscriminatorsCont.addPFTauDiscriminationSequenceForChargedHiggsCont(process, tauAlgos) PFTauTestDiscrimination.addPFTauTestDiscriminationSequence(process, tauAlgos) fixFlightPath(process, tauAlgos[0]) fixFlightPath(process, tauAlgos[0], "Cont") patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequence, postfix) patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequenceCont, postfix) patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusTestDiscriminationSequence, postfix) patTauSeq = cms.Sequence( getattr(process, "hpsPFTauHplusDiscriminationSequence"+postfix) * getattr(process, "hpsPFTauHplusDiscriminationSequenceCont"+postfix) * getattr(process, "hpsPFTauHplusTestDiscriminationSequence"+postfix) # getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequence") * # getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequenceCont") * # getattr(process, "pfTaus"+postfix+"HplusTestDiscriminationSequence") ) setattr(process, "hplusPatTauSequence"+postfix, patTauSeq) patHelpers.massSearchReplaceParam(patTauSeq, "PFTauProducer", cms.InputTag("hpsPFTauProducer"), cms.InputTag("pfTaus"+postfix)) patHelpers.massSearchReplaceAnyInputTag(patTauSeq, cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"), cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"+postfix)) pfTools.adaptPFTaus(process, "hpsPFTau", postfix=postfix) setPatTauDefaults(getattr(process, "patTaus"+postfix), False) addPatTauIsolationEmbedding(process, getattr(process, "patDefaultSequence"+postfix), postfix) getattr(process, "selectedPatTaus"+postfix).cut = tauPreSelection # The prediscriminant of pfTausBaseDiscriminationByLooseIsolation # is missing from the default sequence, but since we don't want to # apply any tau selections as a part of PF2PAT anyway, let's just # remove this too getattr(process, "pfTaus"+postfix).discriminators = cms.VPSet() # getattr(process, "pfTauSequence"+postfix).remove(getattr(process, "pfTaus"+postfix)) # delattr(process, "pfTaus"+postfix) # getattr(process, "pfTausBaseSequence"+postfix).remove(getattr(process, "pfTausBaseDiscriminationByLooseIsolation"+postfix)) # Remove the shrinking cone altogether, we don't care about it # getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "patShrinkingConePFTauDiscrimination"+postfix)) # Override the tau source (this is WRONG in the standard PF2PAT, the expers should know it already) # getattr(process, "patTaus"+postfix).tauSource = "hpsPFTauProducer"+postfix # patHelpers.massSearchReplaceAnyInputTag(getattr(process, "patHPSPFTauDiscrimination"+postfix), # cms.InputTag("pfTaus"+postfix), # cms.InputTag("hpsPFTauProducer"+postfix)) # getattr(process, "pfNoTau"+postfix).topCollection = cms.InputTag("hpsPFTauProducer"+postfix) # Disable iso deposits, they take a LOT of space getattr(process, "patTaus"+postfix).isoDeposits = cms.PSet() # Disable tau top projection, the taus are identified and removed # from jets as a part of the analysis getattr(process, "pfNoTau"+postfix).enable = False # Lepton modifications setPatLeptonDefaults(getattr(process, "patMuons"+postfix), False) #setPatLeptonDefaults(getattr(process, "patElectrons"+postfix), False) #addPatElectronID(process, getattr(process, "patElectrons"+postfix), getattr(process, "makePatElectrons"+postfix)) # PATElectronProducer segfaults, and we don't really need them now getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "makePatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "selectedPatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatLeptons"+postfix)) # Disable muon and electron top projections, needs wider # discussion about lepton definitions getattr(process, "pfNoMuon"+postfix).enable = False getattr(process, "pfNoElectron"+postfix).enable = False # Remove photon MC matcher in order to avoid keeping photons in the event content #process.patDefaultSequencePFlow.remove(process.photonMatchPFlow) if hasOut: process.out.outputCommands = outputCommandsBackup process.out.outputCommands.extend(outputCommands) else: del process.out getattr(process, "patDefaultSequence"+postfix).replace( getattr(process, "patTaus"+postfix), patTauSeq * getattr(process, "patTaus"+postfix) ) sequence = cms.Sequence( getattr(process, "patPF2PATSequence"+postfix) ) if doTauHLTMatching: sequence *= HChTriggerMatching.addTauHLTMatching(process, matchingTauTrigger, collections=["selectedPatTaus"+postfix], postfix=postfix) return sequence
def usePF2PATForAnalysis(jetAlgo, postfix, useTypeIMET, usePFNoPU): # Jet corrections # No L2L3 Residual on purpose if usePFNoPU: jetCorrections = ("%sPFchs" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute']) postfix += "chs" else: jetCorrections = ("%sPF" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute']) #if not runOnMC: # jetCorrections[1].append('L2L3Residual') p = postfix usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=p, jetCorrections=jetCorrections, typeIMetCorrections = useTypeIMET) getattr(process, "pfPileUp" + p).Enable = True getattr(process, "pfPileUp" + p).Vertices = 'goodOfflinePrimaryVertices' getattr(process, "pfPileUp" + p).checkClosestZVertex = cms.bool(False) getattr(process, "pfJets" + p).doAreaFastjet = cms.bool(True) getattr(process, "pfJets" + p).doRhoFastjet = False getattr(process, 'patJetCorrFactors' + p).rho = cms.InputTag("kt6PFJets", "rho") # Do not use kt6PFJetsPFlowAK5, it's not ok for L1FastJet. # top projections in PF2PAT: getattr(process,"pfNoPileUp" + p).enable = cms.bool(usePFNoPU) getattr(process,"pfNoMuon" + p).enable = True getattr(process,"pfNoElectron" + p).enable = True getattr(process,"pfNoTau" + p).enable = True getattr(process,"pfNoJet" + p).enable = True getattr(process,"patElectrons" + p).embedTrack = True getattr(process,"patMuons" + p).embedTrack = True # enable delta beta correction for muon selection in PF2PAT? getattr(process,"pfIsolatedMuons" + p).doDeltaBetaCorrection = True getattr(process, "patJets" + p).embedPFCandidates = False # Keep only jets with pt > 2 Gev getattr(process, "selectedPatJets" + p).cut = "pt > 2"; # Use a cone of 0.3 for photon isolation #adaptPFIsoPhotons(process, applyPostfix(process, "patPhotons", postfix), postfix, "03") # 2012 Photon ID # Electron conversion setattr(process, "patConversions" + p, cms.EDProducer("PATConversionProducer", # input collection electronSource = cms.InputTag("selectedPatElectrons" + p) )) # Switch electron isolation to dR = 0.3, for PF2PAT getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p)) getattr(process, "pfIsolatedElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p) getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p)) getattr(process, "pfElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p)) getattr(process, "pfElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p) getattr(process, "pfElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag( "elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p)) # ... And for PAT adaptPFIsoElectrons(process, getattr(process, "pfElectrons" + p), p, "03") if runOnMC: cloneProcessingSnippet(process, getattr(process, "makePatMuons" + p), "Loose" + p, p) getattr(process, "muonMatchLoose" + p).src = cms.InputTag("pfMuons" + p) getattr(process, "patMuonsLoose" + p).pfMuonSource = cms.InputTag("pfMuons" + p) getattr(process, "patDefaultSequence" + p).replace(getattr(process, "makePatMuons" + p), getattr(process, "makePatMuons" + p) + getattr(process, "makePatMuonsLoose" + p)) else: setattr(process, "patMuonsLoose" + p, getattr(process, "patMuons" + p).clone( pfMuonSource = cms.InputTag("pfMuons" + p) ) ) setattr(process, "selectedPatMuonsLoose" + p, getattr(process, "selectedPatMuons" + p).clone( src = cms.InputTag("patMuonsLoose" + p) ) ) sequence = getattr(process, "patDefaultSequence" + p) if not runOnMC: sequence += getattr(process, "patMuonsLoose" + p) sequence += (getattr(process, "selectedPatMuonsLoose" + p)) setattr(process, "patElectronsLoose" + p, getattr(process, "patElectrons" + p).clone( pfElectronSource = cms.InputTag("pfElectrons" + p) ) ) setattr(process, "selectedPatElectronsLoose" + p, getattr(process, "selectedPatElectrons" + p).clone( src = cms.InputTag("patElectronsLoose" + p) ) ) adaptPFIsoElectrons(process, getattr(process, "patElectronsLoose" + p), postfix, "03") sequence = getattr(process, "patDefaultSequence" + p) sequence += (getattr(process, "patElectronsLoose" + p) * getattr(process, "selectedPatElectronsLoose" + p)) #giulia turn off qg tagger ## Setup quark gluon tagger #process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff') #cloneProcessingSnippet(process, process.QuarkGluonTagger, p) #getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p) #getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True) #getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(usePFNoPU) ## Remove the processing of primary vertices, as it's already what we do here #getattr(process, 'QGTagger' + p).srcPV = cms.InputTag('goodOfflinePrimaryVertices') #getattr(process, 'QuarkGluonTagger' + p).remove(getattr(process, 'goodOfflinePrimaryVerticesQG' + p)) if not runOnMC: if 'L2L3Residual' in jetCorrections: getattr(process, 'patPFJetMETtype1p2Corr' + p).jetCorrLabel = 'L2L3Residual' getattr(process, 'patPFMet' + p).addGenMET = cms.bool(False) names = ["Taus"] #if jetAlgo != "AK5": #names += ["Electrons", "Muons"] if len(names) > 0: removeSpecificPATObjects(process, names = names, outputModules = ['out'], postfix = p) adaptPVs(process, pvCollection = cms.InputTag("goodOfflinePrimaryVertices"), postfix = p) getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatElectrons" + p), getattr(process, "selectedPatElectrons" + p) + getattr(process, "patConversions" + p)) #getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatJets" + p), getattr(process, "selectedPatJets" + p) + getattr(process, "QuarkGluonTagger" + p)) return getattr(process, "patPF2PATSequence" + p)
# subtraction (CHS) applied. The latter is used to identify and remove # particles from pileup, by associating their tracks with the non-main # primary vertex. (The primary vertex collection is sorted by # decreasing sum pT^2; the first one in the collection is usually # taken as *the* primary vertex.) CHS is what is meant when the name # "PFnoPileUp" is used. # # typeIMetCorrections = True indicates we want to apply the jet energy # corrections in the MET calculation. from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT = True, postfix = 'PF', runOnMC = runOnMC, pvCollection = cms.InputTag('goodOfflinePrimaryVertices'), jetAlgo = 'AK5', jetCorrections = ('AK5PFchs', jecLevels), typeIMetCorrections = True, ) # Turn on the "top projections". This has nothing to do with top quark # physics, but rather refers to separating sequentially out from the # entire list of PF candidates the ones identified as pileup (from # "wrong" primary vertices), muons, electrons, jets, and taus. The # "No" in each collection name indicates the thing referred to has # been removed. (See the above first set of slides for a example # picture.) The input to the jet clustering is then taken from the
def customisePAT(process, runOnMC, outputModules = []): ## Load PAT process.load("PhysicsTools.PatAlgos.patSequences_cff") ## Apply MVA process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') process.eidMVASequence = cms.Sequence( process.mvaTrigV0 + process.mvaNonTrigV0 ) process.patElectrons.electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0") process.patElectrons.electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0") process.patDefaultSequence.replace( process.patElectrons, process.eidMVASequence * process.patElectrons ) ## Load trigger matching process.load("KrAFT.Configuration.hltFilters_cff") #from PhysicsTools.PatAlgos.tools.trigTools import * #switchOnTriggerMatchEmbedding(process, outputModule="") ## Apply PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT if runOnMC: jecLevels = ['L1FastJet','L2Relative','L3Absolute'] else: jecLevels = ['L1FastJet','L2Relative', 'L3Absolute', 'L2L3Residual'] #usePFBRECO(process,runPFBRECO=True, usePF2PAT(process, runPF2PAT=True, runOnMC=runOnMC, outputModules = outputModules, postfix="PFlow", jetAlgo="AK5", jetCorrections=("AK5PFchs", jecLevels), typeIMetCorrections=True) # top projections in PF2PAT: process.pfNoPileUpPFlow.enable = True process.pfNoMuonPFlow.enable = True process.pfNoElectronPFlow.enable = True process.pfNoTauPFlow.enable = False process.pfNoJetPFlow.enable = True # verbose flags for the PF2PAT modules process.pfNoMuonPFlow.verbose = False # Use non-isolated muons and electrons process.patMuonsPFlow.pfMuonSource = "pfMuonsPFlow" process.patElectronsPFlow.pfElectronSource = "pfElectronsPFlow" # And turn on delta-beta corrections while building pfIsolated*PFlow process.pfIsolatedMuonsPFlow.doDeltaBetaCorrection = True process.pfIsolatedElectronsPFlow.doDeltaBetaCorrection = True # Change DR cone size to 0.3 process.pfIsolatedMuonsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('muPFIsoValueCharged03PFlow')) process.pfIsolatedMuonsPFlow.deltaBetaIsolationValueMap = cms.InputTag('muPFIsoValuePU03PFlow') process.pfIsolatedMuonsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('muPFIsoValueNeutral03PFlow'), cms.InputTag('muPFIsoValueGamma03PFlow'),) process.pfMuonsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('muPFIsoValueCharged03PFlow') ) process.pfMuonsPFlow.deltaBetaIsolationValueMap = cms.InputTag('muPFIsoValuePU03PFlow') process.pfMuonsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('muPFIsoValueNeutral03PFlow'), cms.InputTag('muPFIsoValueGamma03PFlow'),) process.patMuonsPFlow.isolationValues.pfNeutralHadrons = cms.InputTag('muPFIsoValueNeutral03PFlow') process.patMuonsPFlow.isolationValues.pfChargedAll = cms.InputTag('muPFIsoValueChargedAll03PFlow') process.patMuonsPFlow.isolationValues.pfPUChargedHadrons = cms.InputTag('muPFIsoValuePU03PFlow') process.patMuonsPFlow.isolationValues.pfPhotons = cms.InputTag('muPFIsoValueGamma03PFlow') process.patMuonsPFlow.isolationValues.pfChargedHadrons = cms.InputTag('muPFIsoValueCharged03PFlow') process.pfIsolatedElectronsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('elPFIsoValueCharged03PFIdPFlow')) process.pfIsolatedElectronsPFlow.deltaBetaIsolationValueMap = cms.InputTag('elPFIsoValuePU03PFIdPFlow') process.pfIsolatedElectronsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('elPFIsoValueNeutral03PFIdPFlow'), cms.InputTag('elPFIsoValueGamma03PFIdPFlow')) process.pfElectronsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('elPFIsoValueCharged03PFIdPFlow')) process.pfElectronsPFlow.deltaBetaIsolationValueMap = cms.InputTag('elPFIsoValuePU03PFIdPFlow') process.pfElectronsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('elPFIsoValueNeutral03PFIdPFlow'), cms.InputTag('elPFIsoValueGamma03PFIdPFlow')) process.patElectronsPFlow.isolationValues.pfNeutralHadrons = cms.InputTag('elPFIsoValueNeutral03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfChargedAll = cms.InputTag('elPFIsoValueChargedAll03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfPUChargedHadrons = cms.InputTag('elPFIsoValuePU03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfPhotons = cms.InputTag('elPFIsoValueGamma03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfChargedHadrons = cms.InputTag('elPFIsoValueCharged03PFIdPFlow')
def initialise(runOnMC, decayMode, doOutModule=False, doPAT=True): process = cms.Process("KrAFT") process.load("Configuration.StandardSequences.Services_cff") process.load("Configuration.Geometry.GeometryDB_cff") process.load("Configuration.StandardSequences.MagneticField_cff") process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 10000 process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring()) process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") from Configuration.AlCa.autoCond import autoCond if runOnMC: process.GlobalTag.globaltag = autoCond['startup'] else: process.GlobalTag.globaltag = autoCond['com10'] outputModuleForTriggerMatch = "" outputModules = [] if doOutModule: from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string("out.root"), outputCommands = cms.untracked.vstring( 'drop *', 'keep recoPFCandidates_particleFlow_*_*', *patEventContentNoCleaning ) ) process.outPath = cms.EndPath(process.out) outputModuleForTriggerMatch = "out" outputModules.append(process.out) ## Load PAT process.load("PhysicsTools.PatAlgos.patSequences_cff") ## Apply MVA process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') process.eidMVASequence = cms.Sequence( process.mvaTrigV0 + process.mvaNonTrigV0 ) process.patElectrons.electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0") process.patElectrons.electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0") process.patDefaultSequence.replace( process.patElectrons, process.eidMVASequence * process.patElectrons ) ## Load trigger matching process.load("KrAFT.Configuration.hltFilters_cff") #from PhysicsTools.PatAlgos.tools.trigTools import * #switchOnTriggerMatchEmbedding(process, outputModule="") ## Apply PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT if runOnMC: jecLevels = ['L1FastJet','L2Relative','L3Absolute'] else: jecLevels = ['L1FastJet','L2Relative', 'L3Absolute', 'L2L3Residual'] #usePFBRECO(process,runPFBRECO=True, usePF2PAT(process, runPF2PAT=True, runOnMC=runOnMC, outputModules = outputModules, postfix="PFlow", jetAlgo="AK5", jetCorrections=("AK5PFchs", jecLevels), typeIMetCorrections=True) # top projections in PF2PAT: process.pfNoPileUpPFlow.enable = True process.pfNoMuonPFlow.enable = True process.pfNoElectronPFlow.enable = True process.pfNoTauPFlow.enable = False process.pfNoJetPFlow.enable = True # verbose flags for the PF2PAT modules process.pfNoMuonPFlow.verbose = False # Use non-isolated muons and electrons process.patMuonsPFlow.pfMuonSource = "pfMuonsPFlow" process.patElectronsPFlow.pfElectronSource = "pfElectronsPFlow" # And turn on delta-beta corrections while building pfIsolated*PFlow process.pfIsolatedMuonsPFlow.doDeltaBetaCorrection = True process.pfIsolatedElectronsPFlow.doDeltaBetaCorrection = True # Change DR cone size to 0.3 process.pfIsolatedMuonsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('muPFIsoValueCharged03PFlow')) process.pfIsolatedMuonsPFlow.deltaBetaIsolationValueMap = cms.InputTag('muPFIsoValuePU03PFlow') process.pfIsolatedMuonsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('muPFIsoValueNeutral03PFlow'), cms.InputTag('muPFIsoValueGamma03PFlow'),) process.pfMuonsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('muPFIsoValueCharged03PFlow') ) process.pfMuonsPFlow.deltaBetaIsolationValueMap = cms.InputTag('muPFIsoValuePU03PFlow') process.pfMuonsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('muPFIsoValueNeutral03PFlow'), cms.InputTag('muPFIsoValueGamma03PFlow'),) process.patMuonsPFlow.isolationValues.pfNeutralHadrons = cms.InputTag('muPFIsoValueNeutral03PFlow') process.patMuonsPFlow.isolationValues.pfChargedAll = cms.InputTag('muPFIsoValueChargedAll03PFlow') process.patMuonsPFlow.isolationValues.pfPUChargedHadrons = cms.InputTag('muPFIsoValuePU03PFlow') process.patMuonsPFlow.isolationValues.pfPhotons = cms.InputTag('muPFIsoValueGamma03PFlow') process.patMuonsPFlow.isolationValues.pfChargedHadrons = cms.InputTag('muPFIsoValueCharged03PFlow') process.pfIsolatedElectronsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('elPFIsoValueCharged03PFIdPFlow')) process.pfIsolatedElectronsPFlow.deltaBetaIsolationValueMap = cms.InputTag('elPFIsoValuePU03PFIdPFlow') process.pfIsolatedElectronsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('elPFIsoValueNeutral03PFIdPFlow'), cms.InputTag('elPFIsoValueGamma03PFIdPFlow')) process.pfElectronsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('elPFIsoValueCharged03PFIdPFlow')) process.pfElectronsPFlow.deltaBetaIsolationValueMap = cms.InputTag('elPFIsoValuePU03PFIdPFlow') process.pfElectronsPFlow.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag('elPFIsoValueNeutral03PFIdPFlow'), cms.InputTag('elPFIsoValueGamma03PFIdPFlow')) process.patElectronsPFlow.isolationValues.pfNeutralHadrons = cms.InputTag('elPFIsoValueNeutral03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfChargedAll = cms.InputTag('elPFIsoValueChargedAll03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfPUChargedHadrons = cms.InputTag('elPFIsoValuePU03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfPhotons = cms.InputTag('elPFIsoValueGamma03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfChargedHadrons = cms.InputTag('elPFIsoValueCharged03PFIdPFlow') ## Add common filters process.load( "TopQuarkAnalysis.Configuration.patRefSel_goodVertex_cfi" ) process.goodOfflinePrimaryVertices.filter = True process.load( 'TopQuarkAnalysis.Configuration.patRefSel_eventCleaning_cff' ) process.trackingFailureFilter.VertexSource = cms.InputTag('goodOfflinePrimaryVertices') if runOnMC: process.eventCleaning += process.eventCleaningMC else: process.eventCleaning += process.eventCleaningData ## Lepton veto filters for L+J channels process.muonVetoFilter = cms.EDFilter("PATCandViewCountFilter", src = cms.InputTag("selectedPatMuonsPFlow"), maxNumber = cms.uint32(0), minNumber = cms.uint32(0), ) process.electronVetoFilter = cms.EDFilter("PATCandViewCountFilter", src = cms.InputTag("selectedPatElectronsPFlow"), maxNumber = cms.uint32(0), minNumber = cms.uint32(0), ) # event counters process.nEventsTotal = cms.EDProducer("EventCountProducer") process.nEventsClean = cms.EDProducer("EventCountProducer") process.nEventsPAT = cms.EDProducer("EventCountProducer") process.nEventsHLTElEl = cms.EDProducer("EventCountProducer") process.nEventsHLTMuMu = cms.EDProducer("EventCountProducer") process.nEventsHLTMuEl = cms.EDProducer("EventCountProducer") process.nEventsHLTMuJets = cms.EDProducer("EventCountProducer") process.nEventsHLTElJets = cms.EDProducer("EventCountProducer") process.commonFilterSequence = cms.Sequence( process.goodOfflinePrimaryVertices #* process.eventCleaning + process.nEventsClean ) process.patSequenceComplete = cms.Sequence( # + process.patDefaultSequence # + process.patPFBRECOSequencePFlow process.patPF2PATSequencePFlow + process.nEventsPAT ) ## Defile paths if decayMode in ("all", "dilepton", "ElEl", "ee"): process.pElEl = cms.Path( process.nEventsTotal + process.commonFilterSequence + process.hltElEl + process.nEventsHLTElEl ) if doPAT: process.pElEl += process.patSequenceComplete if decayMode in ("all", "dilepton", "MuMu", "mumu"): process.pMuMu = cms.Path( process.nEventsTotal + process.commonFilterSequence + process.hltMuMu + process.nEventsHLTMuMu ) if doPAT: process.pMuMu += process.patSequenceComplete if decayMode in ("all", "dilepton", "MuEl", "emu"): process.pMuEl = cms.Path( process.nEventsTotal + process.commonFilterSequence + process.hltMuEl + process.nEventsHLTMuEl ) if doPAT: process.pMuEl += process.patSequenceComplete if decayMode in ("all", "MuJets"): process.selectedPatMuonsPFlow.cut = 'isPFMuon && (isGlobalMuon || isTrackerMuon) && pt > 10 && abs(eta) < 2.5 && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.selectedPatElectronsPFlow.cut = 'pt > 20 && abs(eta) < 2.5 && electronID("mvaTrigV0") > 0. && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.muonVetoFilter.maxNumber = 1 process.pMuJets = cms.Path( process.nEventsTotal + process.commonFilterSequence + process.hltMuJets + process.nEventsHLTMuJets ) if doPAT: process.pMuJets += process.patSequenceComplete process.pMuJets *= process.muonVetoFilter process.pMuJets += process.electronVetoFilter if runOnMC: process.pMuJets.remove(process.hltMuJets) if decayMode in ("all", "ElJets"): process.selectedPatMuonsPFlow.cut = 'isPFMuon && (isGlobalMuon || isTrackerMuon) && pt > 10 && abs(eta) < 2.5 && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.selectedPatElectronsPFlow.cut = 'pt > 20 && abs(eta) < 2.5 && electronID("mvaTrigV0") > 0. && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.electronVetoFilter.maxNumber = 1 process.pElJets = cms.Path( process.nEventsTotal + process.commonFilterSequence + process.hltElJets + process.nEventsHLTElJets ) if doPAT: process.pElJets += process.patSequenceComplete process.pElJets *= process.muonVetoFilter process.pElJets += process.electronVetoFilter if runOnMC: process.pElJets.remove(process.hltElJets) return process
def loadPF2PAT(process,mcInfo,jetMetCorrections,extMatch,doSusyTopProjection,postfix): #-- PAT standard config ------------------------------------------------------- process.load("PhysicsTools.PatAlgos.patSequences_cff") #-- Jet corrections ----------------------------------------------------------- process.patJetCorrFactors.levels = jetMetCorrections #-- PF2PAT config ------------------------------------------------------------- from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process,runPF2PAT=True, jetAlgo='AK5',runOnMC=(mcInfo==1),postfix=postfix, jetCorrections=('AK5PFchs', jetMetCorrections)) #process.patJetsPF.embedGenJetMatch = False #process.patJetsPF.embedPFCandidates = False #drop tracks process.patElectronsPF.embedTrack = True process.patMuonsPF.embedTrack = True process.electronMatchPF.maxDeltaR = cms.double(0.2) process.electronMatchPF.maxDPtRel = cms.double(999999.) process.electronMatchPF.checkCharge = False process.muonMatchPF.maxDeltaR = cms.double(0.2) process.muonMatchPF.maxDPtRel = cms.double(999999.) process.muonMatchPF.checkCharge = False if extMatch: process.electronMatchPF.mcStatus = cms.vint32(1,5) process.electronMatchPF.matched = "mergedTruth" process.muonMatchPF.mcStatus = cms.vint32(1,5) process.muonMatchPF.matched = "mergedTruth" process.genParticlesForJets.src = "mergedTruth" process.genParticlesForJetsNoMuNoNu.src = "mergedTruth" process.genParticlesForJetsNoNu.src = "mergedTruth" process.patJetPartonMatchPF.matched = "mergedTruth" process.patJetPartonsPF.src = "mergedTruth" process.photonMatchPF.matched = "mergedTruth" #process.tauGenJetsPF.GenParticles = "mergedTruth" #process.tauMatchPF.matched = "mergedTruth" #Remove jet pt cut #process.pfJetsPF.ptMin = 0. #include tau decay mode in pat::Taus (elese it will just be uninitialized) #process.patTausPF.addDecayMode = True #process.patTausPF.decayModeSrc = "shrinkingConePFTauDecayModeProducerPF" # TODO: Fix type I MET #PF type I corrected MET # Temporarily disabled for first 44X recipe -- Benjamin # addPFTypeIMet(process) #Set isolation cone to 0.3 for PF leptons # TODO: fix this for electrons and muons #process.pfElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId")) #process.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId") #process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) #process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId")) #process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId") #process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) #process.pfElectronsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFIdPF")) #process.pfElectronsPF.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFIdPF") #process.pfElectronsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFIdPF"), cms.InputTag("elPFIsoValueGamma03PFIdPF")) #process.pfIsolatedElectronsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFIdPF")) #process.pfIsolatedElectronsPF.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFIdPF") #process.pfIsolatedElectronsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFIdPF"), cms.InputTag("elPFIsoValueGamma03PFIdPF")) #process.pfMuons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03")) #process.pfMuons.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03") #process.pfMuons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03"), cms.InputTag("muPFIsoValueGamma03")) #process.pfIsolatedMuons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03")) #process.pfIsolatedMuons.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03") #process.pfIsolatedMuons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03"), cms.InputTag("muPFIsoValueGamma03")) #process.pfMuonsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03PF")) #process.pfMuonsPF.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03PF") #process.pfMuonsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03PF"), cms.InputTag("muPFIsoValueGamma03PF")) #process.pfIsolatedMuonsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03PF")) #process.pfIsolatedMuonsPF.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03PF") #process.pfIsolatedMuonsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03PF"), cms.InputTag("muPFIsoValueGamma03PF")) #-- Enable pileup sequence ------------------------------------------------------------- #Vertices process.goodVertices = cms.EDFilter("VertexSelector", src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"), filter = cms.bool(False), ) process.pfPileUpPF.Vertices = "goodVertices" process.pfPileUpPF.Enable = True process.pfNoPileUpSequencePF.replace(process.pfPileUpPF, process.goodVertices + process.pfPileUpPF) if not doSusyTopProjection: return #-- Top projection selection ----------------------------------------------------------- #Electrons #relax all selectors *before* pat-lepton creation process.pfElectronsFromVertexPF.dzCut = 9999.0 process.pfElectronsFromVertexPF.d0Cut = 9999.0 process.pfSelectedElectronsPF.cut = "" process.pfRelaxedElectronsPF = process.pfIsolatedElectronsPF.clone(isolationCut = 3.) process.pfIsolatedElectronsPF.isolationCut = 0.15 process.pfElectronsFromGoodVertex = cms.EDFilter( "IPCutPFCandidateSelector", src = cms.InputTag("pfIsolatedElectronsPF"), # PFCandidate source vertices = cms.InputTag("goodVertices"), # vertices source d0Cut = cms.double(0.04), # transverse IP dzCut = cms.double(1.), # longitudinal IP d0SigCut = cms.double(99.), # transverse IP significance dzSigCut = cms.double(99.), # longitudinal IP significance ) electronSelection = "abs( eta ) < 2.5 & pt > 5" electronSelection += " & mva_e_pi > 0.4" # same as patElectron::mva() #electronSelection += " & (isEB & (sigmaIetaIeta < 0.024 & hadronicOverEm < 0.15) | isEE & (sigmaIetaIeta < 0.040 & hadronicOverEm < 0.10))" #caloIdVL #electronSelection += " & (isEB & (deltaPhiSuperClusterTrackAtVtx < 0.15 & deltaEtaSuperClusterTrackAtVtx < 0.01) | isEE & (deltaPhiSuperClusterTrackAtVtx < 0.10 & deltaEtaSuperClusterTrackAtVtx < 0.01))" #trkIdVL electronSelection += " & gsfTrackRef().isNonnull() & gsfTrackRef().trackerExpectedHitsInner().numberOfHits() <= 0" process.pfUnclusteredElectronsPF = cms.EDFilter( "GenericPFCandidateSelector", src = cms.InputTag("pfElectronsFromGoodVertex"), #pfSelectedElectronsPF cut = cms.string(electronSelection) ) process.pfElectronSequencePF.replace(process.pfIsolatedElectronsPF, process.pfIsolatedElectronsPF + process.goodVertices * process.pfElectronsFromGoodVertex + process.pfUnclusteredElectronsPF + process.pfRelaxedElectronsPF) process.patElectronsPF.pfElectronSource = "pfRelaxedElectronsPF" process.pfNoElectronPF.topCollection = "pfUnclusteredElectronsPF" #Muons #relaxe built-in preselection process.pfMuonsFromVertexPF.dzCut = 9999.0 process.pfMuonsFromVertexPF.d0Cut = 9999.0 process.pfSelectedMuonsPF.cut = "" process.pfRelaxedMuonsPF = process.pfIsolatedMuonsPF.clone(isolationCut = 3) process.pfIsolatedMuonsPF.isolationCut = 0.15 process.pfMuonsFromGoodVertex = cms.EDFilter( "IPCutPFCandidateSelector", src = cms.InputTag("pfIsolatedMuonsPF"), # PFCandidate source vertices = cms.InputTag("goodVertices"), # vertices source d0Cut = cms.double(0.02), # transverse IP dzCut = cms.double(1.), # longitudinal IP d0SigCut = cms.double(99.), # transverse IP significance dzSigCut = cms.double(99.), # longitudinal IP significance ) muonSelection = "abs( eta ) < 2.5 & pt > 5" #GlobalMuonPromptTight muonSelection += " & muonRef().isNonnull & muonRef().isGlobalMuon()" muonSelection += " & muonRef().isTrackerMuon() & muonRef().numberOfMatches > 1" muonSelection += " & muonRef().globalTrack().normalizedChi2() < 10" muonSelection += " & muonRef().track().numberOfValidHits() > 10" muonSelection += " & muonRef().globalTrack().hitPattern().numberOfValidMuonHits() > 0" muonSelection += " & muonRef().innerTrack().hitPattern().numberOfValidPixelHits() > 0" process.pfUnclusteredMuonsPF = cms.EDFilter( "GenericPFCandidateSelector", src = cms.InputTag("pfMuonsFromGoodVertex"), #pfSelectedMuonsPF cut = cms.string(muonSelection) ) process.pfMuonSequencePF.replace(process.pfIsolatedMuonsPF, process.pfIsolatedMuonsPF + process.goodVertices * process.pfMuonsFromGoodVertex + process.pfUnclusteredMuonsPF + process.pfRelaxedMuonsPF) process.patMuonsPF.pfMuonSource = "pfRelaxedMuonsPF" process.pfNoMuonPF.topCollection = "pfUnclusteredMuonsPF"
# subtraction (CHS) applied. The latter is used to identify and remove # particles from pileup, by associating their tracks with the non-main # primary vertex. (The primary vertex collection is sorted by # decreasing sum pT^2; the first one in the collection is usually # taken as *the* primary vertex.) CHS is what is meant when the name # "PFnoPileUp" is used. # # typeIMetCorrections = True indicates we want to apply the jet energy # corrections in the MET calculation. from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT( process, runPF2PAT=True, postfix='PF', runOnMC=runOnMC, pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), jetAlgo='AK5', jetCorrections=('AK5PFchs', jecLevels), typeIMetCorrections=True, ) # Turn on the "top projections". This has nothing to do with top quark # physics, but rather refers to separating sequentially out from the # entire list of PF candidates the ones identified as pileup (from # "wrong" primary vertices), muons, electrons, jets, and taus. The # "No" in each collection name indicates the thing referred to has # been removed. (See the above first set of slides for a example # picture.) The input to the jet clustering is then taken from the # pfNoTauPF -> pfJetsPF collection. process.pfNoPileUpPF.enable = True
#switchOnTrigger(process) #create pat trigger objects #process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") #removeMCMatching(process, ['All']) from PhysicsTools.PatAlgos.tools.jetTools import * from PhysicsTools.PatAlgos.tools import pfTools jetCorrFactors = cms.vstring( 'L1FastJet', 'L2Relative', 'L3Absolute' ) pfTools.usePF2PAT( process, runPF2PAT = True, jetAlgo = 'AK5', jetCorrections = ( 'AK5PFchs', jetCorrFactors, "" ), #jetCorrections = ['L1FastJet', 'L2Relative', 'L3Absolute'], runOnMC = runOnMC, postfix = "PFlow", pvCollection = cms.InputTag( 'goodOfflinePrimaryVertices' ), outputModules = [] ) #switchJetCollection( # process, # cms.InputTag('ak5PFJets') # #doJTA = True # #doBTagging = True # #jetCorrLabel = _jetCorrections, # #doType1MET = False, # #doJetID = True, # #jetIdLabel = "ak5" #)
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1)) process.out.fileName = cms.untracked.string( os.path.expandvars('/tmp/${USER}/patTuple_PATandPF2PAT.root')) # load the PAT config process.load("PhysicsTools.PatAlgos.patSequences_cff") process.load('CMGTools.ZmumuJetsTutorial.patTriggerMatching_cff') #run PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT postfix = "PFlow" usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", runOnMC=runOnMC, postfix=postfix) # a loose offline muon selection process.patMuonSelector = cms.EDFilter( "PATMuonSelector", src=cms.InputTag('patMuonsPFlow'), cut=cms.string("pt >= 10 && abs(eta) < 2.4")) # we require 2 muons process.patMuonFilter = cms.EDFilter("CandViewCountFilter", src=cms.InputTag('patMuonSelector'), minNumber=cms.uint32(2)) process.dimuonSkim = cms.Sequence(process.patMuonSelector + process.patMuonFilter)
numberOfFiles = 10 ) ) ) process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) process.out.fileName = cms.untracked.string(os.path.expandvars('/tmp/${USER}/patTuple_PATandPF2PAT.root')) # load the PAT config process.load("PhysicsTools.PatAlgos.patSequences_cff") process.load('CMGTools.ZmumuJetsTutorial.patTriggerMatching_cff') #run PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT postfix = "PFlow" usePF2PAT(process,runPF2PAT=True, jetAlgo="AK5", runOnMC=runOnMC, postfix=postfix) # a loose offline muon selection process.patMuonSelector = cms.EDFilter("PATMuonSelector", src = cms.InputTag('patMuonsPFlow'), cut =cms.string("pt >= 10 && abs(eta) < 2.4") ) # we require 2 muons process.patMuonFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag('patMuonSelector'), minNumber = cms.uint32(2) ) process.dimuonSkim = cms.Sequence(process.patMuonSelector+process.patMuonFilter) #this is used for bookeeping process.load("CMGTools.Common.countingSequences_cff")
def addPF2PATNoTauJets(process, mcInfo=True, jetCorrections=["L2Relative", "L3Absolute"]): ##Add the PF2PAT-no-tau-cleaning jet collection : postfix = PFLOW ##-- PAT standard config ------------------------------------------------------- # process.load("PhysicsTools.PatAlgos.patSequences_cff") ##-- Jet corrections ----------------------------------------------------------- # process.patJetCorrFactors.levels = options.jetCorrections from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT # -- PF2PAT config ------------------------------------------------------------- usePF2PAT( process, runPF2PAT=True, jetAlgo="AK5", runOnMC=(mcInfo == 1), postfix="PFLOW", jetCorrections=("AK5PFchs", jetCorrections), ) from PhysicsTools.PatAlgos.tools.pfTools import switchToPFJets switchToPFJets( process, cms.InputTag("pfJets" + "PFLOW"), "AK5", postfix="PFLOW", jetCorrections=("AK5PFchs", jetCorrections) ) process.patJetsPFLOW.addTagInfos = cms.bool(True) process.patJetsPFLOW.tagInfoSources = cms.VInputTag("secondaryVertexTagInfosAODPFLOW") if "L1FastJet" in jetCorrections: process.pfJetsPFLOW.doAreaFastjet = True # from JetMETCorrections.Type1MET.MetType1Corrections_cff import metJESCorAK5PFJet # process.metJESCorAK5PFLOWTypeI = metJESCorAK5PFJet.clone( # inputUncorJetsLabel = "patJetsPFLOW", # metType = "pat", # inputUncorMetLabel = "pfMet", # ) # process.patMETsTypeIPFLOW = process.patMETsPFLOW.clone( # metSource = cms.InputTag("metJESCorAK5PFLOWTypeI") # ) ## Add to producersLayer1 sequence ##process.patDefaultSequencePFLOW.replace( # process.patPF2PATSequencePFLOW.replace( # process.patMETsPFLOW, # process.patMETsPFLOW+ # process.metJESCorAK5PFLOWTypeI+ # process.patMETsTypeIPFLOW # ) # Set isolation cone to 0.3 process.isoValElectronWithChargedPFLOW.deposits[0].deltaR = 0.3 process.isoValElectronWithNeutralPFLOW.deposits[0].deltaR = 0.3 process.isoValElectronWithPhotonsPFLOW.deposits[0].deltaR = 0.3 process.isoValMuonWithChargedPFLOW.deposits[0].deltaR = 0.3 process.isoValMuonWithNeutralPFLOW.deposits[0].deltaR = 0.3 process.isoValMuonWithPhotonsPFLOW.deposits[0].deltaR = 0.3 # -- Enable pileup sequence ------------------------------------------------------------- # Vertices process.goodVerticesPFLOW = cms.EDFilter( "VertexSelector", src=cms.InputTag("offlinePrimaryVertices"), cut=cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"), filter=cms.bool(False), ) process.pfPileUpPFLOW.Vertices = "goodVerticesPFLOW" process.pfPileUpPFLOW.Enable = True process.pfNoPileUpSequencePFLOW.replace(process.pfPileUpPFLOW, process.goodVerticesPFLOW + process.pfPileUpPFLOW)
#addMETCollection(process, labelName='patMETsTypeIcorrected', metSource='pfType1CorrectedMet') #addMETCollection(process, labelName='patMETTC', metSource='tcMet') runOnMC=True # An empty postfix means that only PF2PAT is run, # otherwise both standard PAT and PF2PAT are run. In the latter case PF2PAT # collections have standard names + postfix (e.g. patElectronPFlow) postfix = "" jetAlgo = "AK5" #Define Objects to be excluded from Top Projection. Default is Tau, so objects are not cleaned for taus excludeFromTopProjection=['Tau'] # Configure PAT to use PF2PAT instead of AOD sources # this function will modify the PAT sequences. from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=postfix, excludeFromTopProjection=excludeFromTopProjection) #from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection #from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection ## uncomment the following lines to add ak5PFJetsCHS to your PAT output #postfixAK5PFCHS = 'Copy' #addJetCollection( # process, # postfix = postfixAK5PFCHS, # labelName = 'AK5PFCHS', # jetSource = cms.InputTag('ak5PFJetsCHS'), # jetCorrections = ('AK5PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-2') #) #process.out.outputCommands.append( 'drop *_selectedPatJetsAK5PFCHS%s_caloTowers_*'%( postfixAK5PFCHS ) )
## Create and define reco objects if runOnAOD: muonTag = 'patMuons' + pfpostfix metTag = 'patMETs' + pfpostfix ## Output module for edm files (needed for PAT sequence, even if not used in EndPath) from Configuration.EventContent.EventContent_cff import FEVTEventContent process.out = cms.OutputModule("PoolOutputModule", FEVTEventContent, dataset = cms.untracked.PSet(dataTier = cms.untracked.string('RECO')), fileName = cms.untracked.string("eh.root"), ) # add particle flow process.load("PhysicsTools.PatAlgos.patSequences_cff") from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT=True, jetAlgo='AK4', runOnMC=runOnMC, postfix=pfpostfix, jetCorrections=jetCorr, pvCollection=cms.InputTag(opt.primaryVertexOptions['outputCollection']),typeIMetCorrections=True) getattr(process, 'pfPileUp'+pfpostfix).checkClosestZVertex = False # switch off all top projections getattr(process,'pfNoMuon'+pfpostfix).enable = False getattr(process,'pfNoElectron'+pfpostfix).enable = False getattr(process,'pfNoJet'+pfpostfix).enable = False getattr(process,'pfNoTau'+pfpostfix).enable = False # agrohsje don't require isolation on cmsRun level !!! # seems not to work -> check with python -i ? getattr(process,'pfIsolatedElectrons'+pfpostfix).isolationCut = cms.double(999999.) getattr(process,'pfIsolatedMuons'+pfpostfix).isolationCut = cms.double(999999.) else :
if useL3Absolute: jecLevels.append( 'L3Absolute' ) if useL2L3Residual and not runOnMC: jecLevels.append( 'L2L3Residual' ) if useL5Flavor: jecLevels.append( 'L5Flavor' ) if useL7Parton: jecLevels.append( 'L7Parton' ) ### Switch configuration import PhysicsTools.PatAlgos.tools.pfTools as pfTools pfTools.usePF2PAT( process , runPF2PAT = True #runPF2PAT , runOnMC = runOnMC , jetAlgo = patRefSel_refMuJets.jetAlgo , postfix = postfix , jetCorrections = ( jecSetPF , jecLevels ) ) pfTools.adaptPFTaus( process, tauType='hpsPFTau', postfix=postfix ) pfTools.applyPostfix( process, 'pfNoPileUp' , postfix ).enable = usePFnoPU pfTools.applyPostfix( process, 'pfNoMuon' , postfix ).enable = useNoMuon pfTools.applyPostfix( process, 'pfNoElectron', postfix ).enable = useNoElectron pfTools.applyPostfix( process, 'pfNoJet' , postfix ).enable = useNoJet pfTools.applyPostfix( process, 'pfNoTau' , postfix ).enable = useNoTau pfTools.applyPostfix( process, 'pfPileUp', postfix ).Vertices = cms.InputTag( patRefSel_refMuJets.pfVertices ) if useL1FastJet: pfTools.applyPostfix( process, 'pfPileUp' , postfix ).checkClosestZVertex = False pfTools.applyPostfix( process, 'pfPileUpIso', postfix ).checkClosestZVertex = usePfIsoLessCHS
if useL7Parton: jecLevels.append( 'L7Parton' ) ### Switch configuration if runPF2PAT: if useMuonCutBasePF: pfMuonSelectionCut += ' && %s'%( muonCutBase ) if useElectronCutBasePF: pfElectronSelectionCut += ' && %s'%( electronCutBase ) from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT( process , runPF2PAT = runPF2PAT , runOnMC = runOnMC , jetAlgo = jetAlgo , postfix = postfix , jetCorrections = ( jecSetPF , jecLevels ) ) applyPostfix( process, 'pfNoPileUp' , postfix ).enable = usePFnoPU applyPostfix( process, 'pfNoMuon' , postfix ).enable = useNoMuon applyPostfix( process, 'pfNoElectron', postfix ).enable = useNoElectron applyPostfix( process, 'pfNoJet' , postfix ).enable = useNoJet applyPostfix( process, 'pfNoTau' , postfix ).enable = useNoTau applyPostfix( process, 'pfPileUp', postfix ).Vertices = cms.InputTag( pfVertices ) if useL1FastJet: applyPostfix( process, 'pfPileUp', postfix ).checkClosestZVertex = False applyPostfix( process, 'pfJets', postfix ).doAreaFastjet = True applyPostfix( process, 'pfJets', postfix ).doRhoFastjet = False applyPostfix( process, 'pfMuonsFromVertex' , postfix ).vertices = cms.InputTag( pfVertices )
## Load trigger matching ## Trigger matching with PAT process.load("MuonAnalysis.MuonAssociators.patMuonsWithTrigger_cff") process.muonMatchHLTL2.maxDeltaR = 0.3 # Zoltan tuning - it was 0.5 process.muonMatchHLTL3.maxDeltaR = 0.1 ## Apply PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT if runOnMC: jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] else: jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual'] #usePFBRECO(process,runPFBRECO=True, usePF2PAT(process, runPF2PAT=True, runOnMC=runOnMC, outputModules=outputModules, postfix="PFlow", jetAlgo="AK5", jetCorrections=("AK5PFchs", jecLevels), typeIMetCorrections=True) # top projections in PF2PAT: process.pfNoPileUpPFlow.enable = True process.pfNoMuonPFlow.enable = True process.pfNoElectronPFlow.enable = True process.pfNoTauPFlow.enable = False process.pfNoJetPFlow.enable = True # verbose flags for the PF2PAT modules process.pfNoMuonPFlow.verbose = False """ # Change DR cone size to 0.3
def pat_tuple_process(runOnMC=True, suppress_stdout=True): process = cms.Process('PAT') process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(100)) process.source = cms.Source('PoolSource', fileNames = cms.untracked.vstring('/store/mc/Summer12_DR53X/TTJets_HadronicMGDecays_8TeV-madgraph/AODSIM/PU_S10_START53_V7A-v1/00001/FCAF3F92-5A16-E211-ACCC-E0CB4E19F95A.root' if runOnMC else '/store/data/Run2012B/MultiJet1Parked/AOD/05Nov2012-v2/10000/0003D331-5C49-E211-8210-00259020081C.root')) process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(False)) process.load('FWCore.MessageLogger.MessageLogger_cfi') process.MessageLogger.cerr.FwkReport.reportEvery = 1000000 process.MessageLogger.cerr.threshold = 'INFO' process.MessageLogger.categories.append('PATSummaryTables') process.MessageLogger.cerr.PATSummaryTables = cms.untracked.PSet(limit = cms.untracked.int32(-1)) for category in ['TwoTrackMinimumDistance']: process.MessageLogger.categories.append(category) setattr(process.MessageLogger.cerr, category, cms.untracked.PSet(limit=cms.untracked.int32(0))) process.load('Configuration.Geometry.GeometryIdeal_cff') process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag = 'START53_V27::All' if runOnMC else 'FT53_V21A_AN6::All' from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent process.out = cms.OutputModule('PoolOutputModule', fileName = cms.untracked.string('pat.root'), SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('p')), outputCommands = cms.untracked.vstring(*patEventContent), ) process.outp = cms.EndPath(process.out) process.load('JMTucker.Tools.PATTupleSelection_cfi') # Event cleaning, with MET cleaning recommendations from # https://twiki.cern.ch/twiki/bin/view/CMS/MissingETOptionalFilters process.load('HLTrigger.special.hltPhysicsDeclared_cfi') process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis' from DPGAnalysis.Skims.goodvertexSkim_cff import noscraping as FilterOutScraping process.FilterOutScraping = FilterOutScraping process.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi') process.goodOfflinePrimaryVertices.filter = cms.bool(True) process.load('RecoMET.METFilters.metFilters_cff') process.trackingFailureFilter.VertexSource = 'goodOfflinePrimaryVertices' # Instead of filtering out events at tupling time, schedule separate # paths for all the "good data" filters so that the results of them # get stored in a small TriggerResults::PAT object, which can be # accessed later. Make one path for each so they can be accessed # separately in the TriggerResults object; the "All" path that is the # product of all of the filters isn't necessary but it's nice for # convenience. process.eventCleaningAll = cms.Path() for name in process.jtupleParams.eventFilters.value(): negate = name.startswith('~') name = name.replace('~', '') filter_obj = getattr(process, name) if negate: filter_obj = ~filter_obj setattr(process, 'eventCleaning' + name, cms.Path(filter_obj)) process.eventCleaningAll *= filter_obj ################################################################################ # PAT/PF2PAT configuration inspired by TopQuarkAnalysis/Configuration # (test/patRefSel_allJets_cfg.py and included modules) with tag # V07-00-01. # First, turn off stdout so that the spam from PAT/PF2PAT doesn't # flood the screen (especially useful in batch job submission). if suppress_stdout: print 'tuple.py: PAT would spam a lot of stuff to stdout... hiding it.' from cStringIO import StringIO old_stdout = sys.stdout sys.stdout = buf = StringIO() jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not runOnMC: jecLevels.append('L2L3Residual') #jecLevels += ['L5Flavor', 'L7Parton'] postfix = 'PF' def processpostfix(name): return getattr(process, name + postfix) def setprocesspostfix(name, obj): setattr(process, name + postfix, obj) def InputTagPostFix(name): return cms.InputTag(name + postfix) process.load('PhysicsTools.PatAlgos.patSequences_cff') from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT = True, runOnMC = runOnMC, jetAlgo = 'AK5', postfix = postfix, jetCorrections = ('AK5PFchs', jecLevels), # 'chs': using PFnoPU typeIMetCorrections = True, pvCollection = cms.InputTag('goodOfflinePrimaryVertices'), ) processpostfix('pfNoPileUp') .enable = True # usePFnoPU processpostfix('pfNoMuon') .enable = True # useNoMuon processpostfix('pfNoElectron').enable = True # useNoElectron processpostfix('pfNoJet') .enable = True # useNoJet processpostfix('pfNoTau') .enable = True # useNoTau processpostfix('pfPileUp').checkClosestZVertex = False processpostfix('pfPileUpIso').checkClosestZVertex = False processpostfix('pfMuonsFromVertex').d0Cut = processpostfix('pfElectronsFromVertex').d0Cut = 2 processpostfix('pfMuonsFromVertex').dzCut = processpostfix('pfElectronsFromVertex').dzCut = 2 processpostfix('pfSelectedMuons').cut = 'pt > 5.' #processpostfix('pfSelectedMuons').cut += process.jtupleParams.muonCut processpostfix('pfIsolatedMuons').isolationCut = 0.2 if False: # pfMuonIsoConeR03 processpostfix('pfIsolatedMuons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('muPFIsoValueCharged03')) processpostfix('pfIsolatedMuons').deltaBetaIsolationValueMap = InputTagPostFix('muPFIsoValuePU03') processpostfix('pfIsolatedMuons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('muPFIsoValueNeutral03'), InputTagPostFix('muPFIsoValueGamma03')) processpostfix('pfMuons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('muPFIsoValueCharged03')) processpostfix('pfMuons').deltaBetaIsolationValueMap = InputTagPostFix('muPFIsoValuePU03') processpostfix('pfMuons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('muPFIsoValueNeutral03'), InputTagPostFix('muPFIsoValueGamma03')) processpostfix('patMuons').isolationValues.pfNeutralHadrons = InputTagPostFix('muPFIsoValueNeutral03') processpostfix('patMuons').isolationValues.pfChargedAll = InputTagPostFix('muPFIsoValueChargedAll03') processpostfix('patMuons').isolationValues.pfPUChargedHadrons = InputTagPostFix('muPFIsoValuePU03') processpostfix('patMuons').isolationValues.pfPhotons = InputTagPostFix('muPFIsoValueGamma03') processpostfix('patMuons').isolationValues.pfChargedHadrons = InputTagPostFix('muPFIsoValueCharged03') processpostfix('pfSelectedElectrons').cut = 'pt > 5. && gsfTrackRef.isNonnull && gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits < 2' #processpostfix('pfSelectedElectrons').cut += ' && ' + process.jtupleParams.electronCut # disabled by default, but can use minimal (veto) electron selection cut on top of pfElectronSelectionCut processpostfix('pfIsolatedElectrons').isolationCut = 0.2 if True: # pfElectronIsoConeR03 processpostfix('pfIsolatedElectrons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('elPFIsoValueCharged03PFId')) processpostfix('pfIsolatedElectrons').deltaBetaIsolationValueMap = InputTagPostFix('elPFIsoValuePU03PFId') processpostfix('pfIsolatedElectrons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('elPFIsoValueNeutral03PFId'), InputTagPostFix('elPFIsoValueGamma03PFId')) processpostfix('pfElectrons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('elPFIsoValueCharged03PFId')) processpostfix('pfElectrons').deltaBetaIsolationValueMap = InputTagPostFix('elPFIsoValuePU03PFId') processpostfix('pfElectrons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('elPFIsoValueNeutral03PFId'), InputTagPostFix('elPFIsoValueGamma03PFId')) processpostfix('patElectrons').isolationValues.pfNeutralHadrons = InputTagPostFix('elPFIsoValueNeutral03PFId') processpostfix('patElectrons').isolationValues.pfChargedAll = InputTagPostFix('elPFIsoValueChargedAll03PFId') processpostfix('patElectrons').isolationValues.pfPUChargedHadrons = InputTagPostFix('elPFIsoValuePU03PFId') processpostfix('patElectrons').isolationValues.pfPhotons = InputTagPostFix('elPFIsoValueGamma03PFId') processpostfix('patElectrons').isolationValues.pfChargedHadrons = InputTagPostFix('elPFIsoValueCharged03PFId') process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') processpostfix('patElectrons').electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0") processpostfix('patElectrons').electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0") processpostfix('patMuons').embedTrack = True processpostfix('patJets').addTagInfos = True processpostfix('selectedPatElectrons').cut = process.jtupleParams.electronCut processpostfix('selectedPatMuons').cut = process.jtupleParams.muonCut processpostfix('selectedPatJets').cut = process.jtupleParams.jetCut process.load('CMGTools.External.pujetidsequence_cff') for x in (process.puJetId, process.puJetMva, process.puJetIdChs, process.puJetMvaChs): x.jets = InputTagPostFix('selectedPatJets') # fix bug in V00-03-04 of CMGTools/External if hasattr(x, 'algos'): bad, good = 'RecoJets/JetProducers', 'CMGTools/External' for ps in x.algos: if hasattr(ps, 'tmvaWeights'): s = ps.tmvaWeights.value() if s.startswith(bad): ps.tmvaWeights = s.replace(bad, good) from PhysicsTools.PatAlgos.tools.coreTools import runOnData, removeSpecificPATObjects if not runOnMC: runOnData(process, names = ['All'], postfix = postfix) removeSpecificPATObjects(process, names = ['Photons'], postfix = postfix) # will also remove cleaning # Make some extra SV producers for MFV studies. JMTBAD postfix junk for cut in (1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.): cut_name = ('%.1f' % cut).replace('.', 'p') tag_info_name = 'secondaryVertexMaxDR%sTagInfosAODPF' % cut_name tag_info_obj = process.secondaryVertexTagInfosAODPF.clone() tag_info_obj.vertexCuts.maxDeltaRToJetAxis = cut setattr(process, tag_info_name, tag_info_obj) process.patJetsPF.tagInfoSources.append(cms.InputTag(tag_info_name)) processpostfix('patPF2PATSequence').replace(processpostfix('patJets'), tag_info_obj * processpostfix('patJets')) from JMTucker.Tools.PATTupleSelection_cfi import makeLeptonProducers makeLeptonProducers(process, postfix=postfix, params=process.jtupleParams) common_seq = cms.ignore(process.goodOfflinePrimaryVertices) + cms.ignore(process.mvaTrigV0) + cms.ignore(process.mvaNonTrigV0) + processpostfix('patPF2PATSequence') + process.puJetIdSqeuenceChs process.load('JMTucker.MFVNeutralino.Vertexer_cff') common_seq *= process.mfvVertices # Require numbers of jets based on the trigger: hadronic channel will # have at least a 4-jet trigger (maybe 6!), while semileptonic uses a # 3-jet trigger. Dileptonic has no jets in trigger, but we'll require # at least one b-tag anyway. setprocesspostfix('countPatJetsHadronic', processpostfix('countPatJets').clone(minNumber = 4)) setprocesspostfix('countPatJetsSemileptonic', processpostfix('countPatJets').clone(minNumber = 3)) setprocesspostfix('countPatJetsDileptonic', processpostfix('countPatJets').clone(minNumber = 1)) channels = ('Hadronic', 'Semileptonic', 'Dileptonic') for channel in channels: setattr(process, 'p' + channel, cms.Path(common_seq)) process.pHadronic *= processpostfix('countPatJetsHadronic') process.pSemileptonic *= processpostfix('countPatJetsSemileptonic') + process.jtupleSemileptonSequence + process.countSemileptons process.pDileptonic *= processpostfix('countPatJetsDileptonic') + process.jtupleDileptonSequence + process.countDileptons process.out.SelectEvents.SelectEvents = ['p' + channel for channel in channels] process.out.outputCommands = [ 'drop *', 'keep *_selectedPatElectrons*_*_*', 'keep *_selectedPatMuons*_*_*', 'keep *_selectedPatJets*_*_*', 'drop *_selectedPatJetsForMETtype1p2CorrPF_*_*', 'drop *_selectedPatJetsForMETtype2CorrPF_*_*', 'keep *_mfvVertices*_*_*', 'drop CaloTowers_*_*_*', 'keep *_patMETs*_*_*', 'keep *_goodOfflinePrimaryVertices_*_*', 'keep edmTriggerResults_TriggerResults__PAT', # for post-tuple filtering on the goodData paths 'keep *_puJet*_*_*', ] # The normal TrigReport doesn't state how many events are written # total to the file in case of OutputModule's SelectEvents having # multiple paths. Add a summary to stdout that so that it is easy to # see what the total number of events should be (for debugging CRAB # jobs). (This means we can kill the normal TrigReport.) process.ORTrigReport = cms.EDAnalyzer('ORTrigReport', results_src = cms.InputTag('TriggerResults', '', process.name_()), paths = process.out.SelectEvents.SelectEvents ) process.pORTrigReport = cms.EndPath(process.ORTrigReport) # Must be on an EndPath. # As a simple check of the paths' efficiencies, add some lines to the # summary showing stats on events with generator-level muons/electrons # in acceptance from W decays. if runOnMC: for name, cut in [('Muon', 'abs(pdgId) == 13 && abs(eta) < 2.4 && abs(mother.pdgId) == 24 && pt > 20'), ('Electron', 'abs(pdgId) == 11 && abs(eta) < 2.5 && abs(mother.pdgId) == 24 && pt > 20'), ('Lepton', '((abs(pdgId) == 13 && abs(eta) < 2.4) || (abs(pdgId) == 11 && abs(eta) < 2.5)) && abs(mother.pdgId) == 24 && pt > 20'), ]: name = 'gen' + name + 's' filter = cms.EDFilter('CandViewSelector', src = cms.InputTag('genParticles'), cut = cms.string(cut)) counter = cms.EDFilter('CandViewCountFilter', src = cms.InputTag(name), minNumber = cms.uint32(1)) setattr(process, name, filter) setattr(process, name + 'Count', counter) setattr(process, 'p' + name + 'Count', cms.Path(filter*counter)) # Check that the stdout spam from PAT was what we expect. if suppress_stdout: pat_output = buf.getvalue() sys.stdout = old_stdout buf.close() hsh = hash(pat_output) #open('pat_spam.txt', 'wt').write(pat_output) hsh_expected = 6563257886911239637 if runOnMC else 3125511795667431709 print 'PAT is done (spam hash %s, expected %s).' % (hsh, hsh_expected) if hsh != hsh_expected: from JMTucker.Tools.general import big_warn big_warn('Unexpected spam hash! Did you change an option?') return process, common_seq
def createProcess(isMC, globalTag): import FWCore.ParameterSet.Config as cms ##### # Init the process with some default options ##### process = cms.Process("PAT") ## MessageLogger process.load("FWCore.MessageLogger.MessageLogger_cfi") ## Options and Output Report process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True), allowUnscheduled = cms.untracked.bool(True) ) ## Source process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring() ) ## Maximal Number of Events process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) ## Geometry and Detector Conditions (needed for a few patTuple production steps) process.load("Configuration.Geometry.GeometryIdeal_cff") process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") process.GlobalTag.globaltag = cms.string("%s::All" % globalTag) process.load("Configuration.StandardSequences.MagneticField_cff") ## Output Module Configuration (expects a path 'p') from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('patTuple.root'), ## save only events passing the full path #SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), ## save PAT output; you need a '*' to unpack the list of commands ## 'patEventContent' outputCommands = cms.untracked.vstring('drop *', *patEventContentNoCleaning ) ) process.outpath = cms.EndPath(process.out) ##### # Customize process for top pat Tuples production ##### print("Loading python config...") #process.load("PhysicsTools.PatAlgos.patSequences_cff") process.primaryVertexFilter = cms.EDFilter("VertexSelector", src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string("!isFake & ndof > 4 & abs(z) <= 24 & position.Rho <= 2"), filter = cms.bool(True) ) process.goodOfflinePrimaryVertices = cms.EDFilter("PrimaryVertexObjectFilter", filterParams = cms.PSet(minNdof = cms.double(4.), maxZ = cms.double(24.) , maxRho = cms.double(2.)), filter = cms.bool(True), src = cms.InputTag('offlinePrimaryVertices') ) from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT, adaptPFIsoElectrons postfix = "PFlow" jetAlgo = "AK5" # Jet corrections when using CHS (L2L3Residual IS mandatory on data) if isMC: jetCorrections = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'] ) else: jetCorrections = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual'] ) # Jet corrections when NOT using CHS #jetCorrections = ('AK5PF', ['L1FastJet','L2Relative','L3Absolute'] ) # Type I MET enabled usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=isMC , postfix=postfix, jetCorrections = jetCorrections, typeIMetCorrections=True, pvCollection = cms.InputTag('goodOfflinePrimaryVertices')) # We want: # - Uncorrected MEt: patMETsRawPFlow # - Type I corrected MEt: patMETsPFlow # - Type 0+I correct MEt: patMETsType0p1PFlow # Create PAT MEt from raw MEt collection (pfMET<postfix>)) setattr(process, "patMETsRaw%s" % postfix, getattr(process, "patMETs%s" % postfix).clone( metSource = cms.InputTag("pfMET%s" % (postfix)) )) # Type 0, 1 or 2 corrected MEt is produced by the module CorrectedPFMETProducer # Clone the module <jetcorrectorlabel>Type1CorMet<postfix> (eg, AK5PFchschsTypeICorMetPFlow), # to create a Type 0 + I MEt setattr(process, "%sType0p1CorMet%s" % (jetCorrections[0], postfix), getattr(process, "%sType1CorMet%s" % (jetCorrections[0], postfix)).clone( applyType0Corrections = cms.bool(True), srcCHSSums = cms.VInputTag("pfchsMETcorr%s:type0" % postfix) )) # Now, convert the PF met to patMET. Clone patMETs<postfix> setattr(process, "patMETsType0p1%s" % postfix, getattr(process, "patMETs%s" % postfix).clone( metSource = cms.InputTag("%sType0p1CorMet%s" % (jetCorrections[0], postfix)) )) ##### # Add sys shift correction to our Met ##### # Output: # - Type I + sys shift: patMETsSysShiftPFlow # - Type 0 + I + sys shift: patMETsType0p1pSysShiftPFlow #process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi") if not isMC: process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data else: process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc # Clone the Type I MEt producer and add Sys Shift corrections setattr(process, "%sType1pSysShiftCorMet%s" % (jetCorrections[0], postfix), getattr(process, "%sType1CorMet%s" % (jetCorrections[0], postfix)).clone()) getattr(process, "%sType1pSysShiftCorMet%s" % (jetCorrections[0], postfix)).srcType1Corrections.append( cms.InputTag('pfMEtSysShiftCorr') ) # Clone the Type 0+I MEt producer and add Sys Shift corrections setattr(process, "%sType0p1pSysShiftCorMet%s" % (jetCorrections[0], postfix), getattr(process, "%sType0p1CorMet%s" % (jetCorrections[0], postfix)).clone()) getattr(process, "%sType0p1pSysShiftCorMet%s" % (jetCorrections[0], postfix)).srcType1Corrections.append( cms.InputTag('pfMEtSysShiftCorr') ) # Convert PF MEt to PAT MEt setattr(process, "patMETsSysShift%s" % postfix, getattr(process, "patMETs%s" % postfix).clone( metSource = cms.InputTag("%sType1pSysShiftCorMet%s" % (jetCorrections[0], postfix)) )) setattr(process, "patMETsType0p1pShiftCorr%s" % postfix, getattr(process, "patMETs%s" % postfix).clone( metSource = cms.InputTag("%sType0p1pSysShiftCorMet%s" % (jetCorrections[0], postfix)) )) getattr(process, "pfJets%s" % postfix).doAreaFastjet = True getattr(process, "pfJets%s" % postfix).doRhoFastjet = False # Should be fine in recent version of PAT, but in case of... #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho") ##### # Configure muon & electron isolation cuts ##### # Electrons need a deltaR = 0.3 cone for isolation values. from PhysicsTools.PatAlgos.tools.helpers import loadWithPostfix loadWithPostfix(process, "CommonTools.ParticleFlow.Isolation.pfElectronIsolation_cff", postfix) # Fix input tags deposit = getattr(process, "elPFIsoDepositCharged%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag("pfAllChargedHadrons%s" % postfix) deposit = getattr(process, "elPFIsoDepositChargedAll%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag("pfAllChargedParticles%s" % postfix) deposit = getattr(process, "elPFIsoDepositGamma%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag("pfAllPhotons%s" % postfix) deposit = getattr(process, "elPFIsoDepositNeutral%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag("pfAllNeutralHadrons%s" % postfix) deposit = getattr(process, "elPFIsoDepositPU%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag("pfPileUpAllChargedParticles%s" % postfix) # Adapt cut for pfSelectedElectrons # Default cut: pt > 5 & gsfElectronRef.isAvailable() & gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits<2 setattr(process, "pfSelectedElectrons%s" % postfix, cms.EDFilter( "GenericPFCandidateSelector", src = cms.InputTag("pfElectronsFromVertex%s" % postfix), cut = cms.string("pt > 10 && gsfTrackRef.isNonnull && gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits<2") ) ) process.pfIsolatedElectronsClones = cms.EDFilter( "IsolatedPFCandidateSelector", src = cms.InputTag("pfSelectedElectrons%s" % postfix), isolationValueMapsCharged = cms.VInputTag( cms.InputTag("elPFIsoValueCharged03PFId%s" % postfix), ), isolationValueMapsNeutral = cms.VInputTag( cms.InputTag("elPFIsoValueNeutral03PFId%s" % postfix), cms.InputTag("elPFIsoValueGamma03PFId%s" % postfix) ), doDeltaBetaCorrection = cms.bool(False), deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId%s" % postfix), deltaBetaFactor = cms.double(-0.5), ## if True isolation is relative to pT isRelative = cms.bool(True), isolationCut = cms.double(0.10), ## Added in attached patch doEffectiveAreaCorrection = cms.bool(True), effectiveAreas = cms.InputTag("elEffectiveAreas03%s" % postfix), rho = cms.InputTag("kt6PFJets", "rho") ) pfIsolatedElectrons = cms.EDFilter("PFCandidateFwdPtrCollectionStringFilter", src = cms.InputTag("pfIsolatedElectronsClones"), cut = cms.string(""), makeClones = cms.bool(True) ) # Override default electron collection by our new one setattr(process, "pfIsolatedElectrons%s" % postfix, pfIsolatedElectrons) # Set correct isolation deposits for patElectron production # FIXME: This should be enable if we want to recompute isolation from the pat electrons collections. # Unfortunately, it crashes sometimes when accessing deposits, because they are created from # pfSelectedElectrons<postfix> and patElectrons<postfix> red deposits using electrons coming from # pfIsolatedElectrons<postfix>. # adaptPFIsoElectrons(process, getattr(process, "patElectrons%s" % postfix), postfix, "03") # Produce electron conversions selection for Electron ID process.patConversions = cms.EDProducer("PATConversionProducer", # input collection electronSource = cms.InputTag("selectedPatElectrons%s" % postfix) # this should be your last selected electron collection name since currently index is used to match with electron later. We can fix this using reference pointer. ) # Produce electron conversions selection for Electron ID process.patConversionsLoose = cms.EDProducer("PATConversionProducer", # input collection electronSource = cms.InputTag("selectedPatElectronsLoose%s" % postfix) # this should be your last selected electron collection name since currently index is used to match with electron later. We can fix this using reference pointer. ) # Enable deltaBeta correction for muon isolation # Default cut from https://github.com/cms-sw/cmssw/blob/CMSSW_6_2_X/CommonTools/ParticleFlow/python/Isolation/pfIsolatedMuons_cfi.py # pt > 5 & muonRef.isAvailable() & muonRef.pfIsolationR04().sumChargedHadronPt + muonRef.pfIsolationR04().sumNeutralHadronEt + # muonRef.pfIsolationR04().sumPhotonEt < 0.15 * pt # deltaBeta isolation is: [sumChargedHadronPt + max(0., sumNeutralHadronPt + sumPhotonPt - 0.5 * sumPUPt] / pt # pt > 10, global muon, deltaBeta isolation < 0.12 cut = "pt > 10 & muonRef.isAvailable() & muonRef.isGlobalMuon() & ((muonRef.pfIsolationR04().sumChargedHadronPt + max(0.0, muonRef.pfIsolationR04().sumNeutralHadronEt + muonRef.pfIsolationR04().sumPhotonEt - 0.5 * muonRef.pfIsolationR04().sumPUPt)) < 0.12 * pt)" getattr(process, "pfIsolatedMuons%s" % postfix).cut = cut #process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi') #process.eidMVASequence = cms.Sequence(process.mvaTrigV0 + process.mvaNonTrigV0) ##Electron ID #process.patElectronsPFlow.electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0") #process.patElectronsPFlow.electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0") #process.patDefaultSequencePFlow.replace(process.patElectronsPFlow, process.eidMVASequence * process.patElectronsPFlow) # Compute effective areas for correcting isolation loadWithPostfix(process, "PatTopProduction.Tools.electronEffectiveAreaProducer_cfi", postfix) getattr(process, "elEffectiveAreas03%s" % postfix).src = cms.InputTag("pfSelectedElectrons%s" % postfix) if isMC: getattr(process, "elEffectiveAreas03%s" % postfix).target = cms.string("EAFall11MC") ##### # PAT object configuration ##### # jets process.selectedPatJetsPFlow.cut = 'pt > 10. & abs(eta) < 3.' # muons process.patMuonsPFlow.usePV = False process.patMuonsPFlow.embedTrack = True # electrons process.patElectronsPFlow.usePV = False process.patElectronsPFlow.embedTrack = True ##### # Loose collections with no isolation cut applied # Clone selectedPatMuons / selectedPatElectrons, and use in input pfMuons / pfElectrons ##### setattr(process, "selectedPatMuonsLoose%s" % postfix, getattr(process, "patMuons%s" % postfix).clone( pfMuonSource = cms.InputTag("pfMuons%s" % postfix), embedGenMatch = False, addGenMatch = False ) ) setattr(process, "selectedPatElectronsLoose%s" % postfix, getattr(process, "patElectrons%s" % postfix).clone( pfElectronSource = cms.InputTag("pfSelectedElectrons%s" % postfix), embedGenMatch = False, addGenMatch = False ) ) adaptPFIsoElectrons(process, getattr(process, "selectedPatElectronsLoose%s" % postfix), postfix, "03") if not isMC: removeMCMatchingPF2PAT(process, '') ##### # P2FPAT is done. Now setup some filters ##### # require physics declared process.load('HLTrigger.special.hltPhysicsDeclared_cfi') process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis' # require scraping filter if not isMC: process.scrapingVeto = cms.EDFilter("FilterOutScraping", applyfilter = cms.untracked.bool(True), debugOn = cms.untracked.bool(False), numtrack = cms.untracked.uint32(10), thresh = cms.untracked.double(0.25) ) # MET Filters process.load('RecoMET.METFilters.metFilters_cff') # Remove uneeded filter del(process.tobtecfakesfilter) # Add PF2PAT output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out.outputCommands = cms.untracked.vstring('drop *', 'keep GenEventInfoProduct_generator_*_*', 'keep *_genParticles*_*_*', 'keep edmTriggerResults_*_*_*', 'keep *_*fflinePrimaryVertices_*_*', # It's NOT a typo 'keep recoPFCandidates_particleFlow_*_*', 'keep PileupSummaryInfos_*_*_*', 'keep double_kt6PFJets*_rho_*', 'keep *_patConversions*_*_*', *patEventContentNoCleaning ) process.out.outputCommands += [ 'drop *_selectedPatJetsForMET*_*_*', 'drop *_selectedPatJets*_pfCandidates_*', 'keep *_patMETsRaw*_*_PAT', # Keep raw met 'keep *_allConversions*_*_*', # For isolations and conversions vetoes 'keep *_gsfElectron*_*_*', 'keep *_offlineBeamSpot*_*_*' ] # RelVal in inputs #from PhysicsTools.PatAlgos.tools.cmsswVersionTools import pickRelValInputFiles #process.source.fileNames = pickRelValInputFiles(cmsswVersion = "CMSSW_5_3_6", globalTag = "PU_START53_V14", debug = True, numberOfFiles = 1) process.options.wantSummary = False process.MessageLogger.cerr.FwkReport.reportEvery = 1 print("Config loaded") return process
def usePF2PATForAnalysis(jetAlgo, postfix, useTypeIMET, usePFNoPU): # Jet corrections # No L2L3 Residual on purpose if usePFNoPU: jetCorrections = ("%sPFchs" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute']) postfix += "chs" else: jetCorrections = ("%sPF" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute']) #if not runOnMC: # jetCorrections[1].append('L2L3Residual') p = postfix usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=p, jetCorrections=jetCorrections, typeIMetCorrections = useTypeIMET) getattr(process, "pfPileUp" + p).Enable = True getattr(process, "pfPileUp" + p).Vertices = 'goodOfflinePrimaryVertices' getattr(process, "pfPileUp" + p).checkClosestZVertex = cms.bool(False) getattr(process, "pfJets" + p).doAreaFastjet = cms.bool(True) getattr(process, "pfJets" + p).doRhoFastjet = False getattr(process, 'patJetCorrFactors' + p).rho = cms.InputTag("kt6PFJets", "rho") # Do not use kt6PFJetsPFlowAK5, it's not ok for L1FastJet. # top projections in PF2PAT: getattr(process,"pfNoPileUp" + p).enable = cms.bool(usePFNoPU) getattr(process,"pfNoMuon" + p).enable = True getattr(process,"pfNoElectron" + p).enable = True getattr(process,"pfNoTau" + p).enable = True getattr(process,"pfNoJet" + p).enable = True getattr(process,"patElectrons" + p).embedTrack = True getattr(process,"patMuons" + p).embedTrack = True # enable delta beta correction for muon selection in PF2PAT? getattr(process,"pfIsolatedMuons" + p).doDeltaBetaCorrection = True getattr(process, "patJets" + p).embedPFCandidates = False # Keep only jets with pt > 2 Gev getattr(process, "selectedPatJets" + p).cut = "pt > 2"; # Use a cone of 0.3 for photon isolation #adaptPFIsoPhotons(process, applyPostfix(process, "patPhotons", postfix), postfix, "03") # 2012 Photon ID # Electron conversion setattr(process, "patConversions" + p, cms.EDProducer("PATConversionProducer", # input collection electronSource = cms.InputTag("selectedPatElectrons" + p) )) # Switch electron isolation to dR = 0.3, for PF2PAT getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p)) getattr(process, "pfIsolatedElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p) getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p)) getattr(process, "pfElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p)) getattr(process, "pfElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p) getattr(process, "pfElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag( "elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p)) # ... And for PAT adaptPFIsoElectrons(process, getattr(process, "pfElectrons" + p), p, "03") ##there used to be a modulo to keep track of muons gen info, doesnt work anymore and we don't use that info - so removed for now. setattr(process, "patMuonsLoose" + p, getattr(process, "patMuons" + p).clone( pfMuonSource = cms.InputTag("pfMuons" + p), embedGenMatch = False, addGenMatch = False ) ) setattr(process, "selectedPatMuonsLoose" + p, getattr(process, "selectedPatMuons" + p).clone( src = cms.InputTag("patMuonsLoose" + p) ) ) sequence = getattr(process, "patDefaultSequence" + p) sequence += getattr(process, "patMuonsLoose" + p) sequence += (getattr(process, "selectedPatMuonsLoose" + p)) setattr(process, "patElectronsLoose" + p, getattr(process, "patElectrons" + p).clone( pfElectronSource = cms.InputTag("pfElectrons" + p) ) ) setattr(process, "selectedPatElectronsLoose" + p, getattr(process, "selectedPatElectrons" + p).clone( src = cms.InputTag("patElectronsLoose" + p) ) ) adaptPFIsoElectrons(process, getattr(process, "patElectronsLoose" + p), postfix, "03") sequence = getattr(process, "patDefaultSequence" + p) sequence += (getattr(process, "patElectronsLoose" + p) * getattr(process, "selectedPatElectronsLoose" + p)) # Setup quark gluon tagger #process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff') #cloneProcessingSnippet(process, process.QuarkGluonTagger, p) #getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p) #getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True) #getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(usePFNoPU) ## Remove the processing of primary vertices, as it's already what we do here #getattr(process, 'QGTagger' + p).srcPV = cms.InputTag('goodOfflinePrimaryVertices') #getattr(process, 'QuarkGluonTagger' + p).remove(getattr(process, 'goodOfflinePrimaryVerticesQG' + p)) if not runOnMC: if 'L2L3Residual' in jetCorrections: getattr(process, 'patPFJetMETtype1p2Corr' + p).jetCorrLabel = 'L2L3Residual' getattr(process, 'patPFMet' + p).addGenMET = cms.bool(False) names = ["Taus"] #if jetAlgo != "AK5": #names += ["Electrons", "Muons"] if len(names) > 0: removeSpecificPATObjects(process, names = names, outputModules = ['out'], postfix = p) adaptPVs(process, pvCollection = cms.InputTag("goodOfflinePrimaryVertices"), postfix = p) getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatElectrons" + p), getattr(process, "selectedPatElectrons" + p) + getattr(process, "patConversions" + p)) #getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatJets" + p), getattr(process, "selectedPatJets" + p) + getattr(process, "QuarkGluonTagger" + p)) return getattr(process, "patPF2PATSequence" + p)
def loadPF2PAT(process,mcInfo,jetMetCorrections,extMatch,doSusyTopProjection,postfix): #-- PAT standard config ------------------------------------------------------- process.load("PhysicsTools.PatAlgos.patSequences_cff") #-- Jet corrections ----------------------------------------------------------- process.patJetCorrFactors.levels = jetMetCorrections #-- PF2PAT config ------------------------------------------------------------- from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process,runPF2PAT=True, jetAlgo='AK5',runOnMC=(mcInfo==1),postfix=postfix) #process.patJetsPF.embedGenJetMatch = False #process.patJetsPF.embedPFCandidates = False #drop tracks process.patElectronsPF.embedTrack = True process.patMuonsPF.embedTrack = True process.electronMatchPF.maxDeltaR = cms.double(0.2) process.electronMatchPF.maxDPtRel = cms.double(999999.) process.electronMatchPF.checkCharge = False process.muonMatchPF.maxDeltaR = cms.double(0.2) process.muonMatchPF.maxDPtRel = cms.double(999999.) process.muonMatchPF.checkCharge = False if extMatch: process.electronMatchPF.mcStatus = cms.vint32(1,5) process.electronMatchPF.matched = "mergedTruth" process.muonMatchPF.mcStatus = cms.vint32(1,5) process.muonMatchPF.matched = "mergedTruth" process.genParticlesForJets.src = "mergedTruth" process.genParticlesForJetsNoMuNoNu.src = "mergedTruth" process.genParticlesForJetsNoNu.src = "mergedTruth" process.patJetPartonMatchPF.matched = "mergedTruth" process.patJetPartonsPF.src = "mergedTruth" process.photonMatchPF.matched = "mergedTruth" process.tauGenJetsPF.GenParticles = "mergedTruth" process.tauMatchPF.matched = "mergedTruth" #Remove jet pt cut #process.pfJetsPF.ptMin = 0. #include tau decay mode in pat::Taus (elese it will just be uninitialized) #process.patTausPF.addDecayMode = True #process.patTausPF.decayModeSrc = "shrinkingConePFTauDecayModeProducerPF" #PF type I corrected MET addPFTypeIMet(process) #Set isolation cone to 0.3 process.isoValElectronWithChargedPF.deposits.deltaR = 0.3 process.isoValElectronWithNeutralPF.deposits.deltaR = 0.3 process.isoValElectronWithPhotonsPF.deposits.deltaR = 0.3 process.isoValMuonWithChargedPF.deposits.deltaR = 0.3 process.isoValMuonWithNeutralPF.deposits.deltaR = 0.3 process.isoValMuonWithPhotonsPF.deposits.deltaR = 0.3 #-- Enable pileup sequence ------------------------------------------------------------- process.pfPileUpPF.Vertices = "offlinePrimaryVertices" process.pfPileUpPF.Enable = True if not doSusyTopProjection: return #-- Top projection selection ----------------------------------------------------------- #Vertices process.goodVertices = cms.EDFilter("VertexSelector", src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"), filter = cms.bool(False), ) #Electrons #relax all selectors *before* pat-lepton creation process.pfElectronsFromVertexPF.dzCut = 9999.0 process.pfElectronsFromVertexPF.d0Cut = 9999.0 process.pfSelectedElectronsPF.cut = "" process.pfRelaxedElectronsPF = process.pfIsolatedElectronsPF.clone(combinedIsolationCut = 3.) process.pfIsolatedElectronsPF.combinedIsolationCut = 0.15 process.pfElectronsFromGoodVertex = cms.EDFilter( "IPCutPFCandidateSelector", src = cms.InputTag("pfIsolatedElectronsPF"), # PFCandidate source vertices = cms.InputTag("goodVertices"), # vertices source d0Cut = cms.double(0.04), # transverse IP dzCut = cms.double(1.), # longitudinal IP d0SigCut = cms.double(99.), # transverse IP significance dzSigCut = cms.double(99.), # longitudinal IP significance ) electronSelection = "abs( eta ) < 2.5 & pt > 5" electronSelection += " & mva_e_pi > 0.4" # same as patElectron::mva() electronSelection += " & gsfTrackRef().isNonnull() & gsfTrackRef().trackerExpectedHitsInner().numberOfHits() < 1" process.pfUnclusteredElectronsPF = cms.EDFilter( "GenericPFCandidateSelector", src = cms.InputTag("pfElectronsFromGoodVertex"), #pfSelectedElectronsPF cut = cms.string(electronSelection) ) process.pfElectronSequencePF.replace(process.pfIsolatedElectronsPF, process.pfIsolatedElectronsPF + process.goodVertices * process.pfElectronsFromGoodVertex + process.pfUnclusteredElectronsPF + process.pfRelaxedElectronsPF) process.patElectronsPF.pfElectronSource = "pfRelaxedElectronsPF" process.pfNoElectronPF.topCollection = "pfUnclusteredElectronsPF" #Muons #relaxe built-in preselection process.pfMuonsFromVertexPF.dzCut = 9999.0 process.pfMuonsFromVertexPF.d0Cut = 9999.0 process.pfSelectedMuonsPF.cut = "" process.pfRelaxedMuonsPF = process.pfIsolatedMuonsPF.clone(combinedIsolationCut = 3) process.pfIsolatedMuonsPF.combinedIsolationCut = 0.15 process.pfMuonsFromGoodVertex = cms.EDFilter( "IPCutPFCandidateSelector", src = cms.InputTag("pfIsolatedMuonsPF"), # PFCandidate source vertices = cms.InputTag("goodVertices"), # vertices source d0Cut = cms.double(0.02), # transverse IP dzCut = cms.double(1.), # longitudinal IP d0SigCut = cms.double(99.), # transverse IP significance dzSigCut = cms.double(99.), # longitudinal IP significance ) muonSelection = "abs( eta ) < 2.5 & pt > 5" #GlobalMuonPromptTight muonSelection += " & muonRef().isNonnull & muonRef().isGlobalMuon()" muonSelection += " & muonRef().isTrackerMuon() & muonRef().numberOfMatches > 1" muonSelection += " & muonRef().globalTrack().normalizedChi2() < 10" muonSelection += " & muonRef().track().numberOfValidHits() > 10" muonSelection += " & muonRef().globalTrack().hitPattern().numberOfValidMuonHits() > 0" muonSelection += " & muonRef().innerTrack().hitPattern().numberOfValidPixelHits() > 0" process.pfUnclusteredMuonsPF = cms.EDFilter( "GenericPFCandidateSelector", src = cms.InputTag("pfMuonsFromGoodVertex"), #pfSelectedMuonsPF cut = cms.string(muonSelection) ) process.pfMuonSequencePF.replace(process.pfIsolatedMuonsPF, process.pfIsolatedMuonsPF + process.goodVertices * process.pfMuonsFromGoodVertex + process.pfUnclusteredMuonsPF + process.pfRelaxedMuonsPF) process.patMuonsPF.pfMuonSource = "pfRelaxedMuonsPF" process.pfNoMuonPF.topCollection = "pfUnclusteredMuonsPF" #Taus process.pfTausPF.discriminators = cms.VPSet() process.pfUnclusteredTausPF = process.pfTausPF.clone( cut = cms.string("pt < 0") ) process.pfTauSequencePF.replace(process.pfTausPF, process.pfTausPF+ process.pfUnclusteredTausPF) process.pfNoTauPF.topCollection = "pfUnclusteredTausPF"
"PoolOutputModule", fileName=cms.untracked.string('patTuple.root'), # save only events passing the full path SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring('p')), # save PAT Layer 1 output; you need a '*' to # unpack the list of commands 'patEventContent' outputCommands=cms.untracked.vstring('drop *', *patEventContent)) #from PhysicsTools.PatAlgos.tools.coreTools import * #removeAllPATObjectsBut(process, ['Jets']) from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT postfix = "PFlow" usePF2PAT(process, runPF2PAT=True, jetAlgo='AK5', runOnMC=False, postfix=postfix, jetCorrections=('AK5PFchs', [ 'L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual' ]), pvCollection=cms.InputTag('offlinePrimaryVertices')) process.pfPileUpPFlow.checkClosestZVertex = False getattr(process, "patPF2PATSequence" + postfix).remove( getattr(process, "cleanPatCandidates" + postfix)) getattr(process, "patPF2PATSequence" + postfix).remove( getattr(process, "countPatCandidates" + postfix)) process.patseq = cms.Sequence(getattr(process, "patPF2PATSequence" + postfix)) process.pat_step = cms.Path(process.patseq) ######Pileup Jet ID (Hendrik) #https://twiki.cern.ch/twiki/bin/view/CMS/PileupJetID#Running_the_algorithm_on_reco_je from CMGTools.External.pujetidsequence_cff import puJetId, puJetMva
inputJetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']) else: inputJetCorrLabel = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute']) if runOnData: inputJetCorrLabel[1].append('L2L3Residual') # PF2PAT setup. The code snippet is inspired by [1]. In order to make life simplier, the (empty) # postfix is hard-coded. See [2] for information on MET corrections with PFBRECO and PAT # [1] http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/PhysicsTools/PatExamples/test/patTuple_52x_jec_cfg.py?revision=1.1&view=markup # [2] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_II_0_with_PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT = True, runOnMC = not runOnData, postfix = '', jetAlgo = 'AK5', jetCorrections = inputJetCorrLabel, pvCollection = cms.InputTag('goodOfflinePrimaryVertices'), typeIMetCorrections = runOnData, # in case of MC the corrections are added with MET unc. tool outputModules = []) # A recommended setting for JEC with CHS # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012 process.pfPileUp.checkClosestZVertex = False # We do not consider tau-leptons in the analysis (they are included in jets) process.pfNoTau.enable = False # Define the leptons from UserCode.SingleTop.ObjectsDefinitions_cff import *
if useL2L3Residual and not runOnMC: jecLevels.append( 'L2L3Residual' ) if useL5Flavor: jecLevels.append( 'L5Flavor' ) if useL7Parton: jecLevels.append( 'L7Parton' ) ### Switch configuration if runPF2PAT: from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT( process , runPF2PAT = runPF2PAT , runOnMC = runOnMC , jetAlgo = jetAlgo , postfix = postfix , jetCorrections = ( jecSetPF , jecLevels ) ) applyPostfix( process, 'pfNoPileUp' , postfix ).enable = usePFnoPU applyPostfix( process, 'pfNoMuon' , postfix ).enable = useNoMuon applyPostfix( process, 'pfNoElectron', postfix ).enable = useNoElectron applyPostfix( process, 'pfNoJet' , postfix ).enable = useNoJet applyPostfix( process, 'pfNoTau' , postfix ).enable = useNoTau if useL1FastJet: applyPostfix( process, 'pfPileUp', postfix ).Vertices = cms.InputTag( pfVertices ) applyPostfix( process, 'pfPileUp', postfix ).checkClosestZVertex = False applyPostfix( process, 'pfJets', postfix ).doAreaFastjet = True applyPostfix( process, 'pfJets', postfix ).doRhoFastjet = False applyPostfix( process, 'pfMuonsFromVertex' , postfix ).vertices = cms.InputTag( pfVertices )
def addPATSequences(process, runMC): # Load the PAT config from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent process.out = cms.OutputModule( "PoolOutputModule", fileName=cms.untracked.string('patTuple.root'), SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring('pat_step')), outputCommands=cms.untracked.vstring('drop *', *patEventContent)) ### process.load('PhysicsTools.PatAlgos.patSequences_cff') from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT postfix = "PFlow" jetAlgo = "AK5" jetCorrections = None if runMC: jetCorrections = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute']) else: jetCorrections = ('AK5PFchs', [ 'L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual' ]) usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runMC, postfix=postfix, jetCorrections=jetCorrections) #from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching #if not runMC: # removeMCMatching(process, ['All'],"") #-----------------Customization---------------- process.pfPileUpPFlow.Enable = True process.pfPileUpPFlow.checkClosestZVertex = False process.pfPileUpPFlow.Vertices = cms.InputTag('goodOfflinePrimaryVertices') process.pfPileUpPFlow.verbose = True process.pfJetsPFlow.doAreaFastjet = True process.pfJetsPFlow.doRhoFastjet = False from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams=pvSelector.clone(minNdof=cms.double(4.0), maxZ=cms.double(24.0)), src=cms.InputTag('offlinePrimaryVertices')) # Compute the mean pt per unit area (rho) from the PFCHS inputs #from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets,ak5PFJets #process.kt6PFJetsPFlow = kt6PFJets.clone( # src = cms.InputTag('pfNoElectron'+postfix), # doAreaFastjet = cms.bool(True), # doRhoFastjet = cms.bool(True) # ) #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho") from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForPAT = kt4PFJets.clone(rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True)) process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsForPAT", "rho") from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets process.ak5PFJetsPileUp = ak5PFJets.clone(src=cms.InputTag('pfPileUp' + postfix)) # Switch on PAT trigger from PhysicsTools.PatAlgos.tools.trigTools import switchOnTrigger #switchOnTrigger( process,triggerProducer = 'patTrigger', triggerEventProducer = 'patTriggerEvent', sequence = 'patPF2PATSequence',hltProcess = 'HLT', outputModule = 'out') switchOnTrigger(process, sequence='patPF2PATSequence' + postfix) process.patTrigger.addL1Algos = cms.bool(True) switchOnTrigger(process, sequence='patPF2PATSequence' + postfix) # to fix event content #------------------------------------------------------------------------------------------------------------- # Add modules to default sequence #if runMC: # getattr(process, "patElectrons"+postfix).embedGenMatch = True # getattr(process, "patMuons"+postfix).embedGenMatch = True #else: # getattr(process, "patElectrons"+postfix).embedGenMatch = False # getattr(process, "patMuons"+postfix).embedGenMatch = False # Add modules to default sequence getattr(process, "patPF2PATSequence" + postfix).replace( getattr(process, "pfNoElectron" + postfix), getattr(process, "pfNoElectron" + postfix) * process.kt6PFJetsForPAT) getattr(process, "patPF2PATSequence" + postfix).replace( getattr(process, "pfNoPileUp" + postfix), getattr(process, "pfNoPileUp" + postfix) * process.ak5PFJetsPileUp) #---------------------------------------------- # Let it run process.pat_step = cms.Path( process.goodOfflinePrimaryVertices * #process.patDefaultSequence + getattr(process, "patPF2PATSequence" + postfix)) # Add PatTrigger output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patTriggerEventContent # Add PF2PAT output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning patOutputCommands = cms.untracked.vstring( 'drop *', 'keep recoPFCandidates_particleFlow_*_*', *patEventContentNoCleaning) # Adjust the event content patOutputCommands += [ #'keep *_selectedPat*_*_*', 'keep *_genParticles*_*_*', 'keep *_offlinePrimaryVertices*_*_*', 'keep *_goodOfflinePrimaryVertices*_*_*', #'keep *_pileUpN*PrimaryVertices_*_*', #'keep *_pfPileUpExclN*_*_*', 'keep *_pfPileUpPFlow*_*_*', 'keep *_pfNoPileUpPFlow*_*_*', 'keep *_ak5PFJetsPileUp_*_*', 'keep *_ak5PFJets_*_*', 'keep recoTracks_generalTracks_*_*', 'keep HcalNoiseSummary_hcalnoise_*_*', 'keep *_BeamHaloSummary_*_*', #------- Trigger collections ------ 'keep edmTriggerResults_TriggerResults_*_*', 'keep *_hltTriggerSummaryAOD_*_*', 'keep L1GlobalTriggerObjectMapRecord_*_*_*', 'keep L1GlobalTriggerReadoutRecord_*_*_*', #------- CASTOR rec hits ------ 'keep *_logErrorHarvester_*_*', 'keep *_castorreco_*_*', #------- Calo towers (just for now) ------ 'keep *_towerMaker_*_*', #---------------PatTrigger---------------- 'keep patTriggerObjects_patTrigger*_*_*', 'keep patTriggerFilters_patTrigger*_*_*', 'keep patTriggerPaths_patTrigger*_*_*', 'keep patTriggerEvent_patTriggerEvent*_*_*' ] process.out.outputCommands = patOutputCommands # top projections in PF2PAT: getattr(process, "pfNoPileUp" + postfix).enable = True getattr(process, "pfNoMuon" + postfix).enable = True getattr(process, "pfNoElectron" + postfix).enable = True getattr(process, "pfNoTau" + postfix).enable = False getattr(process, "pfNoJet" + postfix).enable = True # verbose flags for the PF2PAT modules getattr(process, "pfNoJet" + postfix).verbose = False
def createProcess(isMC, globalTag): import FWCore.ParameterSet.Config as cms ##### # Init the process with some default options ##### process = cms.Process("PAT") ## MessageLogger process.load("FWCore.MessageLogger.MessageLogger_cfi") ## Options and Output Report process.options = cms.untracked.PSet( wantSummary=cms.untracked.bool(True), allowUnscheduled=cms.untracked.bool(True)) ## Source process.source = cms.Source("PoolSource", fileNames=cms.untracked.vstring()) ## Maximal Number of Events process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(100)) ## Geometry and Detector Conditions (needed for a few patTuple production steps) process.load("Configuration.Geometry.GeometryIdeal_cff") process.load( "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") process.GlobalTag.globaltag = cms.string("%s::All" % globalTag) process.load("Configuration.StandardSequences.MagneticField_cff") ## Output Module Configuration (expects a path 'p') from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out = cms.OutputModule( "PoolOutputModule", fileName=cms.untracked.string('patTuple.root'), ## save only events passing the full path #SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), ## save PAT output; you need a '*' to unpack the list of commands ## 'patEventContent' outputCommands=cms.untracked.vstring('drop *', *patEventContentNoCleaning)) process.outpath = cms.EndPath(process.out) ##### # Customize process for top pat Tuples production ##### print("Loading python config...") #process.load("PhysicsTools.PatAlgos.patSequences_cff") process.primaryVertexFilter = cms.EDFilter( "VertexSelector", src=cms.InputTag("offlinePrimaryVertices"), cut=cms.string( "!isFake & ndof > 4 & abs(z) <= 24 & position.Rho <= 2"), filter=cms.bool(True)) process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams=cms.PSet(minNdof=cms.double(4.), maxZ=cms.double(24.), maxRho=cms.double(2.)), filter=cms.bool(True), src=cms.InputTag('offlinePrimaryVertices')) from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT, adaptPFIsoElectrons postfix = "PFlow" jetAlgo = "AK5" # Jet corrections when using CHS (L2L3Residual IS mandatory on data) if isMC: jetCorrections = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute']) else: jetCorrections = ('AK5PFchs', [ 'L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual' ]) # Jet corrections when NOT using CHS #jetCorrections = ('AK5PF', ['L1FastJet','L2Relative','L3Absolute'] ) # Type I MET enabled usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=isMC, postfix=postfix, jetCorrections=jetCorrections, typeIMetCorrections=True, pvCollection=cms.InputTag('goodOfflinePrimaryVertices')) # We want: # - Uncorrected MEt: patMETsRawPFlow # - Type I corrected MEt: patMETsPFlow # - Type 0+I correct MEt: patMETsType0p1PFlow # Create PAT MEt from raw MEt collection (pfMET<postfix>)) setattr( process, "patMETsRaw%s" % postfix, getattr(process, "patMETs%s" % postfix).clone(metSource=cms.InputTag("pfMET%s" % (postfix)))) # Type 0, 1 or 2 corrected MEt is produced by the module CorrectedPFMETProducer # Clone the module <jetcorrectorlabel>Type1CorMet<postfix> (eg, AK5PFchschsTypeICorMetPFlow), # to create a Type 0 + I MEt setattr( process, "%sType0p1CorMet%s" % (jetCorrections[0], postfix), getattr( process, "%sType1CorMet%s" % (jetCorrections[0], postfix)).clone( applyType0Corrections=cms.bool(True), srcCHSSums=cms.VInputTag("pfchsMETcorr%s:type0" % postfix))) # Now, convert the PF met to patMET. Clone patMETs<postfix> setattr( process, "patMETsType0p1%s" % postfix, getattr(process, "patMETs%s" % postfix).clone( metSource=cms.InputTag("%sType0p1CorMet%s" % (jetCorrections[0], postfix)))) ##### # Add sys shift correction to our Met ##### # Output: # - Type I + sys shift: patMETsSysShiftPFlow # - Type 0 + I + sys shift: patMETsType0p1pSysShiftPFlow #process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi") if not isMC: process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data else: process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc # Clone the Type I MEt producer and add Sys Shift corrections setattr( process, "%sType1pSysShiftCorMet%s" % (jetCorrections[0], postfix), getattr(process, "%sType1CorMet%s" % (jetCorrections[0], postfix)).clone()) getattr(process, "%sType1pSysShiftCorMet%s" % (jetCorrections[0], postfix)).srcType1Corrections.append( cms.InputTag('pfMEtSysShiftCorr')) # Clone the Type 0+I MEt producer and add Sys Shift corrections setattr( process, "%sType0p1pSysShiftCorMet%s" % (jetCorrections[0], postfix), getattr(process, "%sType0p1CorMet%s" % (jetCorrections[0], postfix)).clone()) getattr(process, "%sType0p1pSysShiftCorMet%s" % (jetCorrections[0], postfix)).srcType1Corrections.append( cms.InputTag('pfMEtSysShiftCorr')) # Convert PF MEt to PAT MEt setattr( process, "patMETsSysShift%s" % postfix, getattr(process, "patMETs%s" % postfix).clone( metSource=cms.InputTag("%sType1pSysShiftCorMet%s" % (jetCorrections[0], postfix)))) setattr( process, "patMETsType0p1pShiftCorr%s" % postfix, getattr(process, "patMETs%s" % postfix).clone( metSource=cms.InputTag("%sType0p1pSysShiftCorMet%s" % (jetCorrections[0], postfix)))) getattr(process, "pfJets%s" % postfix).doAreaFastjet = True getattr(process, "pfJets%s" % postfix).doRhoFastjet = False # Should be fine in recent version of PAT, but in case of... #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho") ##### # Configure muon & electron isolation cuts ##### # Electrons need a deltaR = 0.3 cone for isolation values. from PhysicsTools.PatAlgos.tools.helpers import loadWithPostfix loadWithPostfix( process, "CommonTools.ParticleFlow.Isolation.pfElectronIsolation_cff", postfix) # Fix input tags deposit = getattr(process, "elPFIsoDepositCharged%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag( "pfAllChargedHadrons%s" % postfix) deposit = getattr(process, "elPFIsoDepositChargedAll%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag( "pfAllChargedParticles%s" % postfix) deposit = getattr(process, "elPFIsoDepositGamma%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag("pfAllPhotons%s" % postfix) deposit = getattr(process, "elPFIsoDepositNeutral%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag( "pfAllNeutralHadrons%s" % postfix) deposit = getattr(process, "elPFIsoDepositPU%s" % postfix) deposit.src = cms.InputTag("pfSelectedElectrons%s" % postfix) deposit.ExtractorPSet.inputCandView = cms.InputTag( "pfPileUpAllChargedParticles%s" % postfix) # Adapt cut for pfSelectedElectrons # Default cut: pt > 5 & gsfElectronRef.isAvailable() & gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits<2 setattr( process, "pfSelectedElectrons%s" % postfix, cms.EDFilter( "GenericPFCandidateSelector", src=cms.InputTag("pfElectronsFromVertex%s" % postfix), cut=cms.string( "pt > 10 && gsfTrackRef.isNonnull && gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits<2" ))) process.pfIsolatedElectronsClones = cms.EDFilter( "IsolatedPFCandidateSelector", src=cms.InputTag("pfSelectedElectrons%s" % postfix), isolationValueMapsCharged=cms.VInputTag( cms.InputTag("elPFIsoValueCharged03PFId%s" % postfix), ), isolationValueMapsNeutral=cms.VInputTag( cms.InputTag("elPFIsoValueNeutral03PFId%s" % postfix), cms.InputTag("elPFIsoValueGamma03PFId%s" % postfix)), doDeltaBetaCorrection=cms.bool(False), deltaBetaIsolationValueMap=cms.InputTag("elPFIsoValuePU03PFId%s" % postfix), deltaBetaFactor=cms.double(-0.5), ## if True isolation is relative to pT isRelative=cms.bool(True), isolationCut=cms.double(0.10), ## Added in attached patch doEffectiveAreaCorrection=cms.bool(True), effectiveAreas=cms.InputTag("elEffectiveAreas03%s" % postfix), rho=cms.InputTag("kt6PFJets", "rho")) pfIsolatedElectrons = cms.EDFilter( "PFCandidateFwdPtrCollectionStringFilter", src=cms.InputTag("pfIsolatedElectronsClones"), cut=cms.string(""), makeClones=cms.bool(True)) # Override default electron collection by our new one setattr(process, "pfIsolatedElectrons%s" % postfix, pfIsolatedElectrons) # Set correct isolation deposits for patElectron production # FIXME: This should be enable if we want to recompute isolation from the pat electrons collections. # Unfortunately, it crashes sometimes when accessing deposits, because they are created from # pfSelectedElectrons<postfix> and patElectrons<postfix> red deposits using electrons coming from # pfIsolatedElectrons<postfix>. # adaptPFIsoElectrons(process, getattr(process, "patElectrons%s" % postfix), postfix, "03") # Produce electron conversions selection for Electron ID process.patConversions = cms.EDProducer( "PATConversionProducer", # input collection electronSource=cms.InputTag("selectedPatElectrons%s" % postfix) # this should be your last selected electron collection name since currently index is used to match with electron later. We can fix this using reference pointer. ) # Produce electron conversions selection for Electron ID process.patConversionsLoose = cms.EDProducer( "PATConversionProducer", # input collection electronSource=cms.InputTag("selectedPatElectronsLoose%s" % postfix) # this should be your last selected electron collection name since currently index is used to match with electron later. We can fix this using reference pointer. ) # Enable deltaBeta correction for muon isolation # Default cut from https://github.com/cms-sw/cmssw/blob/CMSSW_6_2_X/CommonTools/ParticleFlow/python/Isolation/pfIsolatedMuons_cfi.py # pt > 5 & muonRef.isAvailable() & muonRef.pfIsolationR04().sumChargedHadronPt + muonRef.pfIsolationR04().sumNeutralHadronEt + # muonRef.pfIsolationR04().sumPhotonEt < 0.15 * pt # deltaBeta isolation is: [sumChargedHadronPt + max(0., sumNeutralHadronPt + sumPhotonPt - 0.5 * sumPUPt] / pt # pt > 10, global muon, deltaBeta isolation < 0.12 cut = "pt > 10 & muonRef.isAvailable() & muonRef.isGlobalMuon() & ((muonRef.pfIsolationR04().sumChargedHadronPt + max(0.0, muonRef.pfIsolationR04().sumNeutralHadronEt + muonRef.pfIsolationR04().sumPhotonEt - 0.5 * muonRef.pfIsolationR04().sumPUPt)) < 0.12 * pt)" getattr(process, "pfIsolatedMuons%s" % postfix).cut = cut #process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi') #process.eidMVASequence = cms.Sequence(process.mvaTrigV0 + process.mvaNonTrigV0) ##Electron ID #process.patElectronsPFlow.electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0") #process.patElectronsPFlow.electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0") #process.patDefaultSequencePFlow.replace(process.patElectronsPFlow, process.eidMVASequence * process.patElectronsPFlow) # Compute effective areas for correcting isolation loadWithPostfix( process, "PatTopProduction.Tools.electronEffectiveAreaProducer_cfi", postfix) getattr(process, "elEffectiveAreas03%s" % postfix).src = cms.InputTag( "pfSelectedElectrons%s" % postfix) if isMC: getattr(process, "elEffectiveAreas03%s" % postfix).target = cms.string("EAFall11MC") ##### # PAT object configuration ##### # jets process.selectedPatJetsPFlow.cut = 'pt > 10. & abs(eta) < 3.' # muons process.patMuonsPFlow.usePV = False process.patMuonsPFlow.embedTrack = True # electrons process.patElectronsPFlow.usePV = False process.patElectronsPFlow.embedTrack = True ##### # Loose collections with no isolation cut applied # Clone selectedPatMuons / selectedPatElectrons, and use in input pfMuons / pfElectrons ##### setattr( process, "selectedPatMuonsLoose%s" % postfix, getattr(process, "patMuons%s" % postfix).clone( pfMuonSource=cms.InputTag("pfMuons%s" % postfix), embedGenMatch=False, addGenMatch=False)) setattr( process, "selectedPatElectronsLoose%s" % postfix, getattr(process, "patElectrons%s" % postfix).clone( pfElectronSource=cms.InputTag("pfSelectedElectrons%s" % postfix), embedGenMatch=False, addGenMatch=False)) adaptPFIsoElectrons( process, getattr(process, "selectedPatElectronsLoose%s" % postfix), postfix, "03") if not isMC: removeMCMatchingPF2PAT(process, '') ##### # P2FPAT is done. Now setup some filters ##### # require physics declared process.load('HLTrigger.special.hltPhysicsDeclared_cfi') process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis' # require scraping filter if not isMC: process.scrapingVeto = cms.EDFilter( "FilterOutScraping", applyfilter=cms.untracked.bool(True), debugOn=cms.untracked.bool(False), numtrack=cms.untracked.uint32(10), thresh=cms.untracked.double(0.25)) # MET Filters process.load('RecoMET.METFilters.metFilters_cff') # Remove uneeded filter del (process.tobtecfakesfilter) # Add PF2PAT output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out.outputCommands = cms.untracked.vstring( 'drop *', 'keep GenEventInfoProduct_generator_*_*', 'keep *_genParticles*_*_*', 'keep edmTriggerResults_*_*_*', 'keep *_*fflinePrimaryVertices_*_*', # It's NOT a typo 'keep recoPFCandidates_particleFlow_*_*', 'keep PileupSummaryInfos_*_*_*', 'keep double_kt6PFJets*_rho_*', 'keep *_patConversions*_*_*', *patEventContentNoCleaning) process.out.outputCommands += [ 'drop *_selectedPatJetsForMET*_*_*', 'drop *_selectedPatJets*_pfCandidates_*', 'keep *_patMETsRaw*_*_PAT', # Keep raw met 'keep *_allConversions*_*_*', # For isolations and conversions vetoes 'keep *_gsfElectron*_*_*', 'keep *_offlineBeamSpot*_*_*' ] # RelVal in inputs #from PhysicsTools.PatAlgos.tools.cmsswVersionTools import pickRelValInputFiles #process.source.fileNames = pickRelValInputFiles(cmsswVersion = "CMSSW_5_3_6", globalTag = "PU_START53_V14", debug = True, numberOfFiles = 1) process.options.wantSummary = False process.MessageLogger.cerr.FwkReport.reportEvery = 1 print("Config loaded") return process
process.load( "PhysicsTools.PatAlgos.patSequences_cff" ) # Misc from PhysicsTools.PatAlgos.tools.coreTools import * removeSpecificPATObjects( process , names = [ 'Photons', 'Taus' ] ) # PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT( process , runOnMC = True , jetAlgo = jetAlgo , jetCorrections = ( '%sPFchs'%( jetAlgo ) , jecLevels ) , typeIMetCorrections = useTypeICorr , pvCollection = cms.InputTag( pvCollection ) ) # still need to fix event content afterwards :-( process.out.outputCommands.append( 'keep *_addPileupInfo_*_*' ) process.out.outputCommands.append( 'keep edmTriggerResults_*_*_*' ) process.out.outputCommands.append( 'keep *_offlinePrimaryVertices_*_*' ) process.out.outputCommands.append( 'keep *_%s_*_*'%( pvCollection ) ) process.patPF2PATSequence.remove( process.ak7GenJetsNoNu ) process.patPF2PATSequence.remove( process.iterativeCone5GenJetsNoNu ) process.patPF2PATSequence.remove( process.patPFParticles ) process.patPF2PATSequence.remove( process.selectedPatPFParticles )
jecLevels.append( 'L5Flavor' ) if useL7Parton: jecLevels.append( 'L7Parton' ) ############################ ### Switch configuration ### ############################ from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT( process , runPF2PAT = True , runOnMC = runOnMC , jetAlgo = jetAlgo , postfix = postfix , jetCorrections = ( jecSet , jecLevels ) , typeIMetCorrections = typeIMetCorrections , pvCollection = cms.InputTag( pfVertices ) ) if useElectronCutBasePF: #process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') from TopQuarkAnalysis.Configuration.patRefSel_pfIdentifiedElectrons_cfi import pfIdentifiedElectrons process.pfIdentifiedElectronsPF = pfIdentifiedElectrons process.pfIdentifiedElectronsPF.src = cms.InputTag( 'pfElectronsFromVertexPF' ) process.pfSelectedElectronsPF.src = cms.InputTag( 'pfIdentifiedElectronsPF' ) process.patPF2PATSequencePF.replace( process.pfSelectedElectronsPF, process.pfIdentifiedElectronsPF + process.pfSelectedElectronsPF ) pfElectronSelectionCut += ' && %s'%( electronCutPF ) process.pfNoPileUpPF.enable = usePFnoPU # True process.pfNoMuonPF.enable = useNoMuon # True
def initialise(runOnMC, decayMode, doOutModule=False, doPAT=True): process = cms.Process("KrAFT") process.load("Configuration.StandardSequences.Services_cff") process.load("Configuration.Geometry.GeometryDB_cff") process.load("Configuration.StandardSequences.MagneticField_cff") process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(True)) process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1)) process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 10000 process.source = cms.Source("PoolSource", fileNames=cms.untracked.vstring()) process.source.inputCommands = cms.untracked.vstring( "keep *", "drop *_MEtoEDMConverter_*_*") process.load( "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") from Configuration.AlCa.autoCond import autoCond if runOnMC: process.GlobalTag.globaltag = autoCond['startup'] else: process.GlobalTag.globaltag = autoCond['com10'] outputModuleForTriggerMatch = "" outputModules = [] if doOutModule: from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out = cms.OutputModule( "PoolOutputModule", fileName=cms.untracked.string("out.root"), outputCommands=cms.untracked.vstring( 'drop *', 'keep recoPFCandidates_particleFlow_*_*', *patEventContentNoCleaning)) process.outPath = cms.EndPath(process.out) outputModuleForTriggerMatch = "out" outputModules.append(process.out) ## Load PAT process.load("PhysicsTools.PatAlgos.patSequences_cff") ## Apply MVA process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') process.eidMVASequence = cms.Sequence(process.mvaTrigV0 + process.mvaNonTrigV0) process.patElectrons.electronIDSources.mvaTrigV0 = cms.InputTag( "mvaTrigV0") process.patElectrons.electronIDSources.mvaNonTrigV0 = cms.InputTag( "mvaNonTrigV0") process.patDefaultSequence.replace( process.patElectrons, process.eidMVASequence * process.patElectrons) ## Load trigger matching process.load("KrAFT.Configuration.hltFilters_cff") #from PhysicsTools.PatAlgos.tools.trigTools import * #switchOnTriggerMatchEmbedding(process, outputModule="") ## Apply PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT if runOnMC: jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] else: jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual'] postfix = "PFlow" #usePFBRECO(process,runPFBRECO=True, usePF2PAT(process, runPF2PAT=True, runOnMC=runOnMC, outputModules=outputModules, postfix=postfix, jetAlgo="AK5", jetCorrections=("AK5PFchs", jecLevels), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), typeIMetCorrections=True) # process.pfPileUpPFlow.checkClosestZVertex = cms.bool(False) # top projections in PF2PAT: process.pfNoPileUpPFlow.enable = True process.pfNoMuonPFlow.enable = True process.pfNoElectronPFlow.enable = True process.pfNoTauPFlow.enable = False process.pfNoJetPFlow.enable = False # verbose flags for the PF2PAT modules process.pfNoMuonPFlow.verbose = False # Use non-isolated muons and electrons process.patMuonsPFlow.pfMuonSource = "pfMuonsPFlow" process.patElectronsPFlow.pfElectronSource = "pfElectronsPFlow" # And turn on delta-beta corrections while building pfIsolated*PFlow process.pfIsolatedMuonsPFlow.doDeltaBetaCorrection = True process.pfIsolatedElectronsPFlow.doDeltaBetaCorrection = True # Change DR cone size to 0.3 process.pfIsolatedMuonsPFlow.isolationValueMapsCharged = cms.VInputTag( cms.InputTag('muPFIsoValueCharged03PFlow')) process.pfIsolatedMuonsPFlow.deltaBetaIsolationValueMap = cms.InputTag( 'muPFIsoValuePU03PFlow') process.pfIsolatedMuonsPFlow.isolationValueMapsNeutral = cms.VInputTag( cms.InputTag('muPFIsoValueNeutral03PFlow'), cms.InputTag('muPFIsoValueGamma03PFlow'), ) process.pfMuonsPFlow.isolationValueMapsCharged = cms.VInputTag( cms.InputTag('muPFIsoValueCharged03PFlow')) process.pfMuonsPFlow.deltaBetaIsolationValueMap = cms.InputTag( 'muPFIsoValuePU03PFlow') process.pfMuonsPFlow.isolationValueMapsNeutral = cms.VInputTag( cms.InputTag('muPFIsoValueNeutral03PFlow'), cms.InputTag('muPFIsoValueGamma03PFlow'), ) process.patMuonsPFlow.isolationValues.pfNeutralHadrons = cms.InputTag( 'muPFIsoValueNeutral03PFlow') process.patMuonsPFlow.isolationValues.pfChargedAll = cms.InputTag( 'muPFIsoValueChargedAll03PFlow') process.patMuonsPFlow.isolationValues.pfPUChargedHadrons = cms.InputTag( 'muPFIsoValuePU03PFlow') process.patMuonsPFlow.isolationValues.pfPhotons = cms.InputTag( 'muPFIsoValueGamma03PFlow') process.patMuonsPFlow.isolationValues.pfChargedHadrons = cms.InputTag( 'muPFIsoValueCharged03PFlow') process.pfIsolatedElectronsPFlow.isolationValueMapsCharged = cms.VInputTag( cms.InputTag('elPFIsoValueCharged03PFIdPFlow')) process.pfIsolatedElectronsPFlow.deltaBetaIsolationValueMap = cms.InputTag( 'elPFIsoValuePU03PFIdPFlow') process.pfIsolatedElectronsPFlow.isolationValueMapsNeutral = cms.VInputTag( cms.InputTag('elPFIsoValueNeutral03PFIdPFlow'), cms.InputTag('elPFIsoValueGamma03PFIdPFlow')) process.pfElectronsPFlow.isolationValueMapsCharged = cms.VInputTag( cms.InputTag('elPFIsoValueCharged03PFIdPFlow')) process.pfElectronsPFlow.deltaBetaIsolationValueMap = cms.InputTag( 'elPFIsoValuePU03PFIdPFlow') process.pfElectronsPFlow.isolationValueMapsNeutral = cms.VInputTag( cms.InputTag('elPFIsoValueNeutral03PFIdPFlow'), cms.InputTag('elPFIsoValueGamma03PFIdPFlow')) process.patElectronsPFlow.isolationValues.pfNeutralHadrons = cms.InputTag( 'elPFIsoValueNeutral03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfChargedAll = cms.InputTag( 'elPFIsoValueChargedAll03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfPUChargedHadrons = cms.InputTag( 'elPFIsoValuePU03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfPhotons = cms.InputTag( 'elPFIsoValueGamma03PFIdPFlow') process.patElectronsPFlow.isolationValues.pfChargedHadrons = cms.InputTag( 'elPFIsoValueCharged03PFIdPFlow') ## Add common filters process.primaryVertexFilter = cms.EDFilter( "GoodVertexFilter", vertexCollection=cms.InputTag('offlinePrimaryVertices'), minimumNDOF=cms.uint32(4), maxAbsZ=cms.double(24), maxd0=cms.double(2)) from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams=pvSelector.clone(maxZ=cms.double(24.0)), src=cms.InputTag('offlinePrimaryVertices')) #process.load( "TopQuarkAnalysis.Configuration.patRefSel_goodVertex_cfi" ) #process.goodOfflinePrimaryVertices.filter = True process.load('TopQuarkAnalysis.Configuration.patRefSel_eventCleaning_cff') process.trackingFailureFilter.VertexSource = cms.InputTag( 'goodOfflinePrimaryVertices') if runOnMC: process.eventCleaning += process.eventCleaningMC else: process.eventCleaning += process.eventCleaningData #reason : removing many events. process.eventCleaning.remove(process.CSCTightHaloFilter) ## Lepton veto filters for L+J channels process.muonVetoFilter = cms.EDFilter( "PATCandViewCountFilter", src=cms.InputTag("selectedPatMuonsPFlow"), maxNumber=cms.uint32(0), minNumber=cms.uint32(0), ) process.electronVetoFilter = cms.EDFilter( "PATCandViewCountFilter", src=cms.InputTag("selectedPatElectronsPFlow"), maxNumber=cms.uint32(0), minNumber=cms.uint32(0), ) # event counters process.nEventsTotal = cms.EDProducer("EventCountProducer") process.nEventsClean = cms.EDProducer("EventCountProducer") process.nEventsPAT = cms.EDProducer("EventCountProducer") process.nEventsHLTElEl = cms.EDProducer("EventCountProducer") process.nEventsHLTMuMu = cms.EDProducer("EventCountProducer") process.nEventsHLTMuEl = cms.EDProducer("EventCountProducer") process.nEventsHLTMuJets = cms.EDProducer("EventCountProducer") process.nEventsHLTElJets = cms.EDProducer("EventCountProducer") ############################### ### Add AK5GenJetsNoNu #### ############################### #process.load("RecoJets.Configuration.GenJetParticles_cff") from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu from RecoJets.JetProducers.ak5GenJets_cfi import ak5GenJets process.ak5GenJetsNoNu = ak5GenJets.clone( src=cms.InputTag("genParticlesForJetsNoNu")) process.ak5GenJetsSeq = cms.Sequence(process.genParticlesForJets * process.genParticlesForJetsNoNu * process.ak5GenJetsNoNu) # Flavor history stuff process.load("PhysicsTools.HepMCCandAlgos.flavorHistoryPaths_cfi") process.flavorHistoryFilter.pathToSelect = cms.int32(-1) process.cFlavorHistoryProducer.matchedSrc = cms.InputTag("ak5GenJetsNoNu") process.bFlavorHistoryProducer.matchedSrc = cms.InputTag("ak5GenJetsNoNu") #ptMinParticle = cms.double(0.0) #ptMinShower = cms.double(0.0) #process.load( "RecoJets.Configuration.GenJetParticles_cff") #process.load( "RecoJets.Configuration.RecoGenJets_cff") #process.ReGenJetSequence = cms.Sequence( # process.genParticlesForJets # + process.genParticlesForJetsNoNu # + process.ak5GenJets # + process.ak5GenJetsNoNu #) process.commonFilterSequence = cms.Sequence( process.goodOfflinePrimaryVertices * process.eventCleaning * process.ak5GenJetsSeq * process.primaryVertexFilter * process.nEventsClean * getattr(process, "patPF2PATSequence" + postfix) # main PF2PAT * process.nEventsPAT * process.flavorHistorySeq) # process.patSequenceComplete = cms.Sequence( # + process.patDefaultSequence # + process.patPFBRECOSequencePFlow # process.patPF2PATSequencePFlow # + process.nEventsPAT # ) process.load("KrAFT.GeneratorTools.ttbar2bFilter_cfi") ## Defile paths if decayMode in ("all", "dilepton", "ElEl", "ee"): process.pElEl = cms.Path( process.nEventsTotal * process.commonFilterSequence * process.ttbar2bFilter * process.hltElEl * process.nEventsHLTElEl) # if doPAT: process.pElEl += process.patSequenceComplete if decayMode in ("all", "dilepton", "MuMu", "mumu"): process.pMuMu = cms.Path(process.nEventsTotal * process.commonFilterSequence * process.hltMuMu * process.nEventsHLTMuMu) # if doPAT: process.pMuMu += process.patSequenceComplete if decayMode in ("all", "dilepton", "MuEl", "emu"): process.pMuEl = cms.Path(process.nEventsTotal * process.commonFilterSequence * process.hltMuEl * process.nEventsHLTMuEl) # if doPAT: process.pMuEl += process.patSequenceComplete if decayMode in ("all", "MuJets"): process.selectedPatMuonsPFlow.cut = 'isPFMuon && (isGlobalMuon || isTrackerMuon) && pt > 10 && abs(eta) < 2.5 && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.selectedPatElectronsPFlow.cut = 'pt > 20 && abs(eta) < 2.5 && electronID("mvaTrigV0") > 0. && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.muonVetoFilter.maxNumber = 1 process.pMuJets = cms.Path( process.nEventsTotal * process.commonFilterSequence * process.hltMuJets * process.nEventsHLTMuJets) # if doPAT: process.pMuJets += process.patSequenceComplete process.pMuJets *= process.muonVetoFilter process.pMuJets += process.electronVetoFilter if runOnMC: process.pMuJets.remove(process.hltMuJets) if decayMode in ("all", "ElJets"): process.selectedPatMuonsPFlow.cut = 'isPFMuon && (isGlobalMuon || isTrackerMuon) && pt > 10 && abs(eta) < 2.5 && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.selectedPatElectronsPFlow.cut = 'pt > 20 && abs(eta) < 2.5 && electronID("mvaTrigV0") > 0. && (chargedHadronIso + max(0.,neutralHadronIso+photonIso-0.5*puChargedHadronIso))/pt < 0.15' process.electronVetoFilter.maxNumber = 1 process.pElJets = cms.Path( process.nEventsTotal * process.commonFilterSequence * process.hltElJets * process.nEventsHLTElJets) # if doPAT: process.pElJets += process.patSequenceComplete process.pElJets *= process.muonVetoFilter process.pElJets += process.electronVetoFilter if runOnMC: process.pElJets.remove(process.hltElJets) return process
def loadPF2PAT(process,mcInfo,jetMetCorrections,extMatch,doSusyTopProjection,postfix): #-- PAT standard config ------------------------------------------------------- process.load("PhysicsTools.PatAlgos.patSequences_cff") #-- Jet corrections ----------------------------------------------------------- process.patJetCorrFactors.levels = jetMetCorrections #-- PF2PAT config ------------------------------------------------------------- from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT #usePF2PAT(process,runPF2PAT=True, jetAlgo='AK5',runOnMC=(mcInfo==1),postfix=postfix, jetCorrections=('AK5PFchs', jetMetCorrections), pvCollection=cms.InputTag('goodOfflinePrimaryVertices')) usePF2PAT(process,runPF2PAT=True, jetAlgo='AK5',runOnMC=(mcInfo==1),postfix=postfix, jetCorrections=('AK5PFchs', jetMetCorrections)) # Get a list of good primary vertices, in 42x, these are DAF vertices from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ), src=cms.InputTag('offlinePrimaryVertices') ) #process.patJetsPF.embedGenJetMatch = False #process.patJetsPF.embedPFCandidates = False #drop tracks process.patElectronsPF.embedTrack = True process.patMuonsPF.embedTrack = True process.electronMatchPF.maxDeltaR = cms.double(0.2) process.electronMatchPF.maxDPtRel = cms.double(999999.) process.electronMatchPF.checkCharge = False process.muonMatchPF.maxDeltaR = cms.double(0.2) process.muonMatchPF.maxDPtRel = cms.double(999999.) process.muonMatchPF.checkCharge = False process.pfPileUpPF.checkClosestZVertex = False process.pfPileUpPF.Vertices = "goodOfflinePrimaryVertices" if extMatch: process.electronMatchPF.mcStatus = cms.vint32(1,5) process.electronMatchPF.matched = "mergedTruth" process.muonMatchPF.mcStatus = cms.vint32(1,5) process.muonMatchPF.matched = "mergedTruth" process.genParticlesForJets.src = "mergedTruth" process.genParticlesForJetsNoMuNoNu.src = "mergedTruth" process.genParticlesForJetsNoNu.src = "mergedTruth" process.patJetPartonMatchPF.matched = "mergedTruth" process.patJetPartonsPF.src = "mergedTruth" process.photonMatchPF.matched = "mergedTruth" #process.tauGenJetsPF.GenParticles = "mergedTruth" #process.tauMatchPF.matched = "mergedTruth" #Remove jet pt cut #process.pfJetsPF.ptMin = 0. #include tau decay mode in pat::Taus (elese it will just be uninitialized) #process.patTausPF.addDecayMode = True #process.patTausPF.decayModeSrc = "shrinkingConePFTauDecayModeProducerPF" #Set isolation cone to 0.3 for PF leptons # TODO: fix this for electrons and muons #process.pfElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId")) #process.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId") #process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) #process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId")) #process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId") #process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) #process.pfElectronsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFIdPF")) #process.pfElectronsPF.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFIdPF") #process.pfElectronsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFIdPF"), cms.InputTag("elPFIsoValueGamma03PFIdPF")) #process.pfIsolatedElectronsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFIdPF")) #process.pfIsolatedElectronsPF.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFIdPF") #process.pfIsolatedElectronsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFIdPF"), cms.InputTag("elPFIsoValueGamma03PFIdPF")) #process.pfMuons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03")) #process.pfMuons.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03") #process.pfMuons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03"), cms.InputTag("muPFIsoValueGamma03")) #process.pfIsolatedMuons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03")) #process.pfIsolatedMuons.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03") #process.pfIsolatedMuons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03"), cms.InputTag("muPFIsoValueGamma03")) #process.pfMuonsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03PF")) #process.pfMuonsPF.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03PF") #process.pfMuonsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03PF"), cms.InputTag("muPFIsoValueGamma03PF")) #process.pfIsolatedMuonsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03PF")) #process.pfIsolatedMuonsPF.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03PF") #process.pfIsolatedMuonsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03PF"), cms.InputTag("muPFIsoValueGamma03PF")) #-- Enable pileup sequence ------------------------------------------------------------- #Vertices process.goodVertices = cms.EDFilter("VertexSelector", src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"), filter = cms.bool(False), ) #process.pfPileUpPF.Vertices = "goodVertices" #process.pfPileUpPF.Enable = True process.pfNoPileUpSequencePF.replace(process.pfPileUpPF, process.goodVertices + process.pfPileUpPF) if not doSusyTopProjection: return #-- Top projection selection ----------------------------------------------------------- #Electrons #relax all selectors *before* pat-lepton creation process.pfElectronsFromVertexPF.dzCut = 9999.0 process.pfElectronsFromVertexPF.d0Cut = 9999.0 process.pfSelectedElectronsPF.cut = "" process.pfRelaxedElectronsPF = process.pfIsolatedElectronsPF.clone(isolationCut = 3.) process.pfIsolatedElectronsPF.isolationCut = 0.15 process.pfElectronsFromGoodVertex = cms.EDFilter( "IPCutPFCandidateSelector", src = cms.InputTag("pfIsolatedElectronsPF"), # PFCandidate source vertices = cms.InputTag("goodVertices"), # vertices source d0Cut = cms.double(0.04), # transverse IP dzCut = cms.double(1.), # longitudinal IP d0SigCut = cms.double(99.), # transverse IP significance dzSigCut = cms.double(99.), # longitudinal IP significance ) electronSelection = "abs( eta ) < 2.5 & pt > 5" electronSelection += " & mva_e_pi > 0.4" # same as patElectron::mva() #electronSelection += " & (isEB & (sigmaIetaIeta < 0.024 & hadronicOverEm < 0.15) | isEE & (sigmaIetaIeta < 0.040 & hadronicOverEm < 0.10))" #caloIdVL #electronSelection += " & (isEB & (deltaPhiSuperClusterTrackAtVtx < 0.15 & deltaEtaSuperClusterTrackAtVtx < 0.01) | isEE & (deltaPhiSuperClusterTrackAtVtx < 0.10 & deltaEtaSuperClusterTrackAtVtx < 0.01))" #trkIdVL electronSelection += " & gsfTrackRef().isNonnull() & gsfTrackRef().trackerExpectedHitsInner().numberOfHits() <= 0" process.pfUnclusteredElectronsPF = cms.EDFilter( "GenericPFCandidateSelector", src = cms.InputTag("pfElectronsFromGoodVertex"), #pfSelectedElectronsPF cut = cms.string(electronSelection) ) process.pfElectronSequencePF.replace(process.pfIsolatedElectronsPF, process.pfIsolatedElectronsPF + process.goodVertices * process.pfElectronsFromGoodVertex + process.pfUnclusteredElectronsPF + process.pfRelaxedElectronsPF) process.patElectronsPF.pfElectronSource = "pfRelaxedElectronsPF" process.pfNoElectronPF.topCollection = "pfUnclusteredElectronsPF" #Muons #relaxe built-in preselection process.pfMuonsFromVertexPF.dzCut = 9999.0 process.pfMuonsFromVertexPF.d0Cut = 9999.0 process.pfSelectedMuonsPF.cut = "" process.pfRelaxedMuonsPF = process.pfIsolatedMuonsPF.clone(isolationCut = 3) process.pfIsolatedMuonsPF.isolationCut = 0.15 process.pfMuonsFromGoodVertex = cms.EDFilter( "IPCutPFCandidateSelector", src = cms.InputTag("pfIsolatedMuonsPF"), # PFCandidate source vertices = cms.InputTag("goodVertices"), # vertices source d0Cut = cms.double(0.02), # transverse IP dzCut = cms.double(1.), # longitudinal IP d0SigCut = cms.double(99.), # transverse IP significance dzSigCut = cms.double(99.), # longitudinal IP significance ) muonSelection = "abs( eta ) < 2.5 & pt > 5" #GlobalMuonPromptTight muonSelection += " & muonRef().isNonnull & muonRef().isGlobalMuon()" muonSelection += " & muonRef().isTrackerMuon() & muonRef().numberOfMatches > 1" muonSelection += " & muonRef().globalTrack().normalizedChi2() < 10" muonSelection += " & muonRef().track().numberOfValidHits() > 10" muonSelection += " & muonRef().globalTrack().hitPattern().numberOfValidMuonHits() > 0" muonSelection += " & muonRef().innerTrack().hitPattern().numberOfValidPixelHits() > 0" process.pfUnclusteredMuonsPF = cms.EDFilter( "GenericPFCandidateSelector", src = cms.InputTag("pfMuonsFromGoodVertex"), #pfSelectedMuonsPF cut = cms.string(muonSelection) ) process.pfMuonSequencePF.replace(process.pfIsolatedMuonsPF, process.pfIsolatedMuonsPF + process.goodVertices * process.pfMuonsFromGoodVertex + process.pfUnclusteredMuonsPF + process.pfRelaxedMuonsPF) process.patMuonsPF.pfMuonSource = "pfRelaxedMuonsPF" process.pfNoMuonPF.topCollection = "pfUnclusteredMuonsPF"
## Output module for edm files (needed for PAT sequence, even if not used in EndPath) from Configuration.EventContent.EventContent_cff import FEVTEventContent process.out = cms.OutputModule( "PoolOutputModule", FEVTEventContent, dataset=cms.untracked.PSet(dataTier=cms.untracked.string('RECO')), fileName=cms.untracked.string("eh.root"), ) # add particle flow process.load("PhysicsTools.PatAlgos.patSequences_cff") from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT=True, jetAlgo='AK4', runOnMC=runOnMC, postfix=pfpostfix, jetCorrections=jetCorr, pvCollection=cms.InputTag( opt.primaryVertexOptions['outputCollection']), typeIMetCorrections=True) getattr(process, 'pfPileUp' + pfpostfix).checkClosestZVertex = False # switch off all top projections getattr(process, 'pfNoMuon' + pfpostfix).enable = False getattr(process, 'pfNoElectron' + pfpostfix).enable = False getattr(process, 'pfNoJet' + pfpostfix).enable = False getattr(process, 'pfNoTau' + pfpostfix).enable = False # agrohsje don't require isolation on cmsRun level !!! # seems not to work -> check with python -i ? getattr(process, 'pfIsolatedElectrons' +
def addPATSequences(process,runMC): # Load the PAT config from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('patTuple.root'), SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('pat_step') ), outputCommands = cms.untracked.vstring('drop *', *patEventContent ) ) ### process.load('PhysicsTools.PatAlgos.patSequences_cff') from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT postfix = "PFlow" jetAlgo="AK5" jetCorrections = None if runMC: jetCorrections = ('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute']) else: jetCorrections = ('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute','L2L3Residual']) usePF2PAT(process,runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runMC, postfix=postfix,jetCorrections=jetCorrections) #from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching #if not runMC: # removeMCMatching(process, ['All'],"") #-----------------Customization---------------- process.pfPileUpPFlow.Enable = True process.pfPileUpPFlow.checkClosestZVertex = False process.pfPileUpPFlow.Vertices = cms.InputTag('goodOfflinePrimaryVertices') process.pfPileUpPFlow.verbose = True process.pfJetsPFlow.doAreaFastjet = True process.pfJetsPFlow.doRhoFastjet = False from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ), src=cms.InputTag('offlinePrimaryVertices') ) # Compute the mean pt per unit area (rho) from the PFCHS inputs #from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets,ak5PFJets #process.kt6PFJetsPFlow = kt6PFJets.clone( # src = cms.InputTag('pfNoElectron'+postfix), # doAreaFastjet = cms.bool(True), # doRhoFastjet = cms.bool(True) # ) #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho") from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForPAT = kt4PFJets.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsForPAT", "rho") from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets process.ak5PFJetsPileUp = ak5PFJets.clone( src = cms.InputTag('pfPileUp'+postfix) ) # Switch on PAT trigger from PhysicsTools.PatAlgos.tools.trigTools import switchOnTrigger #switchOnTrigger( process,triggerProducer = 'patTrigger', triggerEventProducer = 'patTriggerEvent', sequence = 'patPF2PATSequence',hltProcess = 'HLT', outputModule = 'out') switchOnTrigger( process ,sequence ='patPF2PATSequence'+postfix) process.patTrigger.addL1Algos = cms.bool( True ) switchOnTrigger( process ,sequence = 'patPF2PATSequence'+postfix) # to fix event content #------------------------------------------------------------------------------------------------------------- # Add modules to default sequence #if runMC: # getattr(process, "patElectrons"+postfix).embedGenMatch = True # getattr(process, "patMuons"+postfix).embedGenMatch = True #else: # getattr(process, "patElectrons"+postfix).embedGenMatch = False # getattr(process, "patMuons"+postfix).embedGenMatch = False # Add modules to default sequence getattr(process,"patPF2PATSequence"+postfix).replace( getattr(process,"pfNoElectron"+postfix), getattr(process,"pfNoElectron"+postfix)*process.kt6PFJetsForPAT ) getattr(process,"patPF2PATSequence"+postfix).replace( getattr(process,"pfNoPileUp"+postfix), getattr(process,"pfNoPileUp"+postfix) * process.ak5PFJetsPileUp ) #---------------------------------------------- # Let it run process.pat_step = cms.Path( process.goodOfflinePrimaryVertices * #process.patDefaultSequence + getattr(process,"patPF2PATSequence"+postfix) ) # Add PatTrigger output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patTriggerEventContent # Add PF2PAT output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning patOutputCommands = cms.untracked.vstring('drop *', 'keep recoPFCandidates_particleFlow_*_*', *patEventContentNoCleaning) # Adjust the event content patOutputCommands += [ #'keep *_selectedPat*_*_*', 'keep *_genParticles*_*_*', 'keep *_offlinePrimaryVertices*_*_*', 'keep *_goodOfflinePrimaryVertices*_*_*', #'keep *_pileUpN*PrimaryVertices_*_*', #'keep *_pfPileUpExclN*_*_*', 'keep *_pfPileUpPFlow*_*_*', 'keep *_pfNoPileUpPFlow*_*_*', 'keep *_ak5PFJetsPileUp_*_*', 'keep *_ak5PFJets_*_*', 'keep recoTracks_generalTracks_*_*', 'keep HcalNoiseSummary_hcalnoise_*_*', 'keep *_BeamHaloSummary_*_*', #------- Trigger collections ------ 'keep edmTriggerResults_TriggerResults_*_*', 'keep *_hltTriggerSummaryAOD_*_*', 'keep L1GlobalTriggerObjectMapRecord_*_*_*', 'keep L1GlobalTriggerReadoutRecord_*_*_*', #------- CASTOR rec hits ------ 'keep *_logErrorHarvester_*_*', 'keep *_castorreco_*_*', #------- Calo towers (just for now) ------ 'keep *_towerMaker_*_*', #---------------PatTrigger---------------- 'keep patTriggerObjects_patTrigger*_*_*', 'keep patTriggerFilters_patTrigger*_*_*', 'keep patTriggerPaths_patTrigger*_*_*', 'keep patTriggerEvent_patTriggerEvent*_*_*' ] process.out.outputCommands = patOutputCommands # top projections in PF2PAT: getattr(process,"pfNoPileUp"+postfix).enable = True getattr(process,"pfNoMuon"+postfix).enable = True getattr(process,"pfNoElectron"+postfix).enable = True getattr(process,"pfNoTau"+postfix).enable = False getattr(process,"pfNoJet"+postfix).enable = True # verbose flags for the PF2PAT modules getattr(process,"pfNoJet"+postfix).verbose = False
## Create and define reco objects if runOnAOD: muonTag = 'patMuons' + pfpostfix metTag = 'patMETs' + pfpostfix ## Output module for edm files (needed for PAT sequence, even if not used in EndPath) from Configuration.EventContent.EventContent_cff import FEVTEventContent process.out = cms.OutputModule("PoolOutputModule", FEVTEventContent, dataset = cms.untracked.PSet(dataTier = cms.untracked.string('RECO')), fileName = cms.untracked.string("eh.root"), ) # add particle flow process.load("PhysicsTools.PatAlgos.patSequences_cff") from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT=True, jetAlgo='AK4', runOnMC=runOnMC, postfix=pfpostfix, jetCorrections=jetCorr, pvCollection=cms.InputTag('offlinePrimaryVertices'),typeIMetCorrections=True) getattr(process, 'pfPileUp'+pfpostfix).checkClosestZVertex = False # switch off all top projections getattr(process,'pfNoMuon'+pfpostfix).enable = False getattr(process,'pfNoElectron'+pfpostfix).enable = False getattr(process,'pfNoJet'+pfpostfix).enable = False getattr(process,'pfNoTau'+pfpostfix).enable = False # agrohsje don't require isolation on cmsRun level !!! # tarndt especially don't require it in the default pf2pat process # PFBRECO is subset of pf2pat processes getattr(process,'pfIsolatedElectronsPFBRECO'+pfpostfix).cut='' getattr(process,'pfElectronsFromVertexPFBRECO'+pfpostfix).d0Cut = cms.double(999999.) getattr(process,'pfElectronsFromVertexPFBRECO'+pfpostfix).dzCut = cms.double(999999.) getattr(process,'pfIsolatedMuonsPFBRECO'+pfpostfix).cut = ''
process.patDefaultSequence.replace( process.patElectrons, process.eidMVASequence * process.patElectrons ) ## Load trigger matching ## Trigger matching with PAT process.load("MuonAnalysis.MuonAssociators.patMuonsWithTrigger_cff") process.muonMatchHLTL2.maxDeltaR = 0.3 # Zoltan tuning - it was 0.5 process.muonMatchHLTL3.maxDeltaR = 0.1 ## Apply PF2PAT from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT if runOnMC: jecLevels = ['L1FastJet','L2Relative','L3Absolute'] else: jecLevels = ['L1FastJet','L2Relative', 'L3Absolute', 'L2L3Residual'] #usePFBRECO(process,runPFBRECO=True, usePF2PAT(process, runPF2PAT=True, runOnMC=runOnMC, outputModules = outputModules, postfix="PFlow", jetAlgo="AK5", jetCorrections=("AK5PFchs", jecLevels), typeIMetCorrections=True) # top projections in PF2PAT: process.pfNoPileUpPFlow.enable = True process.pfNoMuonPFlow.enable = True process.pfNoElectronPFlow.enable = True process.pfNoTauPFlow.enable = False process.pfNoJetPFlow.enable = True # verbose flags for the PF2PAT modules process.pfNoMuonPFlow.verbose = False """ # Change DR cone size to 0.3 process.pfIsolatedMuonsPFlow.isolationValueMapsCharged = cms.VInputTag(cms.InputTag('muPFIsoValueCharged03PFlow'))
#, PdfSetNames = cms.untracked.vstring( 'cteq66.LHgrid', 'CT10.LHgrid' ) ) ### PAT process.load( "PhysicsTools.PatAlgos.patSequences_cff" ) # Misc if len( jecLevels ) is 0: typeIMetCorrections = False from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT( process , runOnMC = runOnMC , jetAlgo = jetAlgo , jetCorrections = ( jetAlgo + 'PFchs' , jecLevels ) , typeIMetCorrections = typeIMetCorrections , pvCollection = cms.InputTag( pvCollection ) , outputModules = outputModules ) from PhysicsTools.PatAlgos.tools.helpers import removeIfInSequence removeIfInSequence( process, 'patPFParticles', 'patPF2PATSequence', '' ) removeIfInSequence( process, 'selectedPatPFParticles', 'patPF2PATSequence', '' ) removeIfInSequence( process, 'countPatPFParticles', 'patPF2PATSequence', '' ) from PhysicsTools.PatAlgos.tools.coreTools import * removeSpecificPATObjects( process , names = [ 'Photons', 'Taus' ] , outputModules = outputModules ) # The following is not performed (properly) by 'removeSpecificPATObjects()' process.cleanPatCandidateSummary.candidates.remove( cms.InputTag( 'cleanPatPhotons' ) )
if useL2L3Residual and not runOnMC: jecLevels.append( 'L2L3Residual' ) if useL5Flavor: jecLevels.append( 'L5Flavor' ) if useL7Parton: jecLevels.append( 'L7Parton' ) ### Switch configuration from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT( process , runPF2PAT = True , runOnMC = runOnMC , jetAlgo = jetAlgo , postfix = postfix , jetCorrections = ( jecSet , jecLevels ) , typeIMetCorrections = typeIMetCorrections , pvCollection = cms.InputTag( pfVertices ) ) if useMuonCutBasePF: pfMuonSelectionCut += ' && %s'%( muonCut ) if useElectronCutBasePF: pfElectronSelectionCut += ' && %s'%( electronCut ) getattr( process, 'pfNoPileUp' + postfix ).enable = usePFnoPU getattr( process, 'pfNoMuon' + postfix ).enable = useNoMuon getattr( process, 'pfNoElectron' + postfix ).enable = useNoElectron getattr( process, 'pfNoJet' + postfix ).enable = useNoJet
outputCommands = cms.untracked.vstring( 'keep *' ), SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('patreco') ), fileName=cms.untracked.string("SynchSelMuJets.root") ) process.add_( cms.Service( "TFileService", fileName = cms.string( options.output ), closeFileFast = cms.untracked.bool(True) ) ) from TopQuarkAnalysis.Configuration.patRefSel_PF2PAT import * process.load("PhysicsTools.PatAlgos.patSequences_cff") from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT topPF2PAT = usePF2PAT(process,runOnMC = not options.isData,typeIMetCorrections = True,pvCollection= "goodOfflinePrimaryVertices",postfix=options.postfix) #configuration object for patPF2PATSequence process.GlobalTag.globaltag = options.globalTag + '::All' process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool( not options.quiet )) process.MessageLogger.cerr.FwkReport.reportEvery = 1000 if options.quiet else 10 process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32( options.maxEvents )) if not options.isData : process.eventCleaning.remove( process.scrapingFilter ) for item in ['mvaNonTrigV0'] : delattr( process, item ) process.patreco = cms.Path( reduce(operator.add, [getattr(process, item) for item in ['goodOfflinePrimaryVertices', 'eventCleaning', 'mvaTrigV0', 'patPF2PATSequence'+options.postfix]])) #process.load('TopQuarkAnalysis.TopRefTuple.lumi_cfi')