def setup_MET_uncertainties(process, cms, options, postfix="PFlow"): from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties #runMEtUncertainties(process, doSmearJets=not options.useData, jetCollection='goodPatJetsPFlow', addToPatDefaultSequence=False) if options.useData: inputJetCorrLabelForMETuncertainties = 'L2L3Residual' metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_data else: inputJetCorrLabelForMETuncertainties = 'L3Absolute' metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc process.pfMEtSysShiftCorr.parameter = metSysShiftCorrParameter runMEtUncertainties(process, electronCollection = cms.InputTag('cleanPatElectrons'), muonCollection = 'cleanPatMuons', tauCollection = 'cleanPatTaus', jetCollection = cms.InputTag('goodPatJetsPFlow'), jetCorrLabel = inputJetCorrLabelForMETuncertainties, doSmearJets = not options.useData, makeType1corrPFMEt = True, makeType1p2corrPFMEt = True, makePFMEtByMVA = False, makeNoPileUpPFMEt = False, doApplyType0corr = options.applyType0METcorrection, sysShiftCorrParameter = metSysShiftCorrParameter, doApplySysShiftCorr = options.applySysShiftCorrection, addToPatDefaultSequence=False )
def metUncertainty(process): process.load("PhysicsTools.PatAlgos.patSequences_cff") #process.MetSequence += process.type0PFMEtCorrection #process.MetSequence += process.patPFMETtype0Corr #from PhysicsTools.PatAlgos.patTemplate_cfg import * #from PhysicsTools.PatAlgos.tools.coreTools import * from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection #from PhysicsTools.PatAlgos.tools.metTools import * switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=True, doBTagging=False, jetCorrLabel=('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])), doType1MET=False, doJetID=True, jetIdLabel="ak5", outputModules=[] # no PAT output module ) from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process)
def metUncertainty(process): process.load("PhysicsTools.PatAlgos.patSequences_cff") # process.MetSequence += process.type0PFMEtCorrection # process.MetSequence += process.patPFMETtype0Corr # from PhysicsTools.PatAlgos.patTemplate_cfg import * # from PhysicsTools.PatAlgos.tools.coreTools import * from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection # from PhysicsTools.PatAlgos.tools.metTools import * switchJetCollection( process, cms.InputTag("ak5PFJets"), doJTA=True, doBTagging=False, jetCorrLabel=("AK5PF", cms.vstring(["L1FastJet", "L2Relative", "L3Absolute"])), doType1MET=False, doJetID=True, jetIdLabel="ak5", outputModules=[], # no PAT output module ) from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process)
def setup_MET_uncertainties(process, cms, options, postfix="PFlow"): from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties #runMEtUncertainties(process, doSmearJets=not options.useData, jetCollection='goodPatJetsPFlow', addToPatDefaultSequence=False) if options.useData: inputJetCorrLabelForMETuncertainties = 'L2L3Residual' if options.centreOfMassEnergy == 8: metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data print "using pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data" elif options.centreOfMassEnergy == 7: metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_data print "using pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_data" else: inputJetCorrLabelForMETuncertainties = 'L3Absolute' if options.centreOfMassEnergy == 8: metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc print "using pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc" elif options.centreOfMassEnergy == 7: metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_mc print "using pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_mc" process.pfMEtSysShiftCorr.parameter = metSysShiftCorrParameter runMEtUncertainties(process, electronCollection=cms.InputTag('patElectronsPFlow'), muonCollection='patMuonsPFlow', tauCollection='patTausPFlow', jetCollection=cms.InputTag('goodPatJetsPFlow'), jetCorrLabel=inputJetCorrLabelForMETuncertainties, doSmearJets=not options.useData, makeType1corrPFMEt=True, makeType1p2corrPFMEt=True, makePFMEtByMVA=False, makeNoPileUpPFMEt=False, doApplyType0corr=options.applyType0METcorrection, sysShiftCorrParameter=metSysShiftCorrParameter, doApplySysShiftCorr=options.applySysShiftCorrection, addToPatDefaultSequence=False)
def addInvHiggsProcess(process, iRunOnData=True, iData="PromptC2", iHLTFilter="MET", iMCSignal=False, iFile='/store/data/Run2012C/MET/AOD/PromptReco-v2/000/203/002/04BCEC26-AA02-E211-A81D-003048CF99BA.root', iMaxEvent=100): ###-------------------------------------------------------------- ### Load PAT, because it insists on defining the process for you #from PhysicsTools.PatAlgos.patTemplate_cfg import * ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Input process.maxEvents.input = iMaxEvent process.source.fileNames = [iFile] ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### GlobalTag if iRunOnData == True: if (iData.find("Jul13")==0): process.GlobalTag.globaltag = "FT_53_V6C_AN3::All" elif (iData.find("Aug06")==0): process.GlobalTag.globaltag = "FT_53_V6C_AN3::All" elif (iData.find("Aug24")==0): process.GlobalTag.globaltag = "FT53_V10A_AN3::All" elif (iData.find("PromptC2")==0): process.GlobalTag.globaltag = "GR_P_V42_AN3::All" elif (iData.find("PromptD")==0): process.GlobalTag.globaltag = "GR_P_V42_AN3::All" elif (iData.find("Dec11")==0): #Run201191 process.GlobalTag.globaltag = "FT_P_V42C_AN3::All" else: process.GlobalTag.globaltag = "GR_P_V42_AN3::All" else: process.GlobalTag.globaltag = "START53_V7G::All" ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Logger process.load("FWCore.MessageService.MessageLogger_cfi") process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport = cms.untracked.PSet( reportEvery = cms.untracked.int32(2000), limit = cms.untracked.int32(10000000) ) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### HLT Trigger(s) # If it's MC signal, no trigger will be applied if iRunOnData == False and iMCSignal == True: iHLTFilter = "NoTrig" # Load hltHighLevel process.load('HLTrigger.HLTfilters.hltHighLevel_cfi') process.hltHighLevel.TriggerResultsTag = cms.InputTag("TriggerResults","","HLT") process.hltHighLevel.throw = cms.bool(False) # Tolerate if triggers not available process.hltHighLevel.andOr = cms.bool(True) # True = OR, False = AND if (iHLTFilter.find("MET")==0): process.hltHighLevel.HLTPaths = cms.vstring( "HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*" ) elif (iHLTFilter.find("SingleMu")==0): process.hltHighLevel.HLTPaths = cms.vstring("HLT_IsoMu24_eta2p1_v*","HLT_Mu40_eta2p1_v*") elif (iHLTFilter.find("DoubleMu")==0): process.hltHighLevel.HLTPaths = cms.vstring("HLT_Mu17_Mu8_v*") elif (iHLTFilter.find("SingleElectron")==0): process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele27_WP80_v*") elif (iHLTFilter.find("DoubleElectron")==0): process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*") elif (iHLTFilter.find("NoTrig")==0): process.hltHighLevel.HLTPaths = cms.vstring("*") else: process.hltHighLevel.HLTPaths = cms.vstring( "HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*" ) ###-------------------------------------------------------------- ###-------------------------------------------------------------- print "-----------------------------------------------" print "INVISIBLE HIGGS: Ntuple V10" print "-----------------------------------------------" print "RunOnData = ", iRunOnData if iRunOnData == True: print "Dataset = ", iData else: if iMCSignal == True: print "Dataset = MC Signal" else: print "Dataset = MC Background" print "GlobalTag = ", process.GlobalTag.globaltag print "Trigger = ", process.hltHighLevel.HLTPaths print "Sample input file = ", iFile print "Max events = ", iMaxEvent print "-----------------------------------------------" ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Basic filters # Track quality filter process.noscraping = cms.EDFilter( "FilterOutScraping", applyfilter = cms.untracked.bool(True), debugOn = cms.untracked.bool(False), numtrack = cms.untracked.uint32(10), thresh = cms.untracked.double(0.25) ) # Require a good vertex 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) ) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### MET Filters # The iso-based HBHE noise filter process.load('CommonTools.RecoAlgos.HBHENoiseFilter_cfi') # The CSC beam halo tight filter process.load('RecoMET.METAnalyzers.CSCHaloFilter_cfi') # The HCAL laser filter process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi") process.load("EventFilter.HcalRawToDigi.hcallasereventfilter2012_cff") process.hcallasereventfilter2012.eventFileName = cms.string('HCALLaser2012AllDatasets.txt.gz') # The ECAL dead cell trigger primitive filter process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi') # The EE bad SuperCrystal filter process.load('RecoMET.METFilters.eeBadScFilter_cfi') # The ECAL laser correction filter process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi') # The Good vertices collection needed by the tracking failure filter process.goodVertices = cms.EDFilter( "VertexSelector", filter = cms.bool(False), src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.rho < 2") ) # The tracking failure filter process.load('RecoMET.METFilters.trackingFailureFilter_cfi') # The tracking POG filters process.load('RecoMET.METFilters.trackingPOGFilters_cff') ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### customise PAT process.load('JetMETCorrections.Configuration.DefaultJEC_cff') from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching,runOnData if iRunOnData == True: removeMCMatching(process, ['All']) runOnData(process) # Add the PF MET from PhysicsTools.PatAlgos.tools.metTools import addPfMET addPfMET(process, 'PF') # Switch to PF jets from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection if iRunOnData == True: switchJetCollection(process, cms.InputTag('ak5PFJets'), doJTA = True, doBTagging = True, jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']), doType1MET = True, doJetID = False, jetIdLabel = "ak5" ) else: switchJetCollection(process, cms.InputTag('ak5PFJets'), doJTA = True, doBTagging = True, jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']), doType1MET = True, genJetCollection = cms.InputTag("ak5GenJetsNoNu"), doJetID = False, jetIdLabel = "ak5" ) from PhysicsTools.PatAlgos.tools.pfTools import usePFIso usePFIso(process) process.patMuons.isoDeposits = cms.PSet() process.patMuons.isolationValues = cms.PSet() process.patElectrons.isolationValues = cms.PSet( pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03PFIdPFIso"), pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03PFIdPFIso"), pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03PFIdPFIso"), pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03PFIdPFIso"), pfPhotons = cms.InputTag("elPFIsoValueGamma03PFIdPFIso") ) process.patElectrons.isolationValuesNoPFId = cms.PSet( pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03NoPFIdPFIso"), pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03NoPFIdPFIso"), pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03NoPFIdPFIso"), pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03NoPFIdPFIso"), pfPhotons = cms.InputTag("elPFIsoValueGamma03NoPFIdPFIso") ) process.patDefaultSequence.replace(process.patElectrons,process.eleIsoSequence+process.patElectrons) process.cleanPatTaus.preselection = cms.string('tauID("decayModeFinding") > 0.5 & tauID("byLooseCombinedIsolationDeltaBetaCorr") > 0.5') ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Object (pre) selection # Jet selection process.selectedPatJets.cut = cms.string("pt>10. && abs(eta)<5.") # Remove overlaps ??? # process.cleanPatJets.finalCut = "!hasOverlaps('electrons') && !hasOverlaps('muons')" # Apply loose PF jet ID from PhysicsTools.SelectorUtils.pfJetIDSelector_cfi import pfJetIDSelector process.goodPatJets = cms.EDFilter("PFJetIDSelectionFunctorFilter", filterParams = pfJetIDSelector.clone(), src = cms.InputTag("selectedPatJets"), filter = cms.bool(True) ) process.selectedPatMuons.cut = cms.string("isGlobalMuon && pt>10. && abs(eta)<2.5") process.selectedPatElectrons.cut = cms.string("pt>10. && abs(eta)<2.5") ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Load the PU JetID sequence if iRunOnData == True: process.load("CMGTools.External.pujetidsequence_cff") process.puJetMva.jets = cms.InputTag("goodPatJets") process.puJetId.jets = cms.InputTag("goodPatJets") else: process.load("CMGTools.External.pujetidsequence_cff") process.puJetMva.jets = cms.InputTag("goodPatJets") process.puJetId.jets = cms.InputTag("goodPatJets") process.puJetMvaSmeared = process.puJetMva.clone() process.puJetIdSmeared = process.puJetId.clone() process.puJetMvaResUp = process.puJetMva.clone() process.puJetIdResUp = process.puJetId.clone() process.puJetMvaResDown = process.puJetMva.clone() process.puJetIdResDown = process.puJetId.clone() process.puJetMvaEnUp = process.puJetMva.clone() process.puJetIdEnUp = process.puJetId.clone() process.puJetMvaEnDown = process.puJetMva.clone() process.puJetIdEnDown = process.puJetId.clone() process.puJetIdSmeared.jets = cms.InputTag("smearedGoodPatJetsWithGaussian") process.puJetMvaSmeared.jetids = cms.InputTag("puJetIdSmeared") process.puJetMvaSmeared.jets = cms.InputTag("smearedGoodPatJetsWithGaussian") process.puJetIdResUp.jets = cms.InputTag("smearedGoodPatJetsResUpWithGaussian") process.puJetMvaResUp.jetids = cms.InputTag("puJetIdResUp") process.puJetMvaResUp.jets = cms.InputTag("smearedGoodPatJetsResUpWithGaussian") process.puJetIdResDown.jets = cms.InputTag("smearedGoodPatJetsResDownWithGaussian") process.puJetMvaResDown.jetids = cms.InputTag("puJetIdResDown") process.puJetMvaResDown.jets = cms.InputTag("smearedGoodPatJetsResDownWithGaussian") process.puJetIdEnUp.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtWithGaussian") process.puJetMvaEnUp.jetids = cms.InputTag("puJetIdEnUp") process.puJetMvaEnUp.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtWithGaussian") process.puJetIdEnDown.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtWithGaussian") process.puJetMvaEnDown.jetids = cms.InputTag("puJetIdEnDown") process.puJetMvaEnDown.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtWithGaussian") # For jet without Gaussian smearing collection process.puJetMvaSmearedNoGaussian = process.puJetMva.clone() process.puJetIdSmearedNoGaussian = process.puJetId.clone() process.puJetMvaResUpNoGaussian = process.puJetMva.clone() process.puJetIdResUpNoGaussian = process.puJetId.clone() process.puJetMvaResDownNoGaussian = process.puJetMva.clone() process.puJetIdResDownNoGaussian = process.puJetId.clone() process.puJetMvaEnUpNoGaussian = process.puJetMva.clone() process.puJetIdEnUpNoGaussian = process.puJetId.clone() process.puJetMvaEnDownNoGaussian = process.puJetMva.clone() process.puJetIdEnDownNoGaussian = process.puJetId.clone() process.puJetIdSmearedNoGaussian.jets = cms.InputTag("smearedGoodPatJetsNoGaussian") process.puJetMvaSmearedNoGaussian.jetids = cms.InputTag("puJetIdSmearedNoGaussian") process.puJetMvaSmearedNoGaussian.jets = cms.InputTag("smearedGoodPatJetsNoGaussian") process.puJetIdResUpNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResUpNoGaussian") process.puJetMvaResUpNoGaussian.jetids = cms.InputTag("puJetIdResUpNoGaussian") process.puJetMvaResUpNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResUpNoGaussian") process.puJetIdResDownNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResDownNoGaussian") process.puJetMvaResDownNoGaussian.jetids = cms.InputTag("puJetIdResDownNoGaussian") process.puJetMvaResDownNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResDownNoGaussian") process.puJetIdEnUpNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtNoGaussian") process.puJetMvaEnUpNoGaussian.jetids = cms.InputTag("puJetIdEnUpNoGaussian") process.puJetMvaEnUpNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtNoGaussian") process.puJetIdEnDownNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtNoGaussian") process.puJetMvaEnDownNoGaussian.jetids = cms.InputTag("puJetIdEnDownNoGaussian") process.puJetMvaEnDownNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtNoGaussian") ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### MET # Apply type 0 MET corrections based on PFCandidate process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi") process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False) process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag( cms.InputTag('pfMETcorrType0'), cms.InputTag('pfJetMETcorr', 'type1') ) # Get loose ID/Iso muons and veto ID electrons process.load("InvisibleHiggs.Ntuple.PhysicsObjectCandidates_cff") # Get PFMET from runMEtUncertainties from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi") if iRunOnData == True: runMEtUncertainties(process, electronCollection = cms.InputTag('selectVetoElectrons'), photonCollection = '', muonCollection = 'selectLooseMuons', tauCollection = '', jetCollection = cms.InputTag('goodPatJets'), jetCorrLabel = 'L2L3Residual', doSmearJets = False, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, makePFMEtByMVA = False, makeNoPileUpPFMEt = False, doApplyType0corr = True, sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_data, doApplySysShiftCorr = False, addToPatDefaultSequence = False, postfix = '' ) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string('L2L3Residual') process.patPFJetMETtype2Corr.jetCorrLabel = cms.string('L2L3Residual') else: runMEtUncertainties(process, electronCollection = cms.InputTag('selectVetoElectrons'), photonCollection = '', muonCollection = 'selectLooseMuons', tauCollection = '', jetCollection = cms.InputTag('goodPatJets'), jetCorrLabel = 'L3Absolute', doSmearJets = True, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, makePFMEtByMVA = False, makeNoPileUpPFMEt = False, doApplyType0corr = True, sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc, doApplySysShiftCorr = False, addToPatDefaultSequence = False, postfix = 'WithGaussian' ) runMEtUncertainties(process, electronCollection = cms.InputTag('selectVetoElectrons'), photonCollection = '', muonCollection = 'selectLooseMuons', tauCollection = '', jetCollection = cms.InputTag('goodPatJets'), jetCorrLabel = 'L3Absolute', doSmearJets = True, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, makePFMEtByMVA = False, makeNoPileUpPFMEt = False, doApplyType0corr = True, sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc, doApplySysShiftCorr = False, addToPatDefaultSequence = False, postfix = 'NoGaussian' ) # Turn off gaussian smearing process.smearedGoodPatJetsNoGaussian.doGaussian = cms.int32(0) process.smearedGoodPatJetsResUpNoGaussian.doGaussian = cms.int32(0) process.smearedGoodPatJetsResDownNoGaussian.doGaussian = cms.int32(0) # Fix Type0 correction module process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209) process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531) process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151) process.patPFMETtype0Corr.correction.par0 = cms.double(0.0) ###-------------------------------------------------------------- # PAT/ntuples one step # Z and W candidates process.load('InvisibleHiggs/Ntuple/WCandidates_cff') process.load('InvisibleHiggs/Ntuple/ZCandidates_cff') # Ntuple producer process.load('InvisibleHiggs/Ntuple/invHiggsInfo_cfi') if iRunOnData == False: # Jet/MET uncertainty process.invHiggsInfo.jetTag = cms.untracked.InputTag("smearedGoodPatJetsWithGaussian") process.invHiggsInfo.metTag = cms.untracked.InputTag("patType1CorrectedPFMetWithGaussian") process.invHiggsInfo.puJetMvaTag = cms.untracked.InputTag("puJetMvaSmeared", "fullDiscriminant") process.invHiggsInfo.puJetIdTag = cms.untracked.InputTag("puJetMvaSmeared", "fullId") # PU re-weighting process.invHiggsInfo.puMCFile = cms.untracked.string("PUHistS10.root") process.invHiggsInfo.puDataFile = cms.untracked.string("PUHistRun2012All_forV9.root") process.invHiggsInfo.puMCHist = cms.untracked.string("pileup") process.invHiggsInfo.puDataHist = cms.untracked.string("pileup") process.invHiggsInfo.mcPYTHIA = cms.untracked.bool(True) process.invHiggsInfo.trigCorrFile = cms.untracked.string("DataMCWeight_53X_v1.root") process.invHiggsInfo.leptCorrFile = cms.untracked.string("leptonWeights.root") # TTree output file process.load("CommonTools.UtilAlgos.TFileService_cfi") process.TFileService.fileName = cms.string('invHiggsInfo_MC.root') ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Tau # removeSpecificPATObjects( process, ['Taus'] ) # process.patDefaultSequence.remove( process.patTaus ) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Trigger matching # from PhysicsTools.PatAlgos.tools.trigTools import * # process.metTriggerMatch = cms.EDProducer( # "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR # , src = cms.InputTag( 'patMETs' ) # , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py # , matchedCuts = cms.string( 'path( "HLT_MET100_v*" )' ) # , maxDPtRel = cms.double( 0.5 ) # , maxDeltaR = cms.double( 0.5 ) # , resolveAmbiguities = cms.bool( True ) # only one match per trigger object # , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above) # ) # process.jetTriggerMatch = cms.EDProducer( # "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR # , src = cms.InputTag( 'patJets' ) # , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py # , matchedCuts = cms.string( 'path( "HLT_Jet30_v*" )' ) # , maxDPtRel = cms.double( 0.5 ) # , maxDeltaR = cms.double( 0.5 ) # , resolveAmbiguities = cms.bool( True ) # only one match per trigger object # , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above) # ) # switchOnTriggerMatchEmbedding( process, [ 'metTriggerMatch', 'jetTriggerMatch' ] ) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Paths process.p0 = cms.Path( process.HBHENoiseFilter ) process.p1 = cms.Path( process.CSCTightHaloFilter ) process.p2 = cms.Path( process.hcalLaserEventFilter ) process.p3 = cms.Path( process.EcalDeadCellTriggerPrimitiveFilter ) process.p4 = cms.Path( process.eeBadScFilter ) process.p5 = cms.Path( process.ecalLaserCorrFilter ) process.p6 = cms.Path( process.goodVertices * process.trackingFailureFilter ) process.p7 = cms.Path( process.trkPOGFilters ) process.p8 = cms.Path( process.hcallLaserEvent2012Filter ) if iRunOnData == True: process.p = cms.Path( # Trigger filter process.hltHighLevel * # Basic filters process.noscraping * process.primaryVertexFilter * # MET filters (Move to be flags) # MET Correction process.type0PFMEtCorrection * # Tau process.recoTauClassicHPSSequence * # Generate PAT process.pfParticleSelectionSequence * process.patDefaultSequence * process.goodPatJets * process.PhysicsObjectSequence * process.metUncertaintySequence * process.puJetIdSqeuence * process.WSequence * process.ZSequence * process.invHiggsInfo ) else: process.p = cms.Path( # Trigger filter process.hltHighLevel * # Basic filters process.noscraping * process.primaryVertexFilter * # MET filters (Move to be flags) # MET Correction process.type0PFMEtCorrection * # Tau process.recoTauClassicHPSSequence * # Generate PAT process.pfParticleSelectionSequence * process.genParticlesForJetsNoNu * process.ak5GenJetsNoNu * process.patDefaultSequence * process.goodPatJets * process.PhysicsObjectSequence * process.metUncertaintySequenceWithGaussian * process.metUncertaintySequenceNoGaussian * process.puJetIdSqeuence * process.puJetIdSmeared * process.puJetMvaSmeared * process.puJetIdResUp * process.puJetMvaResUp * process.puJetIdResDown * process.puJetMvaResDown * process.puJetIdEnUp * process.puJetMvaEnUp * process.puJetIdEnDown * process.puJetMvaEnDown * process.puJetIdSmearedNoGaussian * process.puJetMvaSmearedNoGaussian * process.puJetIdResUpNoGaussian * process.puJetMvaResUpNoGaussian * process.puJetIdResDownNoGaussian * process.puJetMvaResDownNoGaussian * process.puJetIdEnUpNoGaussian * process.puJetMvaEnUpNoGaussian * process.puJetIdEnDownNoGaussian * process.puJetMvaEnDownNoGaussian * process.WSequence * process.ZSequence * process.invHiggsInfo ) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Output process.out.outputCommands += [ # trigger results 'keep edmTriggerResults_*_*_*' ,'keep *_hltTriggerSummaryAOD_*_*' # L1 ,'keep *_l1extraParticles_MET_RECO' ,'keep *_l1extraParticles_MHT_RECO' # good jets ,'keep *_goodPatJets_*_*' # PU jet ID ,'keep *_puJetId*_*_*' ,'keep *_puJetMva*_*_*' # vertices ,'keep *_offlineBeamSpot_*_*' ,'keep *_offlinePrimaryVertices*_*_*' ,'keep *_goodOfflinePrimaryVertices*_*_*' ,'keep double_*_rho_*' ] if iRunOnData == False: process.out.outputCommands += ['keep GenEventInfoProduct_*_*_*' ,'keep recoGenParticles_*_*_*' ,'keep GenMETs_*_*_*' ,'keep *_addPileupInfo_*_*' ,'keep LHEEventProduct_*_*_*' ,'keep ak5GenJets_*_*_*' ,'keep ak5GenJetsNoNu_*_*_*' ] process.out.fileName = 'patTuple.root' del(process.out) del(process.outpath)
def SingleTopStep1( process, ): options = VarParsing('analysis') options.register ('isMC', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Run on MC" ) options.register ('doDebug', False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Run in debugging mode" ) options.register ('doSkimming', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Preselect events" ) options.register ('doSlimming', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Drop unnecessary collections" ) options.register ('runOnFastSim', False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "FastSim-specific processing" ) options.register ('doSync', False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Synchronization exercise" ) #Tag from https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideFrontierConditions?redirectedfrom=CMS.SWGuideFrontierConditions#2012_MC_production #Latest for "53Y Releases (MC)" options.register ('globalTag', Config.globalTagMC, VarParsing.multiplicity.singleton, VarParsing.varType.string, "Global tag" ) options.parseArguments() if len(options.inputFiles)==0: options.inputFiles = cms.untracked.vstring(['/store/relval/CMSSW_5_3_6-START53_V14/RelValProdTTbar/AODSIM/v2/00000/76ED0FA6-1E2A-E211-B8F1-001A92971B72.root']) process.source.fileNames = cms.untracked.vstring(options.inputFiles) process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(options.maxEvents) ) process.out.fileName = cms.untracked.string(options.outputFile) process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(options.doDebug)) if options.doDebug: process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger = cms.Service("MessageLogger", destinations=cms.untracked.vstring('cout', 'debug'), debugModules=cms.untracked.vstring('*'), cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')), debug=cms.untracked.PSet(threshold=cms.untracked.string('DEBUG')), ) else: process.load("FWCore.MessageService.MessageLogger_cfi") #https://twiki.cern.ch/twiki/bin/viewauth/CMS/IntroToJEC #https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCor2012Summer13 postfix = "" jetCorr = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not options.isMC: jetCorr += ['L2L3Residual'] print options usePF2PAT(process, runPF2PAT=True, jetAlgo='AK5', runOnMC=options.isMC, postfix=postfix, jetCorrections=('AK5PFchs', jetCorr), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), #typeIMetCorrections = True typeIMetCorrections = False #Type1 MET now applied later using runMETUncertainties ) # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012 process.pfPileUp.Enable = True process.pfPileUp.checkClosestZVertex = False #------------------------------------------------- # selection step 2: vertex filter #------------------------------------------------- # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012 # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters #process.goodOfflinePrimaryVertices = cms.EDFilter( # "PrimaryVertexObjectFilter" #, filterParams = cms.PSet( # minNdof = cms.double(4.0) # , maxZ = cms.double(24.0) # , maxRho = cms.double(2.0) # ) #, filter = cms.bool(True) #, src = cms.InputTag('offlinePrimaryVertices') #) process.goodOfflinePrimaryVertices = cms.EDFilter("FirstVertexFilter", src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string('!isFake & ndof >= 4. & abs(z) < 24. & position.Rho < 2.') ) from EventFilters_cff import ApplyEventFilters ApplyEventFilters(process, runOnFastSim=options.runOnFastSim) #------------------------------------------------- # Muons #------------------------------------------------- #process.selectedPatMuons.cut = "pt>10 && abs(eta)<3.0" # Enable delta-beta correction for the muon isolation and set the recommended cut [1] # [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideMuonId?rev=46#Muon_Isolation process.pfIsolatedMuons.doDeltaBetaCorrection = True process.pfIsolatedMuons.deltaBetaFactor = -0.5 process.pfIsolatedMuons.isolationCut = 0.2 #process.pfSelectedMuons.cut = 'abs(eta)<2.5 && pt>10.' process.pfSelectedMuons.cut = '(pt > 10.) && (abs(eta) < 2.5) && (muonRef.isAvailable) && (muonRef.isPFMuon) && (muonRef.isGlobalMuon || isTrackerMuon)' process.patMuons.embedTrack = True process.patMuons.usePV = False #process.selectedPatMuons.cut = "(abs(eta) < 2.5) && (pt > 10.0) && ((chargedHadronIso+max(0.,neutralHadronIso+photonIso-0.50*puChargedHadronIso))/pt < 0.20) && (isPFMuon && (isGlobalMuon || isTrackerMu)" # Release cuts on compatibility with the first primary vertex (similar to electrons) process.pfMuonsFromVertex.d0Cut = 9999. process.pfMuonsFromVertex.d0SigCut = 9999. process.pfMuonsFromVertex.dzCut = 9999. process.pfMuonsFromVertex.dzSigCut = 9999. process.patMuons.pfMuonSource = cms.InputTag("pfIsolatedMuons") process.muonMatch.src = cms.InputTag("pfIsolatedMuons") process.muonMatchAll = process.muonMatch.clone( src = cms.InputTag("pfMuons") ) process.patMuonsAll = process.patMuons.clone( pfMuonSource = cms.InputTag("pfMuons"), genParticleMatch = cms.InputTag("muonMatchAll"), ) process.selectedPatMuonsAll = process.selectedPatMuons.clone( src = cms.InputTag("patMuonsAll"), ) # muon ID production (essentially track count embedding) must be here # because tracks get dropped from the collection after this step, resulting # in null ptrs. process.muonsWithID = cms.EDProducer( 'MuonIDProducer', muonSrc = cms.InputTag("selectedPatMuons"), primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices") ) process.muonsWithIDAll = process.muonsWithID.clone( muonSrc = cms.InputTag("selectedPatMuonsAll") ) process.muonSequence = cms.Sequence() if options.isMC: process.muonSequence += process.muonMatchAll process.muonSequence += ( process.patMuonsAll * process.selectedPatMuonsAll * process.muonsWithIDAll ) #------------------------------------------------- # Electrons # Implemented as in https://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=208765 #------------------------------------------------- #From EgammaAnalysis/ElectronTools/test/patTuple_electronId_cfg.py process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') process.load('EgammaAnalysis.ElectronTools.electronIsolatorFromEffectiveArea_cfi') process.mvaID = cms.Sequence( process.mvaTrigV0 + process.mvaTrigNoIPV0 + process.mvaNonTrigV0 ) process.patElectrons.electronIDSources = cms.PSet( mvaTrigV0 = cms.InputTag("mvaTrigV0"), mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0"), mvaTrigNoIPV0 = cms.InputTag("mvaTrigNoIPV0"), ) process.patPF2PATSequence.replace(process.patElectrons, process.mvaID * process.patElectrons) #process.selectedPatElectrons.cut = "pt>20 && abs(eta)<3.0" process.electronsWithID = cms.EDProducer( 'ElectronIDProducer', electronSrc = cms.InputTag("selectedPatElectrons"), primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices") ) process.pfElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId")) process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) process.patElectrons.isolationValues.pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03PFId") process.patElectrons.isolationValues.pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03PFId") process.patElectrons.isolationValues.pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03PFId") process.patElectrons.isolationValues.pfPhotons = cms.InputTag("elPFIsoValueGamma03PFId") process.patElectrons.isolationValues.pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03PFId") process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId")) process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag('elPFIsoValueEA03') # Define a module to produce a value map with rho correction of electron isolation. The # configuration fragment is copied from [1] because it is not included in the current tag of # UserCode/EGamma/EGammaAnalysisTools. General outline of configuration is inspired by [2]. # [1] http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/UserCode/EGamma/EGammaAnalysisTools/python/electronIsolatorFromEffectiveArea_cfi.py?hideattic=0&revision=1.1.2.2&view=markup # [2] https://twiki.cern.ch/twiki/bin/viewauth/CMS/TwikiTopRefHermeticTopProjections?rev=4#Electrons # # In both real data and simulation an effective area derived from real data (2012 HCP dataset) # is applied. Possible difference between data and simulation is belived to be small [3-4] # [3] https://hypernews.cern.ch/HyperNews/CMS/get/top/1607.html # [4] https://hypernews.cern.ch/HyperNews/CMS/get/egamma/1263/1/2/1.html process.elPFIsoValueEA03 = cms.EDFilter('ElectronIsolatorFromEffectiveArea', gsfElectrons = cms.InputTag('gsfElectrons'), pfElectrons = cms.InputTag('pfSelectedElectrons'), rhoIso = cms.InputTag('kt6PFJets', 'rho'), EffectiveAreaType = cms.string('kEleGammaAndNeutralHadronIso03'), EffectiveAreaTarget = cms.string('kEleEAData2012')) process.patPF2PATSequence.replace( process.pfIsolatedElectrons, process.elPFIsoValueEA03 * process.pfIsolatedElectrons ) process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) #process.pfIdentifiedElectrons = cms.EDFilter("ElectronIDPFCandidateSelector", # recoGsfElectrons = cms.InputTag("gsfElectrons"), # electronIdMap = cms.InputTag("mvaTrigV0"), # electronIdCut = cms.double(0.0), # src = cms.InputTag("pfSelectedElectrons") #) #process.pfSelectedElectrons.src = 'pfIdentifiedElectrons' #process.pfSelectedElectrons.cut = 'abs(eta)<2.5 && pt>20. && gsfTrackRef.isNonnull && gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits<2' # Adjust parameters for the rho correction [1]. The cut on the isolation value is set in # accordance with [2] # [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/TwikiTopRefHermeticTopProjections?rev=4#Electrons # [2] https://twiki.cern.ch/twiki/bin/view/CMS/TWikiTopRefEventSel?rev=178#Veto process.pfIsolatedElectrons.doDeltaBetaCorrection = True process.pfIsolatedElectrons.deltaBetaFactor = -1. process.pfIsolatedElectrons.isolationCut = 0.15 process.patPF2PATSequence.replace( process.pfSelectedElectrons, process.mvaTrigV0 + #process.pfIdentifiedElectrons + process.pfSelectedElectrons + process.elPFIsoValueEA03 ) process.patElectrons.isolationValues.user = cms.VInputTag(cms.InputTag("elPFIsoValueEA03")) process.patElectrons.electronIDSources = cms.PSet( mvaTrigV0 = cms.InputTag("mvaTrigV0")) # Release cuts on compatibility with the first primary vertex, as recommended in [1] # [1] https://hypernews.cern.ch/HyperNews/CMS/get/egamma-elecid/72/1.html process.pfElectronsFromVertex.d0Cut = 9999. process.pfElectronsFromVertex.d0SigCut = 9999. process.pfElectronsFromVertex.dzCut = 9999. process.pfElectronsFromVertex.dzSigCut = 9999. # Apply remaining cuts that define veto electrons as required in [1]. It is implemented via an # additional module and not in pfSelectedElectrons, becase all the isolation maps are associated # with the latter collection, and they will be needed also for a looser electron selection # [1] https://twiki.cern.ch/twiki/bin/view/CMS/TWikiTopRefEventSel?rev=178#Veto process.pfElectronsForTopProjection = process.pfSelectedElectrons.clone( src = "pfIsolatedElectrons", cut = "pt > 20. && abs(eta) < 2.5") process.pfNoElectron.topCollection = 'pfElectronsForTopProjection' process.patPF2PATSequence.replace(process.pfIsolatedElectrons, process.pfIsolatedElectrons * process.pfElectronsForTopProjection) #process.selectedPatElectrons.cut = "(abs(eta)<2.5) && (pt>20.) && ((chargedHadronIso + max(0.0, neutralHadronIso + photonIso - 1.0*userIsolation('User1Iso')))/pt < 0.15) && (electronID('mvaTrigV0') > 0.00)" process.patElectronsAll = process.patElectrons.clone( pfElectronSource=cms.InputTag("pfElectrons") ) process.selectedPatElectronsAll = process.selectedPatElectrons.clone( src=cms.InputTag("patElectronsAll") ) process.electronsWithIDAll = process.electronsWithID.clone( electronSrc = cms.InputTag("selectedPatElectronsAll") ) process.electronSequence = cms.Sequence( process.patElectronsAll * process.selectedPatElectronsAll * process.electronsWithIDAll ) #--------------------------------------------- # Trigger matching #--------------------------------------------- process.load('PhysicsTools.PatAlgos.triggerLayer1.triggerProducer_cfi') process.load('PhysicsTools.PatAlgos.triggerLayer1.triggerEventProducer_cfi') process.patTriggerSequence = cms.Sequence( process.patTrigger * process.patTriggerEvent ) #------------------------------------------------- # Jets # MET corrections as https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_0_with_PAT #------------------------------------------------- #Taus are NOT removed from jets process.pfNoTau.enable = False # From Andrey's code # Jet identification criteria as recommended in [1-2]. The fraction of neutral-hadron and # HF-hadron energy is defined below differently from the formula in [2]. However, the formula # is written for uncorrected jets, while JEC-corrected ones are used below. One can rescale the # jet energy in the formula, but the expression below yields the same result. All accessors to # energy fractions from PAT jets account for the effect of JEC # [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/JetID # [2] https://hypernews.cern.ch/HyperNews/CMS/get/JetMET/1429.html jetQualityCut = "numberOfDaughters > 1 & (neutralHadronEnergyFraction + HFHadronEnergyFraction) < 0.99 & neutralEmEnergyFraction < 0.99 & (abs(eta) < 2.4 & chargedEmEnergyFraction < 0.99 & chargedHadronEnergyFraction > 0. & chargedMultiplicity > 0 | abs(eta) >= 2.4)" # Apply the jet ID defined above to selected pat jets. It will be inherited by all the jet # collections considered in the analysis, including those produced by the MET uncertainty tool. # The latter is reasonable as we do not want to apply JEC variation, for instance, to fake jets process.selectedPatJets.cut = jetQualityCut process.load("CMGTools.External.pujetidsequence_cff") process.patPF2PATSequence += process.puJetIdSqeuence #------------------------------------------------- # MET uncertainty step #------------------------------------------------- #Embed the reference to the original jet in the jets, which is constant during the propagation process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>', src=cms.InputTag("selectedPatJets") ) #Note: this module causes a large memory increase when crossing the file boundary #Reason - unknown, solution: limit processing to ~1 file. from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties #for type 0 process.load('JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi') if options.isMC: corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc else: corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data runMEtUncertainties(process, electronCollection=cms.InputTag("electronsWithID"), photonCollection=None, muonCollection=cms.InputTag("muonsWithID"), tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("patJetsWithOwnRef"), jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual", doSmearJets=options.isMC and not options.doSync, #doSmearJets=False, jetCorrPayloadName="AK5PFchs", addToPatDefaultSequence=False, doApplyType0corr=True, doApplySysShiftCorr = True, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, sysShiftCorrParameter = corrpars ) #process.selectedVerticesForMEtCorr.src = cms.InputTag("goodOfflinePrimaryVertices") process.metUncertaintySequence.replace(process.patType1CorrectedPFMet, process.type0PFMEtCorrection + process.patPFMETtype0Corr + process.pfMEtSysShiftCorrSequence + process.patType1CorrectedPFMet ) #Switch off checking for overlaps between leptons and jets #process.patJetsWithOwnRefNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps = cms.PSet() #process.patJetsNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps = cms.PSet() process.stpolMetUncertaintySequence = cms.Sequence( process.metUncertaintySequence ) if not options.doSlimming or options.doDebug: process.out.outputCommands = cms.untracked.vstring('keep *') else: process.out.outputCommands = cms.untracked.vstring([ 'drop *', 'keep edmMergeableCounter_*_*_*', # Keep the lumi-block counter information 'keep edmTriggerResults_TriggerResults__*', #Keep the trigger results 'keep *_genParticles__*', #keep all the genParticles #'keep recoVertexs_offlinePrimaryVertices__*', #keep the offline PV-s 'keep recoVertexs_goodOfflinePrimaryVertices__*', #keep the offline PV-s # Trigger 'keep *_patTrigger_*_*', 'keep *_patTriggerEvent_*_*', # Jets 'keep patJets_*__*', 'keep double_*_rho_*', #For rho-corr rel iso 'keep recoGenJets_selectedPatJets_genJets_*', #For Jet MC smearing we need to keep the genJets "keep *_puJetId_*_*", # input variables "keep *_puJetMva_*_*", # final MVAs and working point flags 'keep *_jetClones__*', # Muons 'keep *_muons__*', #reco muons 'keep patMuons_muonsWithID__*', 'keep patMuons_muonsWithIDAll__*', 'keep *_muonClones__*', # Electrons 'keep patElectrons_electronsWithID__*', 'keep patElectrons_electronsWithIDAll__*', 'keep *_electronClones__*', # METs 'keep patMETs_*__*', #ECAL laser corr filter 'keep bool_ecalLaserCorrFilter__*', #For flavour analyzer 'keep GenEventInfoProduct_generator__*', #PU info 'keep PileupSummaryInfos_addPileupInfo__*', ##PFCandidates #'keep recoPFCandidates_*_pfCandidates_PAT', #'keep recoPFMETs_pfMET__*', #'keep recoPFMETs_pfMet__*', #'keep recoGenMETs_genMetTrue__*', #'keep recoPFCandidates_particleFlow__*', #'keep recoConversions_allConversions__*', #'keep recoVertexCompositeCandidates_generalV0Candidates_*_*', #'keep recoTracks_generalTracks__*', #'keep recoBeamSpot_offlineBeamSpot__*', #'keep recoMuons_muons__*', 'keep int_*__PAT', 'keep ints_*__PAT', 'keep double_*__PAT', 'keep doubles_*__PAT', 'keep float_*__PAT', 'keep floats_*__PAT', ]) process.out.SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring( ["singleTopPathStep1Mu", "singleTopPathStep1Ele"] if options.doSkimming else ["*"] ) ) #------------------------------------------------- # Paths #------------------------------------------------- process.goodOfflinePVCount = cms.EDProducer( "CollectionSizeProducer<reco::Vertex>", src = cms.InputTag("goodOfflinePrimaryVertices") ) process.preCalcSequences = cms.Sequence( process.patJetsWithOwnRef * process.goodOfflinePVCount ) process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatMuons) + 1, process.muonsWithID) process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatElectrons) + 1, process.electronsWithID) #Need separate paths because of skimming process.singleTopSequence = cms.Sequence( process.goodOfflinePrimaryVertices * process.eventFiltersSequence * process.patPF2PATSequence ) process.GlobalTag.globaltag = cms.string(options.globalTag) process.singleTopSequence += process.preCalcSequences process.singleTopSequence += process.stpolMetUncertaintySequence process.singleTopSequence += process.patTriggerSequence process.singleTopSequence += process.muonSequence process.singleTopSequence += process.electronSequence if options.isMC: #https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC process.GlobalTag.toGet = cms.VPSet( cms.PSet(record = cms.string("BTagTrackProbability2DRcd"), tag = cms.string("TrackProbabilityCalibration_2D_MC53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")), cms.PSet(record = cms.string("BTagTrackProbability3DRcd"), tag = cms.string("TrackProbabilityCalibration_3D_MC53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")) ) else: #https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC process.GlobalTag.toGet = cms.VPSet( cms.PSet(record = cms.string("BTagTrackProbability2DRcd"), tag = cms.string("TrackProbabilityCalibration_2D_Data53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")), cms.PSet(record = cms.string("BTagTrackProbability3DRcd"), tag = cms.string("TrackProbabilityCalibration_3D_Data53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")) ) #Filters added by a separate method #process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi') #process.ecalLaserCorrFilter.taggingMode=True # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters #process.scrapingFilter = cms.EDFilter("FilterOutScraping" # , applyfilter = cms.untracked.bool(True) # , debugOn = cms.untracked.bool(False) # , numtrack = cms.untracked.uint32(10) # , thresh = cms.untracked.double(0.25) #) #process.singleTopSequence += process.scrapingFilter #process.singleTopSequence += process.ecalLaserCorrFilter if options.doSkimming: process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_Skim.root")) else: process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSkim.root")) process.singleTopPathStep1Mu = cms.Path(process.singleTopSequence) process.singleTopPathStep1Ele = cms.Path(process.singleTopSequence) #process.chsalgos[0].tmvaWeights = cms.string('CMGTools/External/data/TMVAClassificationCategory_JetID_53X_chs_Dec2012.weights.xml') #process.chsalgos_5x[0].tmvaWeights = cms.string('CMGTools/External/data/TMVAClassificationCategory_JetID_53X_chs_Dec2012.weights.xml') #----------------------------------------------- # Skimming #----------------------------------------------- #Throw away events before particle flow? if options.doSkimming: from SingleTopPolarization.Analysis.eventSkimming_cfg import skimFilters skimFilters(process) process.singleTopPathStep1Mu.insert(0, process.muonSkim) process.singleTopPathStep1Ele.insert(0, process.electronSkim) #----------------------------------------------- # Skim efficiency counters #----------------------------------------------- #count all processed events countProcessed(process) #count events passing mu and ele paths countInSequence(process, process.singleTopPathStep1Mu) countInSequence(process, process.singleTopPathStep1Ele) if not options.doSlimming: process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSlim.root")) return process
# # # EXERCISE 3.2 # # # ################# ## Geometry and Detector Conditions (needed for a Scaling up and down the JEC) process.load("Configuration.StandardSequences.GeometryDB_cff") process.load( "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") from Configuration.AlCa.autoCond import autoCond process.GlobalTag.globaltag = cms.string(autoCond['startup']) process.load("Configuration.StandardSequences.MagneticField_cff") # load the standard PAT config process.load("PhysicsTools.PatAlgos.patSequences_cff") from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process) #process.shiftedPatJets=process.shiftedPatJetsEnUp.clone(src = cms.InputTag("cleanPatJets"),shiftBy=cms.double(1)) #process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJets")) #process.p.replace(process.jecAnalyzer, process.shiftedPatJets * process.jecAnalyzerEnUp) ################# # # # EXERCISE 3.3 # # # ################# #process.btagAnalyzer = cms.EDAnalyzer("WrappedEDAnalysisTasksAnalyzerBTag", # Jets = cms.InputTag("cleanPatJets"), # bTagAlgo=cms.string('trackCountingHighEffBJetTags'),
#for type 0 process.load('JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi') if options.isMC: corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc else: corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data runMEtUncertainties(process, electronCollection=cms.InputTag("electronsWithID"), photonCollection=None, muonCollection=cms.InputTag("muonsWithID"), tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("patJetsWithOwnRef"), jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual", doSmearJets=options.isMC and not options.doSync, #doSmearJets=False, jetCorrPayloadName="AK5PFchs", addToPatDefaultSequence=False, doApplyType0corr=True, doApplySysShiftCorr = True, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, sysShiftCorrParameter = corrpars ) #from tth ### ### ### #process.patPFMetNoPU = process.patMETs.clone( # metSource = cms.InputTag("pfMETNoPU"), # addMuonCorrections = cms.bool(False),
switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA = True, doBTagging = True, jetCorrLabel = _jetCorrections, doType1MET = False, doJetID = True, jetIdLabel = "ak5" ) # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process,doApplyType0corr=False,tauCollection=None) #runMEtUncertainties(process,doApplyType0corr=False) process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1CorrectedMet process.pfMETType0 = pfType1CorrectedMet.clone() process.pfMETType0.applyType1Corrections = cms.bool(True) process.pfMETType0.applyType0Corrections = cms.bool(True) if IsPythiaShowered: filtersequence = cms.Sequence( process.totalKinematicsFilter ) else: filtersequence = cms.Sequence()
#---------------------------------------------------------------------------------------------------- # Use the runMetUncertainties tool here # See https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools #---------------------------------------------------------------------------------------------------- from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, jetCollection=cms.InputTag('analysisPatJetsAK5PF'), doApplySysShiftCorr=True, # Apply correction for systematic x/y shift in MET doApplyType0corr=True, # Apply correction for pileup makeType1corrPFMEt=True, # Apply correction for jet energy scale makeType1p2corrPFMEt= False, # DO NOT apply correction for unclustered energy (degrades MET resolution) makePFMEtByMVA=False, # We don't use MVA PFMET doSmearJets=True, # Very important to smear the pfjets (MC ONLY) addToPatDefaultSequence=True, # Add this to the PAT sequence electronCollection=cms.InputTag('analysisPatElectrons'), tauCollection=cms.InputTag('analysisPatTaus'), muonCollection=cms.InputTag('analysisPatMuons'), sysShiftCorrParameter=process. pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc) #---------------------------------------------------------------------------------------------------- # Available pat::MET collections for analysis # - process.patMETsTC : raw TCMET (NO jet smearing) # # - process.patMETsRawCalo : raw CaloMET (NO jet smearing) # - process.patMETs : Type1 CaloMET (NO jet smearing) #
skipRawJetPtThreshold = cms.double(10.), # GeV skipCorrJetPtThreshold = cms.double(1.e-2), srcGenJets = cms.InputTag('ak5GenJetsNoNu') ) runMEtUncertainties(process, electronCollection = cms.InputTag('selectedPatElectrons'), photonCollection = '', muonCollection = cms.InputTag('selectedPatMuons'), tauCollection = cms.InputTag('selectedPatTaus'), jetCollection = cms.InputTag('patJets'), jetCorrLabel = "L3Absolute", doSmearJets = True, makeType1corrPFMEt = True, makeType1p2corrPFMEt = True, makePFMEtByMVA = True, makeNoPileUpPFMEt = False, doApplyType0corr = False ) ################################################## # Let it run ################################################### process.p = cms.Path( process.VertexPresent+
# ------------------------------------------------------------------------------ # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET if doMetUnc: #process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, postfix="MetUnc", jetCollection="selectedPatJetsAK5PF", jetCorrLabel=patJetCorrLabel, doSmearJets=True, makeType1corrPFMEt=True, makeType1p2corrPFMEt=True, makePFMEtByMVA=False, makeNoPileUpPFMEt=False, doApplyType0corr=False, sysShiftCorrParameter=sysShiftCorrParam, doApplySysShiftCorr=False, pfCandCollection='particleFlow', jetCorrPayloadName='AK5PF', outputModule='', ) process.out.outputCommands += [ 'drop *_*MetUnc_*_*', 'keep selectedPatMETs_patType1CorrectedPFMet*MetUnc_*_*' ] # ------------------------------------------------------------------------------ # MET Filters
def miniAOD_customizeCommon(process): process.patMuons.isoDeposits = cms.PSet() process.patElectrons.isoDeposits = cms.PSet() process.patTaus.isoDeposits = cms.PSet() process.patPhotons.isoDeposits = cms.PSet() # process.patMuons.embedTrack = True # used for IDs process.patMuons.embedCombinedMuon = True # used for IDs process.patMuons.embedMuonBestTrack = True # used for IDs process.patMuons.embedStandAloneMuon = True # maybe? process.patMuons.embedPickyMuon = False # no, use best track process.patMuons.embedTpfmsMuon = False # no, use best track process.patMuons.embedDytMuon = False # no, use best track # # disable embedding of electron and photon associated objects already stored by the ReducedEGProducer process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.patElectrons.electronIDSources = cms.PSet( # configure many IDs as InputTag <someName> = <someTag> you # can comment out those you don't want to save some disk space eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"), eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"), eidLoose = cms.InputTag("reducedEgamma","eidLoose"), eidTight = cms.InputTag("reducedEgamma","eidTight"), eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"), ) process.elPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") # process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons") process.patPhotons.photonIDSources = cms.PSet( PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma', 'PhotonCutBasedIDLoose'), PhotonCutBasedIDTight = cms.InputTag('reducedEgamma', 'PhotonCutBasedIDTight') ) process.phPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedPhotons") # process.selectedPatJets.cut = cms.string("pt > 10") process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))") process.selectedPatElectrons.cut = cms.string("") process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFinding')> 0.5") process.selectedPatPhotons.cut = cms.string("") # from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection #switch to AK4 for CSA14/70X release (should be default in 71X) switchJetCollection(process, jetSource = cms.InputTag('ak4PFJetsCHS'), jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), ''), btagDiscriminators = ['jetBProbabilityBJetTags', 'jetProbabilityBJetTags', 'trackCountingHighPurBJetTags', 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'simpleSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexBJetTags' , 'combinedInclusiveSecondaryVertexBJetTags' ], ) #add CA8 from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection(process, labelName = 'AK8', jetSource = cms.InputTag('ak8PFJetsCHS'),algo= 'AK', rParam = 0.8, jetCorrections = ('AK7PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') ) process.patJetsAK8.userData.userFloats.src = [] # start with empty list of user floats process.selectedPatJetsAK8.cut = cms.string("pt > 100") process.patJetGenJetMatchAK8.matched = 'slimmedGenJets' ## AK8 groomed masses from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsCHSPruned, ak8PFJetsCHSFiltered, ak8PFJetsCHSTrimmed process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone() process.ak8PFJetsCHSTrimmed = ak8PFJetsCHSTrimmed.clone() process.ak8PFJetsCHSFiltered = ak8PFJetsCHSFiltered.clone() process.load("RecoJets.JetProducers.ak8PFJetsCHS_groomingValueMaps_cfi") process.patJetsAK8.userData.userFloats.src += ['ak8PFJetsCHSPrunedLinks','ak8PFJetsCHSTrimmedLinks','ak8PFJetsCHSFilteredLinks'] ### CA8 groomed masses (for the matched jet): doesn't seem to work, it produces tons of warnings "Matched jets separated by dR greater than distMax=0.8" # from RecoJets.Configuration.RecoPFJets_cff import ca8PFJetsCHSFiltered, ca8PFJetsCHSTrimmed # ca8PFJetsCHSPruned is already in AOD # process.ca8PFJetsCHSTrimmed = ca8PFJetsCHSTrimmed.clone() # process.ca8PFJetsCHSFiltered = ca8PFJetsCHSFiltered.clone() # process.load("RecoJets.JetProducers.ca8PFJetsCHS_groomingValueMaps_cfi") # process.ca8PFJetsCHSPrunedLinks.src = cms.InputTag("ak8PFJetsCHS") # process.ca8PFJetsCHSTrimmedLinks.src = cms.InputTag("ak8PFJetsCHS") # process.ca8PFJetsCHSFilteredLinks.src = cms.InputTag("ak8PFJetsCHS") # process.patJetsAK8.userData.userFloats.src += ['ca8PFJetsCHSPrunedLinks','ca8PFJetsCHSTrimmedLinks','ca8PFJetsCHSFilteredLinks'] ## cmsTopTagger (note: it is already run in RECO, we just add the value) process.cmsTopTagPFJetsCHSLinksAK8 = process.ak8PFJetsCHSPrunedLinks.clone() process.cmsTopTagPFJetsCHSLinksAK8.src = cms.InputTag("ak8PFJetsCHS") process.cmsTopTagPFJetsCHSLinksAK8.matched = cms.InputTag("cmsTopTagPFJetsCHS") process.patJetsAK8.userData.userFloats.src += ['cmsTopTagPFJetsCHSLinksAK8'] # from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone switchOnTriggerStandAlone( process, outputModule = '' ) process.patTrigger.packTriggerPathNames = cms.bool(True) # # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties addJetCollection(process, postfix = "ForMetUnc", labelName = 'AK5PF', jetSource = cms.InputTag('ak5PFJets'), jetCorrections = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], '')) runMEtUncertainties(process,jetCollection="selectedPatJetsAK5PFForMetUnc", outputModule=None) #keep this after all addJetCollections otherwise it will attempt computing them also for stuf with no taginfos #Some useful BTAG vars process.patJets.userData.userFunctions = cms.vstring( '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).p4.M):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).nTracks):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).value):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).significance):(0)', ) process.patJets.userData.userFunctionLabels = cms.vstring('vtxMass','vtxNtracks','vtx3DVal','vtx3DSig') process.patJets.tagInfoSources = cms.VInputTag(cms.InputTag("secondaryVertexTagInfos")) process.patJets.addTagInfos = cms.bool(True) # ## PU JetID process.load("PhysicsTools.PatAlgos.slimming.pileupJetId_cfi") process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
### Importing skeleton ### import sys import os.path sys.path.append(os.path.abspath(os.path.expandvars(os.path.join('$CMSSW_BASE','src/PhysicsTools/PatExamples/test/')))) from analyzePatAnalysisTasks_exercise_6c_skeleton_cfg import * ######################### process.jecAnalyzer = cms.EDAnalyzer("WrappedEDAnalysisTasksAnalyzerJEC", Jets = cms.InputTag("cleanPatJets"), jecLevel=cms.string("L3Absolut"), patJetCorrFactors= cms.string('CorrFactors'), help=cms.bool(False), outputFileName=cms.string("jecAnalyzerOutput") ) from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process,electronCollection="selectedPatElectrons",photonCollection=None,muonCollection="selectedPatMuons",tauCollection="selectedPatTaus",jetCollection="selectedPatJets") process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJetsEnDownForCorrMEt")) process.p += process.metUncertaintySequence process.p += process.jecAnalyzerEnUp
from PhysicsTools.PatAlgos.tools.metTools import * addTcMET(process, 'TC') addPfMET(process, 'PF') process.patMETsPF.metSource = cms.InputTag("pfMet") process.patPFMETsTypeIcorrected = process.patMETs.clone( metSource=cms.InputTag('pfType1CorrectedMet'), addMuonCorrections=cms.bool(False), genMETSource=cms.InputTag('genMetTrue'), addGenMET=cms.bool(False)) process.metAnalysisSequence = cms.Sequence(process.patPFMETsTypeIcorrected) # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, doApplyType0corr=True, doSmearJets=True) process.smearedPFType1CorrectedMet = process.patMETs.clone( metSource=cms.InputTag('patType1CorrectedPFMet'), addMuonCorrections=cms.bool(False), genMETSource=cms.InputTag('genMetTrue'), addGenMET=cms.bool(False)) process.metAnalysisSequence += process.smearedPFType1CorrectedMet process.cleanPatPhotons.checkOverlaps.electrons.requireNoOverlaps = cms.bool( False) from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFPhotonIso process.eleIsoSequence = setupPFElectronIso(process, 'gsfElectrons') process.phoIsoSequence = setupPFPhotonIso(process, 'photons')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff' ) process.GlobalTag.globaltag = 'START53_V7F::All' from Configuration.AlCa.autoCond import autoCond process.GlobalTag.globaltag = cms.string(autoCond['startup']) process.load('Configuration.StandardSequences.MagneticField_cff') process.load('Configuration.Geometry.GeometryIdeal_cff') from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, electronCollection=cms.InputTag('electronsWithID'), #electronCollection=cms.InputTag('selectedPatElectrons'), photonCollection='', muonCollection=cms.InputTag('muonsWithID'), #muonCollection=cms.InputTag('selectedPatMuons'), tauCollection='', jetCollection=cms.InputTag('selectedPatJets'), addToPatDefaultSequence=False, ) process.simpleAnalyzer = cms.EDAnalyzer('SimpleEventAnalyzer', interestingCollections=cms.untracked.VInputTag([ 'smearedPatJets', 'smearedPatJetsResUp', 'smearedPatJetsResDown', 'muonsWithID', 'shiftedMuonsWithIDenDown', 'shiftedMuonsWithIDenUp', 'electronsWithID',
def setupPatMets(process, runOnMC, makeNoPUMet): process.preMetSequence = cms.Sequence() ##Filters process.load("RecoMET.METFilters.metFilters_cff") process.preMetSequence += process.metFilters ##Corrections process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") #Type 0 Corrections process.patPFMETtype0Corr.src = cms.InputTag('goodPV') #Type 1 correction process.patPFJetMETtype1p2Corr.skipEM = cms.bool(False) process.patPFJetMETtype1p2Corr.skipMuons = cms.bool(False) #SysShift correction to turn the MET flat(ter) with respect to Phi process.load("UserCode.zbb_louvain.PATconfig.METphiCorrections_cfi") process.selectedVerticesForMEtCorr.src = cms.InputTag('goodPV') if runOnMC: process.PFMETSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewPFMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc, ) process.MVAMETNURSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewMVAMEtNURSysShiftCorrParameters_2012runABCDvsNvtx_mc, src=cms.InputTag( 'pfMEtMVA' ) # I think this is not mandatory for Nvtx based correction but to be safe... ) process.MVAMETURSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewMVAMEtURSysShiftCorrParameters_2012runABCDvsNvtx_mc, src=cms.InputTag('pfMEtMVA')) process.NoPUMETSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewNoPUMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc, src=cms.InputTag('noPileUpPFMEt')) else: process.PFMETSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewPFMEtSysShiftCorrParameters_2012runABCDvsNvtx_data, ) process.MVAMETNURSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewMVAMEtNURSysShiftCorrParameters_2012runABCDvsNvtx_data, src=cms.InputTag('pfMEtMVA')) process.MVAMETURSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewMVAMEtURSysShiftCorrParameters_2012runABCDvsNvtx_data, src=cms.InputTag('pfMEtMVA')) process.NoPUMETSysShiftCorr = process.pfMEtSysShiftCorr.clone( parameter=process. NewNoPUMEtSysShiftCorrParameters_2012runABCDvsNvtx_data, src=cms.InputTag('noPileUpPFMEt')) #MVA MET !!! Based on AK5PFJets and not on AK5PFchsJets (the same holds for noPUMET) process.load("RecoMET.METPUSubtraction.mvaPFMET_cff") process.pfMEtMVA.srcVertices = cms.InputTag('goodPV') process.pfMEtMVA.srcLeptons = cms.VInputTag("tightMuons", "tightElectrons") #noPUMET if makeNoPUMet: process.load("RecoMET.METPUSubtraction.noPileUpPFMET_cff") process.noPileUpPFMEt.srcLeptons = cms.VInputTag( "tightMuons", "tightElectrons") if not runOnMC: process.calibratedAK5PFJetsForNoPileUpPFMEt.correctors = cms.vstring( "ak5PFL1FastL2L3") ##Uncertainties if runOnMC: runMEtUncertainties( process, makeType1p2corrPFMEt=False, doApplyType0corr=True, jetCorrLabel="L3Absolute", sysShiftCorrParameter=process. pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc, #old phi correction for PFMET doApplySysShiftCorr=True, jetCorrPayloadName='AK5PFchs', makePFMEtByMVA=True, makeNoPileUpPFMEt=makeNoPUMet, addToPatDefaultSequence=False, postfix='') else: process.patPFMet.addGenMET = cms.bool(False) process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring( "ak5PFL1FastL2L3Residual") runMEtUncertainties(process, makeType1p2corrPFMEt=False, doApplyType0corr=True, jetCorrLabel="L2L3Residual", sysShiftCorrParameter=process. pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data, doApplySysShiftCorr=True, jetCorrPayloadName='AK5PFchs', makePFMEtByMVA=True, makeNoPileUpPFMEt=makeNoPUMet, addToPatDefaultSequence=False, doSmearJets=False, postfix='') process.metUncertaintySequence.replace( process.patType1CorrectedPFMet, cms.Sequence(process.type0PFMEtCorrection * process.patPFMETtype0Corr * process.patType1CorrectedPFMet)) process.pfCandsNotInJet.topCollection = cms.InputTag("pfNoTau") #Add Met with different corrections process.patType01SCorrectedPFMet = process.patType1CorrectedPFMet.clone( srcType1Corrections=cms.VInputTag( cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), cms.InputTag('patPFMETtype0Corr'), cms.InputTag('PFMETSysShiftCorr')), ) process.patType01CorrectedPFMet = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMet'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag( cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), cms.InputTag('patPFMETtype0Corr')), applyType2Corrections=cms.bool(False)) process.patTypeOnly1CorrectedPFMet = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMet'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag( cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), ), applyType2Corrections=cms.bool(False)) process.patType0CorrectedPFMet = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMet'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag(cms.InputTag('patPFMETtype0Corr')), applyType2Corrections=cms.bool(False)) process.patTypeSysCorrectedPFMet = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMet'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag(cms.InputTag('PFMETSysShiftCorr')), applyType2Corrections=cms.bool(False)) process.patType0sysCorrectedPFMet = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMet'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag(cms.InputTag('patPFMETtype0Corr'), cms.InputTag('PFMETSysShiftCorr')), applyType2Corrections=cms.bool(False)) process.patType1sysCorrectedPFMet = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMet'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag( cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), cms.InputTag('PFMETSysShiftCorr')), applyType2Corrections=cms.bool(False)) process.patMVAMETNURphiCorrected = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMetMVA'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag( cms.InputTag('MVAMETNURSysShiftCorr')), applyType2Corrections=cms.bool(False)) process.patMVAMETURphiCorrected = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMetMVA'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag( cms.InputTag('MVAMETURSysShiftCorr')), applyType2Corrections=cms.bool(False)) process.patNoPUMETphiCorrected = cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag('patPFMetNoPileUp'), applyType1Corrections=cms.bool(True), srcType1Corrections=cms.VInputTag(cms.InputTag('NoPUMETSysShiftCorr')), applyType2Corrections=cms.bool(False)) process.metUncertaintySequence += cms.Sequence( process.PFMETSysShiftCorr + process.MVAMETNURSysShiftCorr + process.MVAMETURSysShiftCorr + process.NoPUMETSysShiftCorr + process.patType01SCorrectedPFMet + process.patTypeOnly1CorrectedPFMet + process.patType0CorrectedPFMet + process.patTypeSysCorrectedPFMet + process.patType01CorrectedPFMet + process.patType1sysCorrectedPFMet + process.patType0sysCorrectedPFMet + process.patMVAMETNURphiCorrected + process.patMVAMETURphiCorrected + process.patMVAMETURphiCorrected + process.patNoPUMETphiCorrected) #clean metUncertaintySequence print "" print "These modules will be removed from the metUncertaintySequence as already produced before:" for name in process.patDefaultSequence.moduleNames(): if name in process.metUncertaintySequence.moduleNames(): print name process.metUncertaintySequence.remove(getattr(process, name)) if name in process.metUncertaintySequence.moduleNames(): print "Error : module not removed from metUncertaintySequence" print "...done." print "" #clean metUncertaintySequence for data if not runOnMC: print "" print "These modules will be removed from the metUncertaintySequence as useless for data:" for name in process.metUncertaintySequence.moduleNames(): #if name[-4:]=="EnUp" or name[-6:]=="EnDown" : if "EnUp" in name or "EnDown" in name: print "Run on data: remove uncertainty variation,", name process.metUncertaintySequence.remove(getattr(process, name)) if name in process.metUncertaintySequence.moduleNames(): process.metUncertaintySequence.remove( getattr(process, name)) if name in process.metUncertaintySequence.moduleNames(): print "Error : module not removed from metUncertaintySequence" print "...done." print ""
def DefineMETs(process, paths, runOnData, jecLevel): """ The function adjusts MET reconstruction. The following corrections are included: type-I (switched on by PF2PAT function), type-0, and phi-modulation correction. """ METCollections = [] #^ MET collections to store. The first one will be raw PF MET, the second one will include the # type-I and type-0 corrections as well as the MET phi-modulation correction. Type-I correction # is performed with selectedPatJets collection process.load('JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi') if runOnData: METCollections.extend(['patPFMet', 'patMETs']) # Include the type-0 MET correction. The code is inspired by [1] # [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_II_0_with_PF2PAT process.patType1CorrectedPFMet.srcType1Corrections.append( cms.InputTag('patPFMETtype0Corr')) # Correct for MET phi modulation. The code is inspired by the implementation [1] of the # runMEtUncertainties tool and [2] # [1] http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/PhysicsTools/PatUtils/python/tools/metUncertaintyTools.py?revision=1.25&view=markup # [2] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#MET_x_y_Shift_Correction_for_mod process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data process.patType1CorrectedPFMet.srcType1Corrections.append( cms.InputTag('pfMEtSysShiftCorr')) # There is some mismatch between the python configurations and CMSSW plugins in the current # setup (*), (**). This is corrected below # (*) http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/JetMETCorrections/Type1MET/plugins/SysShiftMETcorrInputProducer.cc?revision=1.2&view=markup # (**) http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/JetMETCorrections/Type1MET/plugins/SysShiftMETcorrInputProducer.cc?revision=1.3&view=markup process.pfMEtSysShiftCorr.src = process.pfMEtSysShiftCorr.srcMEt process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorr.parameter[0] # Insert missing modules into the sequence process.patPF2PATSequence.replace(process.patType1CorrectedPFMet, process.type0PFMEtCorrection + process.patPFMETtype0Corr + \ process.pfMEtSysShiftCorrSequence + process.patType1CorrectedPFMet) else: # in case of MC the runMEtUncertainties tool takes care of the corrections METCollections.extend(['patMETs', 'patType1CorrectedPFMet']) # Produce the corrected MET and perform systematical shifts [1] # [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#METSysTools from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, electronCollection = 'selectedPatElectrons', muonCollection = 'selectedPatMuons', tauCollection = '', photonCollection = '', jetCollection = 'cleanPatJets', jetCorrLabel = jecLevel, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, doApplyType0corr = True, doApplySysShiftCorr = True, sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc[0], #dRjetCleaning = -1, # this parameter is never used by the function addToPatDefaultSequence = False, outputModule = '') # Switch off the lepton-jet cleaning del(process.patJetsNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps.electrons) del(process.patJetsNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps.muons) # Add systematical variations METCollections.extend(['patType1CorrectedPFMetJetEnUp', 'patType1CorrectedPFMetJetEnDown', 'patType1CorrectedPFMetJetResUp', 'patType1CorrectedPFMetJetResDown', 'patType1CorrectedPFMetUnclusteredEnUp', 'patType1CorrectedPFMetUnclusteredEnDown', 'patType1CorrectedPFMetElectronEnUp', 'patType1CorrectedPFMetElectronEnDown', 'patType1CorrectedPFMetMuonEnUp', 'patType1CorrectedPFMetMuonEnDown']) # Update files with individual JEC uncertainty sources [1] and correct name of subtotal # uncertainty as it is outdated in the default configuraion. There are two files with jet # energy corrections and uncertainties: for data and for simulation; the difference # originate from L1FastJet corrections [2] # [1] https://twiki.cern.ch/twiki/bin/view/CMS/JECUncertaintySources?rev=17#2012_JEC # [2] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections?rev=115#JetEnCor2012Summer13 for moduleName in process.metUncertaintySequence.moduleNames(): module = getattr(process, moduleName) if ['jetCorrUncertaintyTag', 'jetCorrInputFileName'] in dir(module): module.jetCorrUncertaintyTag = 'SubTotalMC' module.jetCorrInputFileName = cms.FileInPath( 'UserCode/SingleTop/data/Summer13_V4_MC_Uncertainty_AK5PFchs.txt') # Correct for the mismatch between the python configurations and CMSSW plugins (similar to # the case of the real data above) process.pfMEtSysShiftCorr.src = process.pfMEtSysShiftCorr.srcMEt # Insert modules to perform type-0 and phi-modulation corrections into the sequence (for # some reason MET uncertainty tool does not do it automatically) process.metUncertaintySequence.replace(process.patType1CorrectedPFMet, process.type0PFMEtCorrection + process.patPFMETtype0Corr + process.pfMEtSysShiftCorr + \ process.patType1CorrectedPFMet) #^ Some collections are created several times under different names (good primary vertices, # for example), but it should not impose a significant overhead paths.append(process.metUncertaintySequence) # Return the list of produced collections return METCollections
runPF2PAT=True, jetAlgo=jetAlgoName, runOnMC=runOnMC, postfix=postfix, jetCorrections=('AK5PFchs', jetCorrections), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), # jetCorrections=('AK5PFchs',jetCorrections), pvCollection=cms.InputTag('offlinePrimaryVertices'), typeIMetCorrections=(not doRunMETUncertainties)) if doRunMETUncertainties: from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties if isData: runMEtUncertainties(process, electronCollection="selectedPatElectrons", doSmearJets=False, muonCollection="selectedPatMuons", tauCollection="selectedPatTaus", jetCollection="selectedPatJets", jetCorrLabel="L2L3Residual") process.patPFMet.addGenMET = False process.patPFMetJetEnUp.addGenMET = False process.patPFMetJetEnDown.addGenMET = False process.patPFMetElectronEnUp.addGenMET = False process.patPFMetElectronEnDown.addGenMET = False process.patPFMetMuonEnUp.addGenMET = False process.patPFMetMuonEnDown.addGenMET = False process.patPFMetTauEnUp.addGenMET = False process.patPFMetTauEnDown.addGenMET = False process.patPFMetTauEnUp.addGenMET = False process.patPFMetTauEnDown.addGenMET = False else:
* process.kt6PFJets * process.ak5PFJets * process.pfCandsNotInJet * process.selectedPatJetsForMETtype1p2Corr * process.selectedPatJetsForMETtype2Corr * process.patPFJetMETtype1p2Corr * process.patPFJetMETtype2Corr * process.pfCandMETcorr * process.patType1CorrectedPFMet * process.patType1p2CorrectedPFMet ) # -------------------------------------------------------------------------------- from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, "selectedPatElectrons", "", "selectedPatMuons", "selectedPatTaus", "selectedPatJetsAK5PF") ### build type1/2 correction also on top of pfMETnoPU process.patType1CorrectedPFMetNoPU = process.patType1CorrectedPFMet.clone() from PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi import patMETs process.patPFMetNoPU = patMETs.clone( metSource=cms.InputTag("pfMETNoPU"), addMuonCorrections=cms.bool(False), genMETSource=cms.InputTag("genMetTrue") ) # process.patPFMetNoPU = process.patMets.clone() # process.patPFMetNoPU.metSource = cms.InputTag('pfMETNoPU'), process.patType1CorrectedPFMetNoPU.src = cms.InputTag("patPFMetNoPU") process.patType1p2CorrectedPFMetNoPU = process.patType1p2CorrectedPFMet.clone() process.patType1p2CorrectedPFMetNoPU.src = cms.InputTag("patPFMetNoPU")
def setupPatMets (process, runOnMC, makeNoPUMet): process.preMetSequence = cms.Sequence() ##Filters process.load("RecoMET.METFilters.metFilters_cff") process.preMetSequence += process.metFilters ##Corrections process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") #Type 0 Corrections process.patPFMETtype0Corr.src = cms.InputTag('goodPV') #Type 1 correction if runOnMC : process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute") else : process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L2L3Residual") process.patPFMet.addGenMET = cms.bool(False) process.patPFJetMETtype1p2Corr.skipEM = cms.bool(False) process.patPFJetMETtype1p2Corr.skipMuons = cms.bool(False) #SysShift correction to turn the MET flat(ter) with respect to Phi process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi") process.selectedVerticesForMEtCorr.src = cms.InputTag('goodPV') #MVA MET !!! Based on AK5PFJets and not on AK5PFchsJets (the same holds for noPUMET) process.load("RecoMET.METPUSubtraction.mvaPFMET_cff") process.pfMEtMVA.srcVertices = cms.InputTag('goodPV') process.pfMEtMVA.srcLeptons = cms.VInputTag("tightMuons","tightElectrons") ##Uncertainties if makeNoPUMet : process.load("RecoMET.METPUSubtraction.noPileUpPFMET_cff") process.noPileUpPFMEt.srcLeptons = cms.VInputTag("tightMuons","tightElectrons") if runOnMC : process.calibratedAK5PFJetsForNoPileUpPFMEt.correctors = cms.vstring("ak5PFL1FastL2L3") process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3") runMEtUncertainties(process, makeType1p2corrPFMEt=False, doApplyType0corr=True, sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc, doApplySysShiftCorr=True, jetCorrPayloadName='AK5PFchs', makePFMEtByMVA=True, makeNoPileUpPFMEt=True, addToPatDefaultSequence=False, postfix='') else : process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3Residual") process.calibratedAK5PFJetsForNoPileUpPFMEt.correctors = cms.vstring("ak5PFL1FastL2L3Residual") runMEtUncertainties(process, makeType1p2corrPFMEt=False, doApplyType0corr=True, sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data, doApplySysShiftCorr=True, jetCorrPayloadName='AK5PFchs', makePFMEtByMVA=True, makeNoPileUpPFMEt=True, addToPatDefaultSequence=False, doSmearJets=False, postfix='') else : if runOnMC : process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3") runMEtUncertainties(process, makeType1p2corrPFMEt=False, doApplyType0corr=True, sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc, doApplySysShiftCorr=True, jetCorrPayloadName='AK5PFchs', makePFMEtByMVA=True, addToPatDefaultSequence=False, postfix='') else : process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3Residual") runMEtUncertainties(process, makeType1p2corrPFMEt=False, doApplyType0corr=True, sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data, doApplySysShiftCorr=True, jetCorrPayloadName='AK5PFchs', makePFMEtByMVA=True, addToPatDefaultSequence=False, doSmearJets=False, postfix='') process.patType01SCorrectedPFMet = process.patType1CorrectedPFMet.clone() process.metUncertaintySequence.replace(process.patType1CorrectedPFMet, cms.Sequence(process.type0PFMEtCorrection*process.patPFMETtype0Corr*process.patType1CorrectedPFMet*process.patType01SCorrectedPFMet) ) process.pfCandsNotInJet.topCollection = cms.InputTag("pfNoTau") #Add Met with different corrections process.patType01CorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer", src = cms.InputTag('patPFMet'), applyType1Corrections = cms.bool(True), srcType1Corrections = cms.VInputTag( cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), cms.InputTag('patPFMETtype0Corr') ), applyType2Corrections = cms.bool(False) ) process.patTypeOnly1CorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer", src = cms.InputTag('patPFMet'), applyType1Corrections = cms.bool(True), srcType1Corrections = cms.VInputTag( cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), ), applyType2Corrections = cms.bool(False) ) process.patType0CorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer", src = cms.InputTag('patPFMet'), applyType1Corrections = cms.bool(True), srcType1Corrections = cms.VInputTag( cms.InputTag('patPFMETtype0Corr') ), applyType2Corrections = cms.bool(False) ) process.patTypeSysCorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer", src = cms.InputTag('patPFMet'), applyType1Corrections = cms.bool(True), srcType1Corrections = cms.VInputTag( cms.InputTag('pfMEtSysShiftCorr') ), applyType2Corrections = cms.bool(False) ) process.patType0sysCorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer", src = cms.InputTag('patPFMet'), applyType1Corrections = cms.bool(True), srcType1Corrections = cms.VInputTag( cms.InputTag('patPFMETtype0Corr'), cms.InputTag('pfMEtSysShiftCorr') ), applyType2Corrections = cms.bool(False) ) process.patType1sysCorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer", src = cms.InputTag('patPFMet'), applyType1Corrections = cms.bool(True), srcType1Corrections = cms.VInputTag( cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), cms.InputTag('pfMEtSysShiftCorr') ), applyType2Corrections = cms.bool(False) ) process.metUncertaintySequence += cms.Sequence(process.patTypeOnly1CorrectedPFMet+process.patType0CorrectedPFMet+process.patTypeSysCorrectedPFMet+process.patType01CorrectedPFMet+process.patType1sysCorrectedPFMet+process.patType0sysCorrectedPFMet) #clean metUncertaintySequence print "" print "These modules will be removed from the metUncertaintySequence as already produced before:" for name in process.patDefaultSequence.moduleNames() : if name in process.metUncertaintySequence.moduleNames() : print name process.metUncertaintySequence.remove(getattr(process,name)) if name in process.metUncertaintySequence.moduleNames() : print "Error : module not removed from metUncertaintySequence" print "...done." print "" #clean metUncertaintySequence for data if not runOnMC: print "" print "These modules will be removed from the metUncertaintySequence as useless for data:" for name in process.metUncertaintySequence.moduleNames() : if name[-2:]=="Up" or name[-4:]=="Down" : print "Run on data: remove uncertainty variation,", name process.metUncertaintySequence.remove(getattr(process,name)) if name in process.metUncertaintySequence.moduleNames() : process.metUncertaintySequence.remove(getattr(process,name)) if name in process.metUncertaintySequence.moduleNames() : print "Error : module not removed from metUncertaintySequence" print "...done." print ""
process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag = 'START53_V7F::All' from Configuration.AlCa.autoCond import autoCond process.GlobalTag.globaltag = cms.string(autoCond['startup']) process.load('Configuration.StandardSequences.MagneticField_cff') process.load('Configuration.Geometry.GeometryIdeal_cff') from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, electronCollection=cms.InputTag('electronsWithID'), #electronCollection=cms.InputTag('selectedPatElectrons'), photonCollection='', muonCollection=cms.InputTag('muonsWithID'), #muonCollection=cms.InputTag('selectedPatMuons'), tauCollection='', jetCollection=cms.InputTag('selectedPatJets'), addToPatDefaultSequence=False, ) process.simpleAnalyzer = cms.EDAnalyzer( 'SimpleEventAnalyzer', interestingCollections=cms.untracked.VInputTag([ 'smearedPatJets', 'smearedPatJetsResUp', 'smearedPatJetsResDown', 'muonsWithID', 'shiftedMuonsWithIDenDown', 'shiftedMuonsWithIDenUp',
#Embed the reference to the original jet in the jets, which is constant during the propagation process.patJetsWithOwnRef = cms.EDProducer("PatObjectOwnRefProducer<pat::Jet>", src=cms.InputTag("selectedPatJets")) # type 1 +2 MET corrected process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") #Note: this module causes a large memory increase when crossing the file boundary #Reason - unknown, solution: limit processing to ~1 file. from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, electronCollection=cms.InputTag("selectedPatElectrons"), photonCollection=None, muonCollection=cms.InputTag("selectedPatMuons"), #FIXME: presently tau variations disabled, results in segfault tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("selectedPatJets"), jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual", doSmearJets=options.isMC, #Note: switch this to False for the sync! jetCorrPayloadName="AK5PFchs", addToPatDefaultSequence=False) process.patPFMetNoPU = process.patMETs.clone( metSource=cms.InputTag("pfMETNoPU"), addMuonCorrections=cms.bool(False), genMETSource=cms.InputTag("genMetTrue")) process.pfMETNoPU = process.pfMET.clone() process.pfMETNoPU.src = cms.InputTag("pfNoPileUp" + postfix) #rocess.pfMETNoPU.jets = cms.InputTag("pfJets"+postfix)
def miniAOD_customizeCommon(process): process.patMuons.isoDeposits = cms.PSet() process.patElectrons.isoDeposits = cms.PSet() process.patTaus.isoDeposits = cms.PSet() process.patPhotons.isoDeposits = cms.PSet() # process.patMuons.embedTrack = True # used for IDs process.patMuons.embedCombinedMuon = True # used for IDs process.patMuons.embedMuonBestTrack = True # used for IDs process.patMuons.embedStandAloneMuon = True # maybe? process.patMuons.embedPickyMuon = False # no, use best track process.patMuons.embedTpfmsMuon = False # no, use best track process.patMuons.embedDytMuon = False # no, use best track # # disable embedding of electron and photon associated objects already stored by the ReducedEGProducer process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.patElectrons.electronIDSources = cms.PSet( # configure many IDs as InputTag <someName> = <someTag> you # can comment out those you don't want to save some disk space eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"), eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"), eidLoose = cms.InputTag("reducedEgamma","eidLoose"), eidTight = cms.InputTag("reducedEgamma","eidTight"), eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"), ) process.elPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.elPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") # process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons") process.patPhotons.photonIDSources = cms.PSet( PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma', 'PhotonCutBasedIDLoose'), PhotonCutBasedIDTight = cms.InputTag('reducedEgamma', 'PhotonCutBasedIDTight') ) process.phPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedPhotons") process.phPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedPhotons") # process.selectedPatJets.cut = cms.string("pt > 10") process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))") process.selectedPatElectrons.cut = cms.string("") process.selectedPatTaus.cut = cms.string("pt > 20 && tauID('decayModeFinding')> 0.5") process.selectedPatPhotons.cut = cms.string("") # from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection #switch to AK4 (though it should soon be unnecessary as ak4 should become the 71X default) #FIXME: still using AK5PFchs for jet energy corrections, while waiting for a new globalTag switchJetCollection(process, jetSource = cms.InputTag('ak4PFJetsCHS'), jetCorrections = ('AK5PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), ''), btagDiscriminators = ['jetBProbabilityBJetTags', 'jetProbabilityBJetTags', 'trackCountingHighPurBJetTags', 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'simpleSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexBJetTags' , 'combinedInclusiveSecondaryVertexBJetTags' ], ) #add CA8 from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection # addJetCollection(process, labelName = 'CA8', jetSource = cms.InputTag('ca8PFJetsCHS'),algo= 'CA', rParam = 0.8) process.selectedPatJetsCA8.cut = cms.string("pt > 100") process.patJetGenJetMatchCA8.matched = 'slimmedGenJets' # from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone switchOnTriggerStandAlone( process, outputModule = '' ) process.patTrigger.packTriggerPathNames = cms.bool(True) # # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET # FIXME: this and the typeI MET should become AK4 once we have the proper JEC? from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties addJetCollection(process, postfix = "ForMetUnc", labelName = 'AK5PF', jetSource = cms.InputTag('ak5PFJets'), jetCorrections = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], '')) process.patJetsAK5PFForMetUnc.getJetMCFlavour = False runMEtUncertainties(process,jetCollection="selectedPatJetsAK5PFForMetUnc", outputModule=None) #keep this after all addJetCollections otherwise it will attempt computing them also for stuf with no taginfos #Some useful BTAG vars process.patJets.userData.userFunctions = cms.vstring( '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).p4.M):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).nTracks):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).value):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).significance):(0)', ) process.patJets.userData.userFunctionLabels = cms.vstring('vtxMass','vtxNtracks','vtx3DVal','vtx3DSig') process.patJets.tagInfoSources = cms.VInputTag(cms.InputTag("secondaryVertexTagInfos")) process.patJets.addTagInfos = cms.bool(True) # ## PU JetID process.load("PhysicsTools.PatAlgos.slimming.pileupJetId_cfi") process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.maxEvents = cms.untracked.PSet( input=cms.untracked.int32(options.maxEvents)) #Embed the reference to the original jet in the jets, which is constant during the propagation process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>', src=cms.InputTag("selectedPatJets")) #Note: this module causes a large memory increase when crossing the file boundary #Reason - unknown, solution: limit processing to ~1 file. from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, electronCollection=cms.InputTag("electronsWithID"), photonCollection=None, muonCollection=cms.InputTag("muonsWithID"), tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("patJetsWithOwnRef"), # jetCollection=cms.InputTag("selectedPatJets"), addToPatDefaultSequence=False) process.metUncertaintyPath = cms.Path(process.patJetsWithOwnRef * process.metUncertaintySequence) process.out = cms.OutputModule( "PoolOutputModule", dropMetaData=cms.untracked.string("DROPPED"), fileName=cms.untracked.string('out_step1B.root'), SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring([])), outputCommands=cms.untracked.vstring( #'drop *', 'keep *',
process.selectedPatElectrons.cut = ( "(ecalDrivenSeed==1) &&" + "pt > 5.0 && abs(eta) < 2.5 &&" + "(isEE || isEB) && !isEBEEGap" ) ######## MET Correction TODO: fix it! # type 1 +2 MET corrected process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") #-------------------------------------------------------------------------------- from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, 'selectedPatElectrons', '', 'selectedPatMuons', 'selectedPatTaus' , 'selectedPatJets') process.HbbAnalyzerNew = cms.EDProducer("HbbAnalyzerNew", runOnMC = cms.bool(isMC), hltResultsTag = cms.InputTag("TriggerResults::HLT"), lep_ptCutForBjets = cms.double(5), electronNoCutsTag = cms.InputTag("gsfElectrons"), # electronTag = cms.InputTag("selectedElectronsMatched"), electronTag = cms.InputTag("selectedPatElectrons"), tauTag = cms.InputTag("patTaus"),
# MinJetPt = cms.double(30), # MaxJetEta = cms.double(5) # ) # ------------------------------------------------------------------------------ # MET Smearing Correction # https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools # ------------------------------------------------------------------------------ # NB: The photonCollection parameter is set to None per default, in order to # avoid overlap with the electron collection. # NB: The energies of pat::Jets are smeared by the Data/MC difference in PFJet # resolution per default. The smearing factors are taken from JME-10-014. # NB: Type-0 MET correction are applied (default). # NB: MET systematic x/y shift correction is not applied (default). from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, 'selectedPatElectrons', None, 'selectedPatMuons', 'selectedPatTaus', 'selectedPatJets', jetCorrLabel=("L3Absolute" if RUN_ON_MC else "L2L3Residual"), doSmearJets=True, doApplyType0corr=True, doApplySysShiftCorr=False) # change doSmearJets=True to doSmearJets=RUN_ON_MC ? ################################################################################ # Trigger # ################################################################################ from PhysicsTools.PatAlgos.tools.trigTools import * # In general, it should always be used after any modification done to paths # (including the out-path), sequences and the modules they contain, since the # current configuration is used in these tools to determine e.g. the correct # order of module executions or the output to be saved in the event. switchOnTrigger( process ) ################################################################################
def miniAOD_customizeCommon(process): process.patMuons.isoDeposits = cms.PSet() process.patElectrons.isoDeposits = cms.PSet() process.patTaus.isoDeposits = cms.PSet() process.patPhotons.isoDeposits = cms.PSet() # process.patMuons.embedTrack = True # used for IDs process.patMuons.embedCombinedMuon = True # used for IDs process.patMuons.embedMuonBestTrack = True # used for IDs process.patMuons.embedStandAloneMuon = True # maybe? process.patMuons.embedPickyMuon = False # no, use best track process.patMuons.embedTpfmsMuon = False # no, use best track process.patMuons.embedDytMuon = False # no, use best track # process.patElectrons.embedPflowSuperCluster = False process.patElectrons.embedPflowBasicClusters = False process.patElectrons.embedPflowPreshowerClusters = False # process.selectedPatJets.cut = cms.string("pt > 10") process.selectedPatMuons.cut = cms.string( "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))" ) process.selectedPatElectrons.cut = cms.string("") process.selectedPatTaus.cut = cms.string( "pt > 20 && tauID('decayModeFinding')> 0.5") process.selectedPatPhotons.cut = cms.string( "pt > 15 && hadTowOverEm()<0.15 ") # from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection # addJetCollection(process, labelName='CA8', jetSource=cms.InputTag('ca8PFJetsCHS'), algo='CA', rParam=0.8) process.selectedPatJetsCA8.cut = cms.string("pt > 100") process.patJetGenJetMatchCA8.matched = 'slimmedGenJets' # ## PU JetID process.load("PhysicsTools.PatAlgos.slimming.pileupJetId_cfi") process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ] # #Some useful BTAG vars process.patJets.userData.userFunctions = cms.vstring( '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).p4.M):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).nTracks):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).value):(0)', '?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).significance):(0)', ) process.patJets.userData.userFunctionLabels = cms.vstring( 'vtxMass', 'vtxNtracks', 'vtx3DVal', 'vtx3DSig') process.patJets.tagInfoSources = cms.VInputTag( cms.InputTag("secondaryVertexTagInfos")) process.patJets.addTagInfos = cms.bool(True) # from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone switchOnTriggerStandAlone(process) process.patTrigger.packTriggerPathNames = cms.bool(True) # # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties addJetCollection(process, postfix="ForMetUnc", labelName='AK5PF', jetSource=cms.InputTag('ak5PFJets'), jetCorrections=('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], ''), btagDiscriminators=['combinedSecondaryVertexBJetTags']) runMEtUncertainties(process, jetCollection="selectedPatJetsAK5PFForMetUnc", outputModule=None)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties #from JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi import * #runMEtUncertainties(process) #from PhysicsTools.PatUtils.tools.metUncertaintyTools import * print process.pfMEtSysShiftCorrParameters_2012runABCvsNvtx_mc[0] if isMC == False: runMEtUncertainties(process, electronCollection = cms.InputTag('cleanPatElectrons'), photonCollection = '', muonCollection = 'selectedPatMuons', tauCollection = 'selectedPatTaus', jetCollection = cms.InputTag('selectedPatJets'), jetCorrLabel = 'L2L3Residual', doSmearJets = False, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, makePFMEtByMVA = False, makeNoPileUpPFMEt = False, doApplyType0corr = False, sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCvsNvtx_data[0], #sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCvsNvtx_data, doApplySysShiftCorr = False, addToPatDefaultSequence = False, ) else: runMEtUncertainties(process, electronCollection = cms.InputTag('cleanPatElectrons'), photonCollection = '', muonCollection = 'selectedPatMuons',
process.patElectrons.electronIDSources = process.electronIDSources postfix = "" # Configure PAT to use PF2PAT instead of AOD sources: from PhysicsTools.PatAlgos.tools.pfTools import * from PhysicsTools.PatAlgos.tools.trigTools import * from PhysicsTools.PatUtils.tools.metUncertaintyTools import * Postfix = "" runOnMC = (not isData) jetAlgoName = "AK5" usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgoName, runOnMC=runOnMC, postfix=Postfix, jetCorrections=('AK5PFchs',['L1FastJet','L2Relative','L3Absolute']), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), typeIMetCorrections=isData) if (not(isData)): from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process,electronCollection = "selectedPatElectrons", doSmearJets= False, muonCollection = "selectedPatMuons", tauCollection="selectedPatTaus", jetCollection = "selectedPatJets") #Note: we run the MET uncertainty tools if it is MC. If it is data, the type 1 corrected METs #Trigger matching: switchOnTriggerMatchEmbedding(process,triggerMatchers = ['PatMuonTriggerMatchHLTIsoMu24','PatJetTriggerMatchHLTIsoMuBTagIP']) #PF no Pileup: process.pfPileUp.Enable = True process.load("CMGTools.External.pujetidsequence_cff") process.pfPileUp.checkClosestZVertex = cms.bool(False) #Use DR = 0.3 for electrons: 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.selectedPatElectrons.cut = ("(ecalDrivenSeed==1) &&" + "pt > 5.0 && abs(eta) < 2.5 &&" + "(isEE || isEB) && !isEBEEGap") ######## MET Correction TODO: fix it! # type 1 +2 MET corrected process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") #-------------------------------------------------------------------------------- from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, 'selectedPatElectrons', '', 'selectedPatMuons', 'selectedPatTaus', 'selectedPatJets') process.HbbAnalyzerNew = cms.EDProducer( "HbbAnalyzerNew", runOnMC=cms.bool(isMC), hltResultsTag=cms.InputTag("TriggerResults::HLT"), lep_ptCutForBjets=cms.double(5), electronNoCutsTag=cms.InputTag("gsfElectrons"), # electronTag = cms.InputTag("selectedElectronsMatched"), electronTag=cms.InputTag("selectedPatElectrons"), tauTag=cms.InputTag("patTaus"), muonNoCutsTag=cms.InputTag("muons"), muonTag=cms.InputTag("selectedPatMuons"), # muonTag = cms.InputTag("selectedMuonsMatched"), jetTag=cms.InputTag("selectedPatJetsCAVHFatPF"), subjetTag=cms.InputTag("selectedPatJetsCAVHSubPF"),
cms.InputTag('pfMETcorrType0'), cms.InputTag('pfJetMETcorr', 'type1') ) # Get PFMET from runMEtUncertainties from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi") runMEtUncertainties(process, electronCollection = cms.InputTag('cleanPatElectrons'), photonCollection = '', muonCollection = 'cleanPatMuons', tauCollection = '', jetCollection = cms.InputTag('selectedPatJets'), jetCorrLabel = 'L3Absolute', doSmearJets = True, makeType1corrPFMEt = True, makeType1p2corrPFMEt = False, makePFMEtByMVA = False, makeNoPileUpPFMEt = False, doApplyType0corr = True, #sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc, doApplySysShiftCorr = False, ) process.producePatPFMETCorrections.replace(process.patPFJetMETtype2Corr,process.patPFJetMETtype2Corr + process.type0PFMEtCorrectionPFCandToVertexAssociation + process.patPFMETtype0Corr) # Fix Type0 correction module process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209) process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531) process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151) process.patPFMETtype0Corr.correction.par0 = cms.double(0.0)
process.slimmedJets.clearDaughters = False #process.slimmedElectrons.dropRecHits = True #process.slimmedElectrons.dropBasicClusters = True #process.slimmedElectrons.dropPFlowClusters = True #process.slimmedElectrons.dropPreshowerClusters = True from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone switchOnTriggerStandAlone( process ) process.patTrigger.packTriggerPathNames = cms.bool(True) # ## # process.options.wantSummary = False ## (to suppress the long output at the end of the job) # ## # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties addJetCollection(process, postfix = "ForMetUnc", labelName = 'AK5PF', jetSource = cms.InputTag('ak5PFJets'), jetCorrections = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], ''), btagDiscriminators = ['combinedSecondaryVertexBJetTags' ] ) runMEtUncertainties(process,jetCollection="selectedPatJetsAK5PFForMetUnc", outputModule=None) # process.out.outputCommands = [ ... ] ## (e.g. taken from PhysicsTools/PatAlgos/python/patEventContent_cff.py) # ## process.out.fileName = 'patTuple_micro.root' process.out.outputCommands = process.MicroEventContentMC.outputCommands process.out.dropMetaData = cms.untracked.string('ALL') process.out.fastCloning= cms.untracked.bool(False) process.out.overrideInputFileSplitLevels = cms.untracked.bool(True)
process.source.fileNames = cms.untracked.vstring(options.inputFiles) process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(options.maxEvents)) #Embed the reference to the original jet in the jets, which is constant during the propagation process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>', src=cms.InputTag("selectedPatJets") ) #Note: this module causes a large memory increase when crossing the file boundary #Reason - unknown, solution: limit processing to ~1 file. from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, electronCollection=cms.InputTag("electronsWithID"), photonCollection=None, muonCollection=cms.InputTag("muonsWithID"), tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("patJetsWithOwnRef"), # jetCollection=cms.InputTag("selectedPatJets"), addToPatDefaultSequence=False ) process.metUncertaintyPath = cms.Path( process.patJetsWithOwnRef * process.metUncertaintySequence ) process.out = cms.OutputModule("PoolOutputModule", dropMetaData=cms.untracked.string("DROPPED"), fileName=cms.untracked.string('out_step1B.root'), SelectEvents=cms.untracked.PSet( SelectEvents=cms.vstring([]) ),
print sep_line print 'postfix : ', postfix print sep_line print 'JEC : ', jetCorrections print sep_line ######################################### usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgoName, runOnMC=runOnMC, postfix=postfix, jetCorrections=('AK5PFchs',jetCorrections), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), # jetCorrections=('AK5PFchs',jetCorrections), pvCollection=cms.InputTag('offlinePrimaryVertices'), typeIMetCorrections=(not doRunMETUncertainties)) if doRunMETUncertainties: from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties if isData: runMEtUncertainties(process,electronCollection = "selectedPatElectrons", doSmearJets= False, muonCollection = "selectedPatMuons", tauCollection="selectedPatTaus", jetCollection = "selectedPatJets",jetCorrLabel="L2L3Residual") process.patPFMet.addGenMET = False process.patPFMetJetEnUp.addGenMET = False process.patPFMetJetEnDown.addGenMET = False process.patPFMetElectronEnUp.addGenMET = False process.patPFMetElectronEnDown.addGenMET = False process.patPFMetMuonEnUp.addGenMET = False process.patPFMetMuonEnDown.addGenMET = False process.patPFMetTauEnUp.addGenMET = False process.patPFMetTauEnDown.addGenMET = False process.patPFMetTauEnUp.addGenMET = False process.patPFMetTauEnDown.addGenMET = False else: runMEtUncertainties(process,electronCollection = "selectedPatElectrons", doSmearJets= False, muonCollection = "selectedPatMuons", tauCollection="selectedPatTaus", jetCollection = "selectedPatJets",) # CONFIGURE LEPTONS for the analysis
def filterTightWenuCandidates(process, isMC): process.tightWenuSelectionSequence = cms.Sequence() # Trigger requirements process.load("HLTrigger.HLTfilters.hltHighLevel_cfi") process.wenuHLTFilter = process.hltHighLevel.clone( TriggerResultsTag=cms.InputTag("TriggerResults", "", "HLT"), HLTPaths=cms.vstring([ # single electron triggers (2011 Run B) 'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v7', 'HLT_Ele25_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v5', # single electron triggers (Summer'11 MC) 'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v1', 'HLT_Ele27_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v2', ]), throw=cms.bool(False)) process.tightWenuSelectionSequence += process.wenuHLTFilter # Vertex selection process.goodVertex = cms.EDFilter( "VertexSelector", src=cms.InputTag("offlinePrimaryVertices"), cut=cms.string( "isValid & ndof >= 4 & abs(z) < 24 & abs(position.Rho) < 2"), filter=cms.bool(True)) process.tightWenuSelectionSequence += process.goodVertex process.load("CommonTools.ParticleFlow.pfNoPileUp_cff") process.pfPileUp.Enable = cms.bool(True) process.pfPileUp.checkClosestZVertex = cms.bool(True) process.tightWenuSelectionSequence += process.pfNoPileUpSequence process.load("CommonTools.ParticleFlow.pfParticleSelection_cff") process.tightWenuSelectionSequence += process.pfParticleSelectionSequence process.load("PhysicsTools/PatAlgos/patSequences_cff") # compute electron IsoDeposits process.load("TauAnalysis.Skimming.electronPFIsolationDeposits_cff") process.load("TauAnalysis.Skimming.electronPFIsolationValues_cff") process.electronPFIsolationSequence = cms.Sequence( process.electronPFIsolationDepositsSequence * process.electronPFIsolationValuesSequence) process.tightWenuSelectionSequence += process.electronPFIsolationSequence # configure pat::Electron production process.patElectrons.isoDeposits = cms.PSet( # CV: strings for IsoDeposits defined in PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc pfChargedHadrons=cms.InputTag("elecPFIsoDepositCharged"), pfNeutralHadrons=cms.InputTag("elecPFIsoDepositNeutral"), pfPhotons=cms.InputTag("elecPFIsoDepositGamma"), user=cms.VInputTag(cms.InputTag("elecPFIsoDepositChargedAll"), cms.InputTag("elecPFIsoDepositPU"))) process.patElectrons.userIsolation = cms.PSet( # CV: strings for Isolation values defined in PhysicsTools/PatAlgos/src/MultiIsolator.cc pfChargedHadron=cms.PSet( deltaR=cms.double(0.4), src=process.patElectrons.isoDeposits.pfChargedHadrons, vetos=process.elecPFIsoValueCharged04.deposits[0].vetos, skipDefaultVeto=process.elecPFIsoValueCharged04.deposits[0]. skipDefaultVeto), pfNeutralHadron=cms.PSet( deltaR=cms.double(0.4), src=process.patElectrons.isoDeposits.pfNeutralHadrons, vetos=process.elecPFIsoValueNeutral04.deposits[0].vetos, skipDefaultVeto=process.elecPFIsoValueNeutral04.deposits[0]. skipDefaultVeto), pfGamma=cms.PSet( deltaR=cms.double(0.4), src=process.patElectrons.isoDeposits.pfPhotons, vetos=process.elecEBPFIsoValueGamma04.deposits[0].vetos, skipDefaultVeto=process.elecEBPFIsoValueGamma04.deposits[0]. skipDefaultVeto), user=cms.VPSet( cms.PSet( deltaR=cms.double(0.4), src=process.patElectrons.isoDeposits.user[0], vetos=process.elecEBPFIsoValueChargedAll04.deposits[0].vetos, skipDefaultVeto=process.elecEBPFIsoValueChargedAll04. deposits[0].skipDefaultVeto), cms.PSet(deltaR=cms.double(0.4), src=process.patElectrons.isoDeposits.user[1], vetos=process.elecPFIsoValuePU04.deposits[0].vetos, skipDefaultVeto=process.elecPFIsoValuePU04.deposits[0]. skipDefaultVeto), cms.PSet(deltaR=cms.double(0.4), src=process.patElectrons.isoDeposits.pfPhotons, vetos=process.elecEEPFIsoValueGamma04.deposits[0].vetos, skipDefaultVeto=process.elecEEPFIsoValueGamma04. deposits[0].skipDefaultVeto), cms.PSet( deltaR=cms.double(0.4), src=process.patElectrons.isoDeposits.user[0], vetos=process.elecEEPFIsoValueChargedAll04.deposits[0].vetos, skipDefaultVeto=process.elecEEPFIsoValueChargedAll04. deposits[0].skipDefaultVeto))) process.patElectrons.addGenMatch = cms.bool(False) process.patElectrons.embedHighLevelSelection = cms.bool(True) process.patElectrons.usePV = cms.bool( False ) # compute transverse impact parameter wrt. beamspot (not event vertex) if not isMC: # remove MC matching from standard PAT sequences removeMCMatching(process, ["All"], outputInProcess=False) process.patDefaultSequence.remove(process.patJetPartonMatch) # select tight electrons, no isolation cuts applied process.selectedElectronsWP80 = cms.EDFilter("PATElectronSelector", src = cms.InputTag("patElectrons"), cut = cms.string( 'pt > 25 & abs(eta) < 2.1 & ' + \ '(isEB & ' + \ ' sigmaIetaIeta < 0.010 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.06 & deltaEtaSuperClusterTrackAtVtx < 0.004 & ' + \ ' hadronicOverEm < 0.04) | ' + \ '(isEE & ' + \ ' sigmaIetaIeta < 0.030 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.03 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \ ' hadronicOverEm < 0.025)' ), filter = cms.bool(True) ) process.selectedElectronsWP80conversionVeto = cms.EDFilter( "NPATElectronConversionFinder", src=cms.InputTag("selectedElectronsWP80"), filter=cms.bool(True)) # select loose electrons, used for di-electron veto process.selectedElectronsWP95 = cms.EDFilter("PATElectronSelector", src = cms.InputTag("patElectrons"), cut = cms.string( 'pt > 20 & abs(eta) < 2.5 & ' + \ 'gsfTrack.isNonnull & gsfTrack.trackerExpectedHitsInner.numberOfHits <= 1 &' + \ '(isEB & ' + \ ' sigmaIetaIeta < 0.010 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.80 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \ ' hadronicOverEm < 0.15) | ' + \ '(isEE & ' + \ ' sigmaIetaIeta < 0.030 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.70 & deltaEtaSuperClusterTrackAtVtx < 0.010 & ' + \ ' hadronicOverEm < 0.07)' ), filter = cms.bool(False) ) # select tight electrons which are isolated process.selectedIsoElectronsWP80 = cms.EDFilter("PATElectronSelector", src = cms.InputTag("selectedElectronsWP80conversionVeto"), cut = cms.string( '(isEB & ' + \ '(userIsolation("pat::User1Iso")' + \ ' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::PfGammaIso")' + \ ' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt) | ' + \ '(isEE & ' + \ '(userIsolation("pat::User4Iso")' + \ ' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::User3Iso")' + \ ' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt)' ), filter = cms.bool(False) ) process.patDefaultSequence.replace( process.patElectrons, process.patElectrons * process.selectedElectronsWP80 * process.selectedElectronsWP80conversionVeto * process.selectedIsoElectronsWP80 * process.selectedElectronsWP95) # configure pat::Jet production # (enable L2L3Residual corrections in case running on Data) jetCorrections = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not isMC: jetCorrections.append('L2L3Residual') switchJetCollection(process, cms.InputTag('ak5PFJets'), doJTA=True, doBTagging=False, jetCorrLabel=('AK5PF', cms.vstring(jetCorrections)), doType1MET=False, doJetID=True, jetIdLabel="ak5", outputModule='') # configure pat::MET production process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") process.tightWenuSelectionSequence += process.kt6PFJets process.tightWenuSelectionSequence += process.ak5PFJets process.tightWenuSelectionSequence += process.patDefaultSequence doSmearJets = None if isMC: doSmearJets = True else: doSmearJets = False runMEtUncertainties( process, electronCollection=cms.InputTag('selectedIsoElectronsWP80'), photonCollection='', muonCollection='', tauCollection='', jetCollection=cms.InputTag('patJets'), doSmearJets=doSmearJets, addToPatDefaultSequence=False) if isMC: process.patPFMet.addGenMET = cms.bool(True) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute") process.tightWenuSelectionSequence += process.metUncertaintySequence else: process.patPFMet.addGenMET = cms.bool(False) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string( "L2L3Residual") process.tightWenuSelectionSequence += process.patJetsNotOverlappingWithLeptonsForMEtUncertainty process.tightWenuSelectionSequence += process.producePatPFMETCorrections # Apply event selection cuts process.isoElectronWP80Filter = cms.EDFilter( "CandViewCountFilter", src=cms.InputTag("selectedIsoElectronsWP80"), minNumber=cms.uint32(1)) process.tightWenuSelectionSequence += process.isoElectronWP80Filter process.diElectronVeto = cms.EDFilter( "PATCandViewMaxFilter", src=cms.InputTag("selectedElectronsWP95"), maxNumber=cms.uint32(1)) process.tightWenuSelectionSequence += process.diElectronVeto process.WenuCandidates = cms.EDProducer( "PATElecNuPairProducer", srcVisDecayProducts=cms.InputTag('selectedIsoElectronsWP80'), srcMET=cms.InputTag('patType1CorrectedPFMet'), verbosity=cms.untracked.int32(0)) process.tightWenuSelectionSequence += process.WenuCandidates process.selectedWenuCandidates = cms.EDFilter( "PATElecNuPairSelector", src=cms.InputTag("WenuCandidates"), cut=cms.string('mt > 50.'), filter=cms.bool(False)) process.tightWenuSelectionSequence += process.selectedWenuCandidates process.tightWenuFilter = cms.EDFilter( "CandViewCountFilter", src=cms.InputTag("selectedWenuCandidates"), minNumber=cms.uint32(1)) process.tightWenuSelectionSequence += process.tightWenuFilter
#process.load("PhysicsTools.PatUtils.tools.metUncertaintyTools") process.load('Configuration.StandardSequences.Services_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag = 'START53_V23::All' ##-------------------- Import the JEC services ----------------------- process.load('JetMETCorrections.Configuration.DefaultJEC_cff') runMEtUncertainties(process, electronCollection = cms.InputTag('selectedPatElectrons'), muonCollection = cms.InputTag('selectedPatMuons'), tauCollection = cms.InputTag('selectedPatTaus'), jetCollection = cms.InputTag('selectedPatJets'), makePFMEtByMVA = True, doSmearJets = True, addToPatDefaultSequence = False ) ########################## # Nominal Systematics # ########################## process.TupleMuonsNominal = cms.EDProducer('TupleMuonProducer' , muonSrc =cms.InputTag('selectedPatMuons'), vertexSrc =cms.InputTag('offlinePrimaryVertices'), NAME=cms.string("TupleMuonsNominal") )
# # # EXERCISE 3 # # # ################# ## The MET Uncertainty tool needs some more things to be there: process.load("Configuration.StandardSequences.Geometry_cff") process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") from Configuration.AlCa.autoCond import autoCond process.GlobalTag.globaltag = cms.string( autoCond[ 'startup' ] ) process.load("Configuration.StandardSequences.MagneticField_cff") process.load("PhysicsTools.PatAlgos.patSequences_cff") #Applying the MET Uncertainty tools from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, electronCollection = cms.InputTag("selectedPatElectronsPFlow"), jetCollection="selectedPatJetsPFlow", muonCollection = cms.InputTag("selectedPatMuonsPFlow"), tauCollection = cms.InputTag("selectedPatTausPFlow") ) #process.shiftedPatJetsEnUp=process.shiftedPatJetsPFlowEnUpForCorrMEt.clone(shiftBy=cms.double(2), src="selectedPatJetsPFlow") #process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJetsEnUp")) #process.p_jec.__iadd__( process.shiftedPatJetsEnUp * process.jecAnalyzerEnUp) ################# # # # EXERCISE 4 # # # ################# process.patJPsiCandidates = cms.EDProducer("PatJPsiProducer", muonSrc = cms.InputTag("selectedPatMuonsPFlow") )
PF2PATPostfix = "PFlow" jetAlgo="AK5" #addPfMET(process, postfixLabel=postfix) usePF2PAT(process,runPF2PAT=True,jetAlgo=jetAlgo,runOnMC=True,postfix=PF2PATPostfix,jetCorrections=('AK5PF',['L1FastJet','L2Relative','L3Absolute']),typeIMetCorrections=True,outputModules=[]) # to use tau-cleaned jet collection uncomment the following: #getattr(process,"pfNoTau"+postfix).enable = True # to switch default tau to HPS tau uncomment the following: #adaptPFTaus(process,"hpsPFTau",postfix=postfix) from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties from JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi import * runMEtUncertainties(process, electronCollection='selectedPatElectronsPFlow', muonCollection='selectedPatMuonsPFlow', tauCollection='selectedPatTausPFlow', jetCollection='selectedPatJetsPFlow',doApplyType0corr=False, doSmearJets=False, postfix='NotSmeared') process.patPFMETtype0CorrNotSmeared=process.patPFMETtype0Corr.clone() process.PF2PAT = cms.Sequence( # process.patDefaultSequence + getattr(process,"patPF2PATSequence"+PF2PATPostfix) + process.type0PFMEtCorrection + process.patPFMETtype0CorrNotSmeared + process.metUncertaintySequenceNotSmeared ) #output commands skimEventContent = cms.PSet( outputCommands = cms.untracked.vstring( "keep *", "drop *_*ak7*_*_*",
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools # ------------------------------------------------------------------------------ # NB: The photonCollection parameter is set to None per default, in order to # avoid overlap with the electron collection. # NB: The energies of pat::Jets are smeared by the Data/MC difference in PFJet # resolution per default. The smearing factors are taken from JME-10-014. # NB: Type-0 MET correction are applied (default). # NB: MET systematic x/y shift correction is not applied (default). from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, "selectedPatElectrons", None, "selectedPatMuons", "selectedPatTaus", "selectedPatJets", jetCorrLabel=("L3Absolute" if RUN_ON_MC else "L2L3Residual"), doSmearJets=True, doApplyType0corr=True, doApplySysShiftCorr=False, ) # change doSmearJets=True to doSmearJets=RUN_ON_MC ? ################################################################################ # Trigger # ################################################################################ from PhysicsTools.PatAlgos.tools.trigTools import * # In general, it should always be used after any modification done to paths # (including the out-path), sequences and the modules they contain, since the # current configuration is used in these tools to determine e.g. the correct
process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data #---------------------------------------------------------------------------------------------------- # Use the runMetUncertainties tool here # See https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools #---------------------------------------------------------------------------------------------------- from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, jetCollection = cms.InputTag('analysisPatJetsAK5PF'), doApplySysShiftCorr = True, # Apply correction for systematic x/y shift in MET doApplyType0corr = True, # Apply correction for pileup makeType1corrPFMEt = True, # Apply correction for jet energy scale makeType1p2corrPFMEt = False, # DO NOT apply correction for unclustered energy (degrades MET resolution) makePFMEtByMVA = False, # We don't use MVA PFMET doSmearJets = False, # Very important to NOT smear the pfjets (DATA ONLY) addToPatDefaultSequence = True, # Add this to the PAT sequence sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data ) #---------------------------------------------------------------------------------------------------- # Available pat::MET collections for analysis # - process.patMETsTC : raw TCMET (NO jet smearing) # # - process.patMETsRawCalo : raw CaloMET (NO jet smearing) # - process.patMETs : Type1 CaloMET (NO jet smearing) # # - process.patMETsRawPF : raw PFMET (NO jet smearing) # - process.patType1CorrectedPFMet_Type1Only : Type1 PFMET (NO jet smearing)
switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA = True, doBTagging = False, jetCorrLabel = _jetCorrections, doType1MET = False, doJetID = True, jetIdLabel = "ak5" ) # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process,doApplyType0corr=False) process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1CorrectedMet process.pfMETType0 = pfType1CorrectedMet.clone() process.pfMETType0.applyType1Corrections = cms.bool(True) process.pfMETType0.applyType0Corrections = cms.bool(True) if tauSwitch: tausequence = cms.Sequence( process.PFTau) else: tausequence = cms.Sequence() if IsPythiaShowered: filtersequence = cms.Sequence( process.totalKinematicsFilter ) else:
def addInvHiggsProcess( process, iRunOnData=True, iData="ParkedData", iHLTFilter="MET", iMCSignal=False, iFile='/store/data/Run2012C/VBF1Parked/AOD/22Jan2013-v1/20000/40F56410-D979-E211-9843-002618943849.root', iMaxEvent=100): ###-------------------------------------------------------------- ### Load PAT, because it insists on defining the process for you #from PhysicsTools.PatAlgos.patTemplate_cfg import * ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Input process.maxEvents.input = iMaxEvent process.source.fileNames = [iFile] ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### GlobalTag if iRunOnData == True: process.GlobalTag.globaltag = "FT53_V21A_AN6::All" else: process.GlobalTag.globaltag = "START53_V27::All" ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Logger process.load("FWCore.MessageService.MessageLogger_cfi") process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport = cms.untracked.PSet( reportEvery=cms.untracked.int32(2000), limit=cms.untracked.int32(10000000)) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### L1 Trigger process.load('L1Trigger.Skimmer.l1Filter_cfi') process.l1Filter.algorithms = cms.vstring('L1_ETM40') ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### HLT Trigger(s) # If it's MC signal, no trigger will be applied if iRunOnData == False and iMCSignal == True: iHLTFilter = "NoTrig" # Load hltHighLevel process.load('HLTrigger.HLTfilters.hltHighLevel_cfi') process.hltHighLevel.TriggerResultsTag = cms.InputTag( "TriggerResults", "", "HLT") process.hltHighLevel.throw = cms.bool( False) # Tolerate if triggers not available process.hltHighLevel.andOr = cms.bool(True) # True = OR, False = AND if (iRunOnData == True and iHLTFilter.find("MET") == 0): process.hltHighLevel.HLTPaths = cms.vstring( #"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*", #"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*" "HLT_DiJet35_MJJ700_AllJets_DEta3p5_VBF_v*", "HLT_DiJet30_MJJ700_AllJets_DEta3p5_VBF_v*") elif (iHLTFilter.find("SingleMu") == 0): process.hltHighLevel.HLTPaths = cms.vstring("HLT_IsoMu24_eta2p1_v*", "HLT_Mu40_eta2p1_v*") #elif (iHLTFilter.find("DoubleMu")==0): # process.hltHighLevel.HLTPaths = cms.vstring("HLT_Mu17_Mu8_v*") #elif (iHLTFilter.find("SingleElectron")==0): # process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele27_WP80_v*") #elif (iHLTFilter.find("DoubleElectron")==0): # process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*") elif (iHLTFilter.find("NoTrig") == 0): process.hltHighLevel.HLTPaths = cms.vstring("*") else: process.hltHighLevel.HLTPaths = cms.vstring( #"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*", #"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*" "HLT_DiJet35_MJJ700_AllJets_DEta3p5_VBF_v*", "HLT_DiJet30_MJJ700_AllJets_DEta3p5_VBF_v*") ### VBF filter for MC Background process.vbfFilter = cms.EDFilter("HLTPFJetVBFFilter", saveTags=cms.bool(True), triggerType=cms.int32(85), inputTag=cms.InputTag("ak5PFJets"), leadingJetOnly=cms.bool(False), minPtHigh=cms.double(25.0), minPtLow=cms.double(25.0), maxEta=cms.double(5.0), etaOpposite=cms.bool(True), minDeltaEta=cms.double(3.0), minInvMass=cms.double(500.0)) ###-------------------------------------------------------------- ###-------------------------------------------------------------- print "-----------------------------------------------" print "INVISIBLE HIGGS: Ntuple V12 for Parked Data" print "-----------------------------------------------" print "RunOnData = ", iRunOnData if iRunOnData == True: print "Dataset = ", iData else: if iMCSignal == True: print "Dataset = MC Signal or DYNoTrig" else: print "Dataset = MC Background" print "GlobalTag = ", process.GlobalTag.globaltag print "Trigger = ", process.hltHighLevel.HLTPaths print "Sample input file = ", iFile print "Max events = ", iMaxEvent print "-----------------------------------------------" ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Basic filters # Track quality filter process.noscraping = cms.EDFilter("FilterOutScraping", applyfilter=cms.untracked.bool(True), debugOn=cms.untracked.bool(False), numtrack=cms.untracked.uint32(10), thresh=cms.untracked.double(0.25)) # Require a good vertex 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)) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### MET Filters # The iso-based HBHE noise filter process.load('CommonTools.RecoAlgos.HBHENoiseFilter_cfi') # The CSC beam halo tight filter process.load('RecoMET.METAnalyzers.CSCHaloFilter_cfi') # The HCAL laser filter process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi") #process.load("EventFilter.HcalRawToDigi.hcallasereventfilter2012_cff") #process.hcallasereventfilter2012.eventFileName = cms.string('HCALLaser2012AllDatasets.txt.gz') process.load( "EventFilter.HcalRawToDigi.hcallaserFilterFromTriggerResult_cff") # The ECAL dead cell trigger primitive filter process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi') # The EE bad SuperCrystal filter process.load('RecoMET.METFilters.eeBadScFilter_cfi') # The ECAL laser correction filter process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi') # The Good vertices collection needed by the tracking failure filter process.goodVertices = cms.EDFilter( "VertexSelector", filter=cms.bool(False), src=cms.InputTag("offlinePrimaryVertices"), cut=cms.string( "!isFake && ndof > 4 && abs(z) <= 24 && position.rho < 2")) # The tracking failure filter process.load('RecoMET.METFilters.trackingFailureFilter_cfi') # The tracking POG filters process.load('RecoMET.METFilters.trackingPOGFilters_cff') ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### customise PAT process.load('JetMETCorrections.Configuration.DefaultJEC_cff') from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching, runOnData if iRunOnData == True: removeMCMatching(process, ['All']) runOnData(process) # Add the PF MET from PhysicsTools.PatAlgos.tools.metTools import addPfMET addPfMET(process, 'PF') # Switch to PF jets from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection if iRunOnData == True: switchJetCollection(process, cms.InputTag('ak5PFJets'), doJTA=True, doBTagging=False, jetCorrLabel=('AK5PF', [ 'L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual' ]), doType1MET=True, genJetCollection=cms.InputTag("ak5GenJets"), doJetID=False, jetIdLabel="ak5") else: switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=True, doBTagging=False, jetCorrLabel=('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']), doType1MET=True, genJetCollection=cms.InputTag("ak5GenJets"), doJetID=False, jetIdLabel="ak5") from PhysicsTools.PatAlgos.tools.pfTools import usePFIso usePFIso(process) process.patMuons.isoDeposits = cms.PSet() process.patMuons.isolationValues = cms.PSet() process.patElectrons.isolationValues = cms.PSet( pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03PFIdPFIso"), pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03PFIdPFIso"), pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03PFIdPFIso"), pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03PFIdPFIso"), pfPhotons=cms.InputTag("elPFIsoValueGamma03PFIdPFIso")) process.patElectrons.isolationValuesNoPFId = cms.PSet( pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03NoPFIdPFIso"), pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03NoPFIdPFIso"), pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03NoPFIdPFIso"), pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03NoPFIdPFIso"), pfPhotons=cms.InputTag("elPFIsoValueGamma03NoPFIdPFIso")) process.patDefaultSequence.replace( process.patElectrons, process.eleIsoSequence + process.patElectrons) process.cleanPatTaus.preselection = cms.string( 'tauID("decayModeFinding") > 0.5 & tauID("byLooseCombinedIsolationDeltaBetaCorr") > 0.5' ) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Object (pre) selection # Jet selection process.selectedPatJets.cut = cms.string("pt>10. && abs(eta)<5.") # Remove overlaps ??? # process.cleanPatJets.finalCut = "!hasOverlaps('electrons') && !hasOverlaps('muons')" # Apply loose PF jet ID from PhysicsTools.SelectorUtils.pfJetIDSelector_cfi import pfJetIDSelector process.goodPatJets = cms.EDFilter("PFJetIDSelectionFunctorFilter", filterParams=pfJetIDSelector.clone(), src=cms.InputTag("selectedPatJets"), filter=cms.bool(True)) process.selectedPatMuons.cut = cms.string( "isGlobalMuon && pt>10. && abs(eta)<2.5") process.selectedPatElectrons.cut = cms.string("pt>10. && abs(eta)<2.5") ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Load the PU JetID sequence if iRunOnData == True: process.load("CMGTools.External.pujetidsequence_cff") process.puJetMva.jets = cms.InputTag("goodPatJets") process.puJetId.jets = cms.InputTag("goodPatJets") else: process.load("CMGTools.External.pujetidsequence_cff") process.puJetMva.jets = cms.InputTag("goodPatJets") process.puJetId.jets = cms.InputTag("goodPatJets") process.puJetMvaSmeared = process.puJetMva.clone() process.puJetIdSmeared = process.puJetId.clone() process.puJetMvaResUp = process.puJetMva.clone() process.puJetIdResUp = process.puJetId.clone() process.puJetMvaResDown = process.puJetMva.clone() process.puJetIdResDown = process.puJetId.clone() process.puJetMvaEnUp = process.puJetMva.clone() process.puJetIdEnUp = process.puJetId.clone() process.puJetMvaEnDown = process.puJetMva.clone() process.puJetIdEnDown = process.puJetId.clone() process.puJetIdSmeared.jets = cms.InputTag("smearedGoodPatJets") process.puJetMvaSmeared.jetids = cms.InputTag("puJetIdSmeared") process.puJetMvaSmeared.jets = cms.InputTag("smearedGoodPatJets") process.puJetIdResUp.jets = cms.InputTag("smearedGoodPatJetsResUp") process.puJetMvaResUp.jetids = cms.InputTag("puJetIdResUp") process.puJetMvaResUp.jets = cms.InputTag("smearedGoodPatJetsResUp") process.puJetIdResDown.jets = cms.InputTag("smearedGoodPatJetsResDown") process.puJetMvaResDown.jetids = cms.InputTag("puJetIdResDown") process.puJetMvaResDown.jets = cms.InputTag( "smearedGoodPatJetsResDown") process.puJetIdEnUp.jets = cms.InputTag( "shiftedGoodPatJetsEnUpForCorrMEt") process.puJetMvaEnUp.jetids = cms.InputTag("puJetIdEnUp") process.puJetMvaEnUp.jets = cms.InputTag( "shiftedGoodPatJetsEnUpForCorrMEt") process.puJetIdEnDown.jets = cms.InputTag( "shiftedGoodPatJetsEnDownForCorrMEt") process.puJetMvaEnDown.jetids = cms.InputTag("puJetIdEnDown") process.puJetMvaEnDown.jets = cms.InputTag( "shiftedGoodPatJetsEnDownForCorrMEt") ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### MET # Apply type 0 MET corrections based on PFCandidate process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi") process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False) process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag( cms.InputTag('pfMETcorrType0'), cms.InputTag('pfJetMETcorr', 'type1')) # Get loose ID/Iso muons and veto ID electrons process.load("InvisibleHiggs.Ntuple.PhysicsObjectCandidates_cff") # Get PFMET from runMEtUncertainties from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi") if iRunOnData == True: runMEtUncertainties( process, electronCollection=cms.InputTag('selectVetoElectrons'), photonCollection='', muonCollection='selectLooseMuons', tauCollection='', jetCollection=cms.InputTag('goodPatJets'), jetCorrLabel='L2L3Residual', doSmearJets=False, makeType1corrPFMEt=True, makeType1p2corrPFMEt=False, makePFMEtByMVA=False, makeNoPileUpPFMEt=False, doApplyType0corr=True, sysShiftCorrParameter=process. pfMEtSysShiftCorrParameters_2012runAvsNvtx_data, doApplySysShiftCorr=False, addToPatDefaultSequence=False, ) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string( 'L2L3Residual') process.patPFJetMETtype2Corr.jetCorrLabel = cms.string('L2L3Residual') else: runMEtUncertainties( process, electronCollection=cms.InputTag('selectVetoElectrons'), photonCollection='', muonCollection='selectLooseMuons', tauCollection='', jetCollection=cms.InputTag('goodPatJets'), jetCorrLabel='L3Absolute', doSmearJets=True, makeType1corrPFMEt=True, makeType1p2corrPFMEt=False, makePFMEtByMVA=False, makeNoPileUpPFMEt=False, doApplyType0corr=True, sysShiftCorrParameter=process. pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc, doApplySysShiftCorr=False, addToPatDefaultSequence=False, ) # Fix Type0 correction module #process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209) #process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531) #process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151) #process.patPFMETtype0Corr.correction.par0 = cms.double(0.0) # Need this line for CMSSW_5_3_11 process.producePatPFMETCorrections.replace( process.patPFJetMETtype2Corr, process.patPFJetMETtype2Corr + process.type0PFMEtCorrectionPFCandToVertexAssociation + process.patPFMETtype0Corr) #process.producePatPFMETCorrections.replace(process.patPFJetMETtype2Corr,process.patPFJetMETtype2Corr + process.patPFMETtype0Corr) ###-------------------------------------------------------------- # PAT/ntuples one step # Z and W candidates process.load('InvisibleHiggs/Ntuple/WCandidates_cff') process.load('InvisibleHiggs/Ntuple/ZCandidates_cff') # Ntuple producer process.load('InvisibleHiggs/Ntuple/invHiggsInfo_cfi') if iRunOnData == False: # Jet/MET uncertainty process.invHiggsInfo.jetTag = cms.untracked.InputTag( "smearedGoodPatJets") process.invHiggsInfo.metTag = cms.untracked.InputTag( "patType1CorrectedPFMet") process.invHiggsInfo.puJetMvaTag = cms.untracked.InputTag( "puJetMvaSmeared", "full53xDiscriminant") process.invHiggsInfo.puJetIdTag = cms.untracked.InputTag( "puJetMvaSmeared", "full53xId") # PU re-weighting process.invHiggsInfo.puMCFile = cms.untracked.string("PUHistS10.root") process.invHiggsInfo.puDataFile = cms.untracked.string( "PUHistRun2012All_forParked.root") process.invHiggsInfo.puMCHist = cms.untracked.string("pileup") process.invHiggsInfo.puDataHist = cms.untracked.string("pileup") process.invHiggsInfo.mcPYTHIA = cms.untracked.bool(True) process.invHiggsInfo.trigCorrFile = cms.untracked.string( "DataMCWeight_53X_v1.root") # TTree output file process.load("CommonTools.UtilAlgos.TFileService_cfi") process.TFileService.fileName = cms.string('invHiggsInfo.root') ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Tau # removeSpecificPATObjects( process, ['Taus'] ) # process.patDefaultSequence.remove( process.patTaus ) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Trigger matching # from PhysicsTools.PatAlgos.tools.trigTools import * # process.metTriggerMatch = cms.EDProducer( # "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR # , src = cms.InputTag( 'patMETs' ) # , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py # , matchedCuts = cms.string( 'path( "HLT_MET100_v*" )' ) # , maxDPtRel = cms.double( 0.5 ) # , maxDeltaR = cms.double( 0.5 ) # , resolveAmbiguities = cms.bool( True ) # only one match per trigger object # , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above) # ) # process.jetTriggerMatch = cms.EDProducer( # "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR # , src = cms.InputTag( 'patJets' ) # , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py # , matchedCuts = cms.string( 'path( "HLT_Jet30_v*" )' ) # , maxDPtRel = cms.double( 0.5 ) # , maxDeltaR = cms.double( 0.5 ) # , resolveAmbiguities = cms.bool( True ) # only one match per trigger object # , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above) # ) # switchOnTriggerMatchEmbedding( process, [ 'metTriggerMatch', 'jetTriggerMatch' ] ) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Paths process.p0 = cms.Path(process.HBHENoiseFilter) process.p1 = cms.Path(process.CSCTightHaloFilter) process.p2 = cms.Path(process.hcalLaserEventFilter) process.p3 = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter) process.p4 = cms.Path(process.eeBadScFilter) process.p5 = cms.Path(process.ecalLaserCorrFilter) process.p6 = cms.Path(process.goodVertices * process.trackingFailureFilter) process.p7 = cms.Path(process.trkPOGFilters) if iRunOnData == True: #process.p8 = cms.Path( process.hcallLaserEvent2012Filter ) process.p8 = cms.Path(process.hcalfilter) else: process.p8 = cms.Path(process.primaryVertexFilter) if iRunOnData == True: process.p = cms.Path( # Trigger filter process.l1Filter * process.hltHighLevel * # Basic filters process.noscraping * process.primaryVertexFilter * # MET filters (Move to be flagged) # MET Correction process.type0PFMEtCorrection * # Tau process.recoTauClassicHPSSequence * # Generate PAT process.pfParticleSelectionSequence * process.patDefaultSequence * process.goodPatJets * process.PhysicsObjectSequence * process.metUncertaintySequence * process.puJetIdSqeuence * process.WSequence * process.ZSequence * process.invHiggsInfo) elif (iMCSignal == True): process.p = cms.Path( # Trigger filter #process.hltHighLevel * # Basic filters process.noscraping * process.primaryVertexFilter * # MET filters (Move to be flags) # MET Correction process.type0PFMEtCorrection * # Tau process.recoTauClassicHPSSequence * # Generate PAT process.pfParticleSelectionSequence * process.patDefaultSequence * process.goodPatJets * process.PhysicsObjectSequence * process.metUncertaintySequence * process.puJetIdSqeuence * process.puJetIdSmeared * process.puJetMvaSmeared * process.puJetIdResUp * process.puJetMvaResUp * process.puJetIdResDown * process.puJetMvaResDown * process.puJetIdEnUp * process.puJetMvaEnUp * process.puJetIdEnDown * process.puJetMvaEnDown * process.WSequence * process.ZSequence * process.invHiggsInfo) else: process.p = cms.Path( # Trigger filter #process.hltHighLevel * process.vbfFilter * # Basic filters process.noscraping * process.primaryVertexFilter * # MET filters (Move to be flags) # MET Correction process.type0PFMEtCorrection * # Tau process.recoTauClassicHPSSequence * # Generate PAT process.pfParticleSelectionSequence * process.patDefaultSequence * process.goodPatJets * process.PhysicsObjectSequence * process.metUncertaintySequence * process.puJetIdSqeuence * process.puJetIdSmeared * process.puJetMvaSmeared * process.puJetIdResUp * process.puJetMvaResUp * process.puJetIdResDown * process.puJetMvaResDown * process.puJetIdEnUp * process.puJetMvaEnUp * process.puJetIdEnDown * process.puJetMvaEnDown * process.WSequence * process.ZSequence * process.invHiggsInfo) ###-------------------------------------------------------------- ###-------------------------------------------------------------- ### Output process.out.outputCommands += [ # trigger results 'keep edmTriggerResults_*_*_*', 'keep *_hltTriggerSummaryAOD_*_*' # L1 , 'keep *_l1extraParticles_MET_RECO', 'keep *_l1extraParticles_MHT_RECO' # good jets , 'keep *_goodPatJets_*_*' # PU jet ID , 'keep *_puJetId*_*_*', 'keep *_puJetMva*_*_*' # vertices , 'keep *_offlineBeamSpot_*_*', 'keep *_offlinePrimaryVertices*_*_*', 'keep *_goodOfflinePrimaryVertices*_*_*', 'keep double_*_rho_*' ] if iRunOnData == False: process.out.outputCommands += [ 'keep GenEventInfoProduct_*_*_*', 'keep recoGenParticles_*_*_*', 'keep GenMETs_*_*_*', 'keep *_addPileupInfo_*_*', 'keep LHEEventProduct_*_*_*' ] process.out.fileName = 'patTuple.root' del (process.out) del (process.outpath)
# Get PFMET from runMEtUncertainties from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi") if isData: print "not doing runmetunc for data" else: runMEtUncertainties( process, electronCollection=cms.InputTag('cleanPatElectrons'), photonCollection='', muonCollection='cleanPatMuons', tauCollection='', jetCollection=cms.InputTag('selectedPatJets'), jetCorrLabel='L3Absolute', doSmearJets=True, makeType1corrPFMEt=True, makeType1p2corrPFMEt=False, makePFMEtByMVA=False, makeNoPileUpPFMEt=False, doApplyType0corr=True, #sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc, doApplySysShiftCorr=False, ) process.producePatPFMETCorrections.replace( process.patPFJetMETtype2Corr, process.patPFJetMETtype2Corr + process.type0PFMEtCorrectionPFCandToVertexAssociation + process.patPFMETtype0Corr) process.icJetsmearedcentralJets = cms.EDProducer( 'ICPatJetCandidateProducer', branchName=cms.untracked.string("jetsmearedcentralJets"),
process.patJetsWithOwnRef = cms.EDProducer("PatObjectOwnRefProducer<pat::Jet>", src=cms.InputTag("selectedPatJets") ) # type 1 +2 MET corrected process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") #Note: this module causes a large memory increase when crossing the file boundary #Reason - unknown, solution: limit processing to ~1 file. from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, electronCollection=cms.InputTag("selectedPatElectrons"), photonCollection=None, muonCollection=cms.InputTag("selectedPatMuons"), #FIXME: presently tau variations disabled, results in segfault tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("selectedPatJets"), jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual", doSmearJets=options.isMC, #Note: switch this to False for the sync! jetCorrPayloadName="AK5PFchs", addToPatDefaultSequence=False ) process.patPFMetNoPU = process.patMETs.clone( metSource = cms.InputTag("pfMETNoPU"), addMuonCorrections = cms.bool(False), genMETSource = cms.InputTag("genMetTrue") ) process.pfMETNoPU = process.pfMET.clone() process.pfMETNoPU.src=cms.InputTag("pfNoPileUp"+postfix) #rocess.pfMETNoPU.jets = cms.InputTag("pfJets"+postfix)
def filterTightWenuCandidates(process, isMC): process.tightWenuSelectionSequence = cms.Sequence() # Trigger requirements process.load("HLTrigger.HLTfilters.hltHighLevel_cfi") process.wenuHLTFilter = process.hltHighLevel.clone( TriggerResultsTag = cms.InputTag("TriggerResults", "", "HLT"), HLTPaths = cms.vstring([ # single electron triggers (2011 Run B) 'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v7', 'HLT_Ele25_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v5', # single electron triggers (Summer'11 MC) 'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v1', 'HLT_Ele27_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v2', ]), throw = cms.bool(False) ) process.tightWenuSelectionSequence += process.wenuHLTFilter # Vertex selection process.goodVertex = cms.EDFilter("VertexSelector", src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string("isValid & ndof >= 4 & abs(z) < 24 & abs(position.Rho) < 2"), filter = cms.bool(True) ) process.tightWenuSelectionSequence += process.goodVertex process.load("CommonTools.ParticleFlow.pfNoPileUp_cff") process.pfPileUp.Enable = cms.bool(True) process.pfPileUp.checkClosestZVertex = cms.bool(True) process.tightWenuSelectionSequence += process.pfNoPileUpSequence process.load("CommonTools.ParticleFlow.pfParticleSelection_cff") process.tightWenuSelectionSequence += process.pfParticleSelectionSequence process.load("PhysicsTools/PatAlgos/patSequences_cff") # compute electron IsoDeposits process.load("TauAnalysis.Skimming.electronPFIsolationDeposits_cff") process.load("TauAnalysis.Skimming.electronPFIsolationValues_cff") process.electronPFIsolationSequence = cms.Sequence( process.electronPFIsolationDepositsSequence * process.electronPFIsolationValuesSequence ) process.tightWenuSelectionSequence += process.electronPFIsolationSequence # configure pat::Electron production process.patElectrons.isoDeposits = cms.PSet( # CV: strings for IsoDeposits defined in PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc pfChargedHadrons = cms.InputTag("elecPFIsoDepositCharged"), pfNeutralHadrons = cms.InputTag("elecPFIsoDepositNeutral"), pfPhotons = cms.InputTag("elecPFIsoDepositGamma"), user = cms.VInputTag( cms.InputTag("elecPFIsoDepositChargedAll"), cms.InputTag("elecPFIsoDepositPU") ) ) process.patElectrons.userIsolation = cms.PSet( # CV: strings for Isolation values defined in PhysicsTools/PatAlgos/src/MultiIsolator.cc pfChargedHadron = cms.PSet( deltaR = cms.double(0.4), src = process.patElectrons.isoDeposits.pfChargedHadrons, vetos = process.elecPFIsoValueCharged04.deposits[0].vetos, skipDefaultVeto = process.elecPFIsoValueCharged04.deposits[0].skipDefaultVeto ), pfNeutralHadron = cms.PSet( deltaR = cms.double(0.4), src = process.patElectrons.isoDeposits.pfNeutralHadrons, vetos = process.elecPFIsoValueNeutral04.deposits[0].vetos, skipDefaultVeto = process.elecPFIsoValueNeutral04.deposits[0].skipDefaultVeto ), pfGamma = cms.PSet( deltaR = cms.double(0.4), src = process.patElectrons.isoDeposits.pfPhotons, vetos = process.elecEBPFIsoValueGamma04.deposits[0].vetos, skipDefaultVeto = process.elecEBPFIsoValueGamma04.deposits[0].skipDefaultVeto ), user = cms.VPSet( cms.PSet( deltaR = cms.double(0.4), src = process.patElectrons.isoDeposits.user[0], vetos = process.elecEBPFIsoValueChargedAll04.deposits[0].vetos, skipDefaultVeto = process.elecEBPFIsoValueChargedAll04.deposits[0].skipDefaultVeto ), cms.PSet( deltaR = cms.double(0.4), src = process.patElectrons.isoDeposits.user[1], vetos = process.elecPFIsoValuePU04.deposits[0].vetos, skipDefaultVeto = process.elecPFIsoValuePU04.deposits[0].skipDefaultVeto ), cms.PSet( deltaR = cms.double(0.4), src = process.patElectrons.isoDeposits.pfPhotons, vetos = process.elecEEPFIsoValueGamma04.deposits[0].vetos, skipDefaultVeto = process.elecEEPFIsoValueGamma04.deposits[0].skipDefaultVeto ), cms.PSet( deltaR = cms.double(0.4), src = process.patElectrons.isoDeposits.user[0], vetos = process.elecEEPFIsoValueChargedAll04.deposits[0].vetos, skipDefaultVeto = process.elecEEPFIsoValueChargedAll04.deposits[0].skipDefaultVeto ) ) ) process.patElectrons.addGenMatch = cms.bool(False) process.patElectrons.embedHighLevelSelection = cms.bool(True) process.patElectrons.usePV = cms.bool(False) # compute transverse impact parameter wrt. beamspot (not event vertex) if not isMC: # remove MC matching from standard PAT sequences removeMCMatching(process, ["All"], outputInProcess = False) process.patDefaultSequence.remove(process.patJetPartonMatch) # select tight electrons, no isolation cuts applied process.selectedElectronsWP80 = cms.EDFilter("PATElectronSelector", src = cms.InputTag("patElectrons"), cut = cms.string( 'pt > 25 & abs(eta) < 2.1 & ' + \ '(isEB & ' + \ ' sigmaIetaIeta < 0.010 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.06 & deltaEtaSuperClusterTrackAtVtx < 0.004 & ' + \ ' hadronicOverEm < 0.04) | ' + \ '(isEE & ' + \ ' sigmaIetaIeta < 0.030 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.03 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \ ' hadronicOverEm < 0.025)' ), filter = cms.bool(True) ) process.selectedElectronsWP80conversionVeto = cms.EDFilter("NPATElectronConversionFinder", src = cms.InputTag("selectedElectronsWP80"), filter = cms.bool(True) ) # select loose electrons, used for di-electron veto process.selectedElectronsWP95 = cms.EDFilter("PATElectronSelector", src = cms.InputTag("patElectrons"), cut = cms.string( 'pt > 20 & abs(eta) < 2.5 & ' + \ 'gsfTrack.isNonnull & gsfTrack.trackerExpectedHitsInner.numberOfHits <= 1 &' + \ '(isEB & ' + \ ' sigmaIetaIeta < 0.010 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.80 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \ ' hadronicOverEm < 0.15) | ' + \ '(isEE & ' + \ ' sigmaIetaIeta < 0.030 & ' + \ ' deltaPhiSuperClusterTrackAtVtx < 0.70 & deltaEtaSuperClusterTrackAtVtx < 0.010 & ' + \ ' hadronicOverEm < 0.07)' ), filter = cms.bool(False) ) # select tight electrons which are isolated process.selectedIsoElectronsWP80 = cms.EDFilter("PATElectronSelector", src = cms.InputTag("selectedElectronsWP80conversionVeto"), cut = cms.string( '(isEB & ' + \ '(userIsolation("pat::User1Iso")' + \ ' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::PfGammaIso")' + \ ' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt) | ' + \ '(isEE & ' + \ '(userIsolation("pat::User4Iso")' + \ ' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::User3Iso")' + \ ' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt)' ), filter = cms.bool(False) ) process.patDefaultSequence.replace( process.patElectrons, process.patElectrons * process.selectedElectronsWP80 * process.selectedElectronsWP80conversionVeto * process.selectedIsoElectronsWP80 * process.selectedElectronsWP95) # configure pat::Jet production # (enable L2L3Residual corrections in case running on Data) jetCorrections = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ] if not isMC: jetCorrections.append('L2L3Residual') switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA = True, doBTagging = False, jetCorrLabel = ( 'AK5PF', cms.vstring(jetCorrections) ), doType1MET = False, doJetID = True, jetIdLabel = "ak5", outputModule = '' ) # configure pat::MET production process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") process.tightWenuSelectionSequence += process.kt6PFJets process.tightWenuSelectionSequence += process.ak5PFJets process.tightWenuSelectionSequence += process.patDefaultSequence doSmearJets = None if isMC: doSmearJets = True else: doSmearJets = False runMEtUncertainties( process, electronCollection = cms.InputTag('selectedIsoElectronsWP80'), photonCollection = '', muonCollection = '', tauCollection = '', jetCollection = cms.InputTag('patJets'), doSmearJets = doSmearJets, addToPatDefaultSequence = False ) if isMC: process.patPFMet.addGenMET = cms.bool(True) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute") process.tightWenuSelectionSequence += process.metUncertaintySequence else: process.patPFMet.addGenMET = cms.bool(False) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L2L3Residual") process.tightWenuSelectionSequence += process.patJetsNotOverlappingWithLeptonsForMEtUncertainty process.tightWenuSelectionSequence += process.producePatPFMETCorrections # Apply event selection cuts process.isoElectronWP80Filter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("selectedIsoElectronsWP80"), minNumber = cms.uint32(1) ) process.tightWenuSelectionSequence += process.isoElectronWP80Filter process.diElectronVeto = cms.EDFilter("PATCandViewMaxFilter", src = cms.InputTag("selectedElectronsWP95"), maxNumber = cms.uint32(1) ) process.tightWenuSelectionSequence += process.diElectronVeto process.WenuCandidates = cms.EDProducer("PATElecNuPairProducer", srcVisDecayProducts = cms.InputTag('selectedIsoElectronsWP80'), srcMET = cms.InputTag('patType1CorrectedPFMet'), verbosity = cms.untracked.int32(0) ) process.tightWenuSelectionSequence += process.WenuCandidates process.selectedWenuCandidates = cms.EDFilter("PATElecNuPairSelector", src = cms.InputTag("WenuCandidates"), cut = cms.string('mt > 50.'), filter = cms.bool(False) ) process.tightWenuSelectionSequence += process.selectedWenuCandidates process.tightWenuFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("selectedWenuCandidates"), minNumber = cms.uint32(1) ) process.tightWenuSelectionSequence += process.tightWenuFilter
################# ## The MET Uncertainty tool needs some more things to be there: process.load("Configuration.StandardSequences.Geometry_cff") process.load( "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") from Configuration.AlCa.autoCond import autoCond process.GlobalTag.globaltag = cms.string(autoCond['startup']) process.load("Configuration.StandardSequences.MagneticField_cff") process.load("PhysicsTools.PatAlgos.patSequences_cff") #Applying the MET Uncertainty tools from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, electronCollection=cms.InputTag("selectedPatElectronsPFlow"), jetCollection="selectedPatJetsPFlow", muonCollection=cms.InputTag("selectedPatMuonsPFlow"), tauCollection=cms.InputTag("selectedPatTausPFlow")) #process.shiftedPatJetsEnUp=process.shiftedPatJetsPFlowEnUpForCorrMEt.clone(shiftBy=cms.double(2), src="selectedPatJetsPFlow") #process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJetsEnUp")) #process.p_jec.__iadd__( process.shiftedPatJetsEnUp * process.jecAnalyzerEnUp) ################# # # # EXERCISE 4 # # # ################# process.patJPsiCandidates = cms.EDProducer( "PatJPsiProducer", muonSrc=cms.InputTag("selectedPatMuonsPFlow"))
def SingleTopStep1( process, ): options = VarParsing('analysis') options.register ('isMC', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Run on MC" ) options.register ('doDebug', False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Run in debugging mode" ) options.register ('doSkimming', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Preselect events" ) options.register ('doSlimming', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Drop unnecessary collections" ) options.register ('doMuon', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Do muon paths" ) options.register ('doElectron', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Do electron paths" ) #Tag from https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideFrontierConditions?redirectedfrom=CMS.SWGuideFrontierConditions#2012_MC_production # Latest for "53Y Releases (MC)" options.register ('globalTag', Config.globalTagMC, VarParsing.multiplicity.singleton, VarParsing.varType.string, "Global tag" ) options.parseArguments() process.source.fileNames = cms.untracked.vstring(options.inputFiles) process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(options.maxEvents) ) process.out.fileName = cms.untracked.string(options.outputFile) process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(options.doDebug)) if options.doDebug: process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger = cms.Service("MessageLogger", destinations=cms.untracked.vstring('cout', 'debug'), debugModules=cms.untracked.vstring('*'), cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')), debug=cms.untracked.PSet(threshold=cms.untracked.string('DEBUG')), ) else: process.load("FWCore.MessageService.MessageLogger_cfi") postfix = "" jetCorr = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not options.isMC: jetCorr += ['L2L3Residual'] usePF2PAT(process, runPF2PAT=True, jetAlgo='AK5', runOnMC=options.isMC, postfix=postfix, jetCorrections=('AK5PFchs', jetCorr), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), #typeIMetCorrections = True typeIMetCorrections = False #Type1 MET now applied later using runMETUncertainties ) # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012 process.pfPileUp.Enable = True process.pfPileUp.checkClosestZVertex = False #------------------------------------------------- # selection step 2: vertex filter #------------------------------------------------- # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012 # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter" , filterParams = cms.PSet( minNdof = cms.double(4.0) , maxZ = cms.double(24.0) , maxRho = cms.double(2.0) ) , filter = cms.bool(True) , src = cms.InputTag('offlinePrimaryVertices') ) #------------------------------------------------- # Muons #------------------------------------------------- #if not maxLeptonIso is None: # process.pfIsolatedMuons.isolationCut = maxLeptonIso #Use both isolated and non-isolated muons as a patMuon source #process.patMuons.pfMuonSource = cms.InputTag("pfMuons") #process.muonMatch.src = cms.InputTag("pfMuons") process.patMuons.pfMuonSource = cms.InputTag("pfIsolatedMuons") process.muonMatch.src = cms.InputTag("pfIsolatedMuons") process.selectedPatMuons.cut = "pt>20 && abs(eta)<3.0" # muon ID production (essentially track count embedding) must be here # because tracks get dropped from the collection after this step, resulting # in null ptrs. process.muonsWithID = cms.EDProducer( 'MuonIDProducer', muonSrc = cms.InputTag("selectedPatMuons"), primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices") ) #process.muonClones = cms.EDProducer("MuonShallowCloneProducer", # src = cms.InputTag("selectedPatMuons") #) #------------------------------------------------- # Electrons # Implemented as in https://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=208765 #------------------------------------------------- #if not maxLeptonIso is None: # process.pfIsolatedElectrons.isolationCut = maxLeptonIso #Use both isolated and un-isolated electrons as patElectrons. #NB: no need to change process.electronMatch.src to pfElectrons, # it's already gsfElectrons, which is a superset of the pfElectrons process.patElectrons.pfElectronSource = cms.InputTag("pfElectrons") process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi') process.mvaID = cms.Sequence(process.mvaTrigV0 + process.mvaNonTrigV0) process.patElectrons.electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0") process.patElectrons.electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0") process.patPF2PATSequence.replace(process.patElectrons, process.mvaID * process.patElectrons) process.selectedPatElectrons.cut = "pt>25 && abs(eta)<3.0" process.electronsWithID = cms.EDProducer( 'ElectronIDProducer', electronSrc = cms.InputTag("selectedPatElectrons"), primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices") ) #process.electronClones = cms.EDProducer("ElectronShallowCloneProducer", # src = cms.InputTag("selectedPatElectrons") #) #if not maxLeptonIso is None: # process.pfIsolatedElectrons.isolationCut = maxLeptonIso #electron dR=0.3 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.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId") process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) process.patElectrons.isolationValues.pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03PFId") process.patElectrons.isolationValues.pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03PFId") process.patElectrons.isolationValues.pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03PFId") process.patElectrons.isolationValues.pfPhotons = cms.InputTag("elPFIsoValueGamma03PFId") process.patElectrons.isolationValues.pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03PFId") 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")) #------------------------------------------------- # Jets # MET corrections as https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_0_with_PAT #------------------------------------------------- #pfNoTau == True => remove taus from jets #process.pfNoTau.enable = noTau process.selectedPatJets.cut = cms.string("pt>30 && abs(eta)<5.0") process.load("CMGTools.External.pujetidsequence_cff") process.patPF2PATSequence += process.puJetIdSqeuence #process.jetClones = cms.EDProducer("CaloJetShallowCloneProducer", # src = cms.InputTag("seletedPatJets") #) #------------------------------------------------- # MET uncertainty step #------------------------------------------------- #Embed the reference to the original jet in the jets, which is constant during the propagation process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>', src=cms.InputTag("selectedPatJets") ) #Note: this module causes a large memory increase when crossing the file boundary #Reason - unknown, solution: limit processing to ~1 file. from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, electronCollection=cms.InputTag("electronsWithID"), photonCollection=None, muonCollection=cms.InputTag("muonsWithID"), tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("patJetsWithOwnRef"), jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual", doSmearJets=options.isMC, jetCorrPayloadName="AK5PFchs", addToPatDefaultSequence=False ) process.stpolMetUncertaintySequence = cms.Sequence( process.metUncertaintySequence ) if not options.doSlimming: process.out.outputCommands = cms.untracked.vstring('keep *') else: process.out.outputCommands = cms.untracked.vstring([ 'drop *', 'keep edmMergeableCounter_*_*_*', # Keep the lumi-block counter information 'keep edmTriggerResults_TriggerResults__*', #Keep the trigger results 'keep *_genParticles__*', #keep all the genParticles #'keep recoVertexs_offlinePrimaryVertices__*', #keep the offline PV-s 'keep recoVertexs_goodOfflinePrimaryVertices__*', #keep the offline PV-s # Jets 'keep patJets_*__*', 'keep double_*_rho_*', #For rho-corr rel iso 'keep recoGenJets_selectedPatJets_genJets_*', #For Jet MC smearing we need to keep the genJets "keep *_puJetId_*_*", # input variables "keep *_puJetMva_*_*", # final MVAs and working point flags 'keep *_jetClones__*', # Muons 'keep patMuons_*__*', 'keep *_muonClones__*', # Electrons 'keep patElectrons_*__*', 'keep *_electronClones__*', # METs 'keep patMETs_*__*', #ECAL laser corr filter 'keep bool_ecalLaserCorrFilter__*', #For flavour analyzer 'keep GenEventInfoProduct_generator__*', #PU info 'keep PileupSummaryInfos_addPileupInfo__*', ##PFCandidates #'keep recoPFCandidates_*_pfCandidates_PAT', #'keep recoPFMETs_pfMET__*', #'keep recoPFMETs_pfMet__*', #'keep recoGenMETs_genMetTrue__*', #'keep recoPFCandidates_particleFlow__*', #'keep recoConversions_allConversions__*', #'keep recoVertexCompositeCandidates_generalV0Candidates_*_*', #'keep recoTracks_generalTracks__*', #'keep recoBeamSpot_offlineBeamSpot__*', #'keep recoMuons_muons__*', 'keep int_*__PAT', 'keep ints_*__PAT', 'keep double_*__PAT', 'keep doubles_*__PAT', 'keep float_*__PAT', 'keep floats_*__PAT', ]) #FIXME: is this correct? #Keep events that pass either the muon OR the electron path process.out.SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring( [] ) ) #------------------------------------------------- # Paths #------------------------------------------------- process.goodOfflinePVCount = cms.EDProducer( "CollectionSizeProducer<reco::Vertex>", src = cms.InputTag("goodOfflinePrimaryVertices") ) process.preCalcSequences = cms.Sequence( process.patJetsWithOwnRef * process.goodOfflinePVCount ) process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatMuons) + 1, process.muonsWithID) process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatElectrons) + 1, process.electronsWithID) #Need separate paths because of skimming if options.doMuon: process.singleTopPathStep1Mu = cms.Path( process.goodOfflinePrimaryVertices * process.patPF2PATSequence #* process.muonClones #* process.electronClones #* process.jetClones ) if options.doElectron: process.singleTopPathStep1Ele = cms.Path( process.goodOfflinePrimaryVertices * process.patPF2PATSequence #* process.muonClones #* process.electronClones #* process.jetClones ) if options.doMuon: process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Mu") if options.doElectron: process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Ele") process.GlobalTag.globaltag = cms.string(options.globalTag) process.singleTopPathStep1Mu += process.preCalcSequences process.singleTopPathStep1Ele += process.preCalcSequences if options.doMuon: process.singleTopPathStep1Mu += process.stpolMetUncertaintySequence if options.doElectron: process.singleTopPathStep1Ele += process.stpolMetUncertaintySequence if options.isMC: #https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC process.GlobalTag.toGet = cms.VPSet( cms.PSet(record = cms.string("BTagTrackProbability2DRcd"), tag = cms.string("TrackProbabilityCalibration_2D_MC53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")), cms.PSet(record = cms.string("BTagTrackProbability3DRcd"), tag = cms.string("TrackProbabilityCalibration_3D_MC53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")) ) else: #https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC process.GlobalTag.toGet = cms.VPSet( cms.PSet(record = cms.string("BTagTrackProbability2DRcd"), tag = cms.string("TrackProbabilityCalibration_2D_Data53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")), cms.PSet(record = cms.string("BTagTrackProbability3DRcd"), tag = cms.string("TrackProbabilityCalibration_3D_Data53X_v2"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")) ) process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi') process.ecalLaserCorrFilter.taggingMode=True # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters process.scrapingFilter = cms.EDFilter("FilterOutScraping" , applyfilter = cms.untracked.bool(True) , debugOn = cms.untracked.bool(False) , numtrack = cms.untracked.uint32(10) , thresh = cms.untracked.double(0.25) ) #if doElectron: # process.singleTopPathStep1Ele.insert(0, process.scrapingFilter) #if doMuon: # process.singleTopPathStep1Mu.insert(0, process.scrapingFilter) process.patPF2PATSequence += process.scrapingFilter process.patPF2PATSequence += process.ecalLaserCorrFilter #if not onGrid: # from SingleTopPolarization.Analysis.cmdlineParsing import enableCommandLineArguments # enableCommandLineArguments(process) #else: # process.out.fileName = "step1.root" if options.doSkimming: process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_Skim.root")) else: process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSkim.root")) #----------------------------------------------- # Skimming #----------------------------------------------- #Throw away events before particle flow? if options.doSkimming: from SingleTopPolarization.Analysis.eventSkimming_cfg import skimFilters skimFilters(process) if options.doMuon: process.singleTopPathStep1Mu.insert(0, process.muonSkim) if options.doElectron: process.singleTopPathStep1Ele.insert(0, process.electronSkim) #----------------------------------------------- # Skim efficiency counters #----------------------------------------------- #count all processed events countProcessed(process) #count events passing mu and ele paths if options.doMuon: countInSequence(process, process.singleTopPathStep1Mu) if options.doElectron: countInSequence(process, process.singleTopPathStep1Ele) #------------------------------------------------- # #------------------------------------------------- if not options.doSlimming: process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSlim.root")) return process
def configurePatTupleProduction(process, patSequenceBuilder=buildGenericTauSequence, patPFTauCleanerPrototype=None, patCaloTauCleanerPrototype=None, addSVfitInfo=False, hltProcess="HLT", isMC=False, applyTauVertexMatch=True): # check that patSequenceBuilder and patTauCleanerPrototype are defined and non-null if patSequenceBuilder is None: raise ValueError("Undefined 'patSequenceBuilder' Parameter !!") if patPFTauCleanerPrototype is None or patCaloTauCleanerPrototype is None: raise ValueError("Undefined 'patTauCleanerPrototype' Parameter !!") #-------------------------------------------------------------------------------- # produce PAT objects #-------------------------------------------------------------------------------- process.load("PhysicsTools.PatAlgos.patSequences_cff") process.load("PhysicsTools.PatAlgos.producersLayer1.tauProducer_cff") process.load("PhysicsTools.PatAlgos.producersLayer1.muonProducer_cff") process.load("PhysicsTools.PatAlgos.producersLayer1.metProducer_cff") process.load("TauAnalysis.CandidateTools.muTauPairProduction_cff") # per default, do **not** run SVfit algorithm if not addSVfitInfo: process.allMuTauPairs.doSVreco = cms.bool(False) process.allMuTauPairs.doPFMEtSign = cms.bool(False) process.allMuTauPairsLooseMuonIsolation.doSVreco = cms.bool(False) process.allMuTauPairsLooseMuonIsolation.doPFMEtSign = cms.bool(False) if not isMC: removeMCMatching(process, ["All"], outputModules=[]) else: # match pat::Taus to all genJets # (including to genJets build from electrons/muons produced in tau --> e/mu decays) process.tauGenJetMatch.matched = cms.InputTag("tauGenJets") #-------------------------------------------------------------------------------- # configure PAT trigger matching switchOnTrigger(process, hltProcess=hltProcess, outputModule='') # CV: disable L1Algos in MC for now, to prevent error messages # # %MSG-e L1GlobalTriggerObjectMapRecord: PATTriggerProducer:patTrigger # # ERROR: The requested algorithm name = L1_DoubleEG1 # does not exists in the trigger menu. # Returning zero pointer for getObjectMap # # to be printed for every event (06/05/2011) # # for Data the L1Algos flag needs to be enabled, # in order for the prescale computation/correction for Data # implemented in TauAnalysis/TauIdEfficiency/bin/FWLiteTauIdEffAnalyzer.cc to work if isMC: process.patTrigger.addL1Algos = cms.bool(False) else: process.patTrigger.addL1Algos = cms.bool(True) process.patTauTriggerMatchHLTprotoType = cms.EDProducer( "PATTriggerMatcherDRLessByR", src=cms.InputTag("cleanLayer1Taus"), matched=cms.InputTag("patTrigger"), matchedCuts=cms.string('path("HLT_Jet30_v*")'), maxDPtRel=cms.double(1.e+3), maxDeltaR=cms.double(0.5), resolveAmbiguities=cms.bool(True), resolveByMatchQuality=cms.bool(True)) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # compute Pt sum of charged + neutral hadrons and photons within isolation cones of size dR = 0.4/0.6 process.load("RecoMuon/MuonIsolation/muonPFIsolation_cff") patutils.massSearchReplaceAnyInputTag( process.muonPFIsolationDepositsSequence, cms.InputTag('muons1stStep'), cms.InputTag('muons')) process.patMuons.isoDeposits = cms.PSet( # CV: strings for IsoDeposits defined in PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc pfChargedHadrons=cms.InputTag("muPFIsoDepositCharged"), pfNeutralHadrons=cms.InputTag("muPFIsoDepositNeutral"), pfPhotons=cms.InputTag("muPFIsoDepositGamma"), user=cms.VInputTag(cms.InputTag("muPFIsoDepositChargedAll"), cms.InputTag("muPFIsoDepositPU"))) process.patMuons.userIsolation = cms.PSet( # CV: strings for Isolation values defined in PhysicsTools/PatAlgos/src/MultiIsolator.cc pfChargedHadron=cms.PSet( deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.pfChargedHadrons, vetos=process.muPFIsoValueCharged04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueCharged04.deposits[0]. skipDefaultVeto), pfNeutralHadron=cms.PSet( deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.pfNeutralHadrons, vetos=process.muPFIsoValueNeutral04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueNeutral04.deposits[0]. skipDefaultVeto), pfGamma=cms.PSet(deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.pfPhotons, vetos=process.muPFIsoValueGamma04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueGamma04. deposits[0].skipDefaultVeto), user=cms.VPSet( cms.PSet(deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.user[0], vetos=process.muPFIsoValueChargedAll04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueChargedAll04. deposits[0].skipDefaultVeto), cms.PSet(deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.user[1], vetos=process.muPFIsoValuePU04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValuePU04.deposits[0]. skipDefaultVeto))) process.patMuonsWithinAcc = cms.EDFilter( "PATMuonSelector", src=cms.InputTag('patMuons'), cut=cms.string("pt > 15. & abs(eta) < 2.1"), filter=cms.bool(False)) process.selectedPatMuonsVBTFid = cms.EDFilter( "PATMuonIdSelector", src=cms.InputTag('patMuonsWithinAcc'), vertexSource=cms.InputTag('selectedPrimaryVertexPosition'), beamSpotSource=cms.InputTag('offlineBeamSpot'), filter=cms.bool(False)) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collections of pat::Jets for CaloJets and PFJets # # NOTE: needed for evaluating jetId for Calo/TCTaus and PFTaus # jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not isMC: jec.extend(['L2L3Residual']) addJetCollection(process, cms.InputTag('ak5PFJets'), 'AK5', 'PF', doJTA=False, doBTagging=False, jetCorrLabel=('AK5PF', cms.vstring(jec)), doType1MET=False, genJetCollection=cms.InputTag("ak5GenJets"), doJetID=True, jetIdLabel="ak5", outputModules=[]) addJetCollection(process, cms.InputTag('ak5CaloJets'), 'AK5', 'Calo', doJTA=False, doBTagging=False, jetCorrLabel=('AK5Calo', cms.vstring(jec)), doType1MET=False, genJetCollection=cms.InputTag("ak5GenJets"), doJetID=True, jetIdLabel="ak5", outputModules=[]) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # configure Jet Energy Corrections # process.load("TauAnalysis.Configuration.jetCorrectionParameters_cfi") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # add pfMET process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") if isMC: import PhysicsTools.PatAlgos.tools.helpers as configtools configtools.cloneProcessingSnippet(process, process.producePatPFMETCorrections, "NoSmearing") process.selectedPatJetsForMETtype1p2CorrNoSmearing.src = cms.InputTag( 'patJetsNotOverlappingWithLeptonsForMEtUncertainty') process.selectedPatJetsForMETtype2CorrNoSmearing.src = process.selectedPatJetsForMETtype1p2CorrNoSmearing.src process.patMEtProductionSequence = cms.Sequence() process.patMEtProductionSequence += process.patDefaultSequence from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties doSmearJets = None if isMC: doSmearJets = True else: doSmearJets = False runMEtUncertainties( process, electronCollection='', photonCollection='', muonCollection=cms.InputTag('selectedPatMuonsVBTFid'), tauCollection='', jetCollection=cms.InputTag('patJetsAK5PF'), doSmearJets=doSmearJets, doApplyType0corr=True, sysShiftCorrParameter=None, doApplySysShiftCorr=False, # CV: shift Jet energy by 3 standard-deviations, # so that template morphing remains an interpolation and no extrapolation is needed varyByNsigmas=3.0, addToPatDefaultSequence=False) if isMC: process.patPFMet.addGenMET = cms.bool(True) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute") process.patMEtProductionSequence += process.metUncertaintySequence else: process.patPFMet.addGenMET = cms.bool(False) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string( "L2L3Residual") process.patMEtProductionSequence += process.patJetsAK5PFnotOverlappingWithLeptonsForMEtUncertainty process.patMEtProductionSequence += process.producePatPFMETCorrections #-------------------------------------------------------------------------------- pfJetCollection = 'patJetsAK5PFnotOverlappingWithLeptonsForMEtUncertainty' pfMEtCollection = 'patType1CorrectedPFMet' if isMC: pfJetCollection = 'smearedPatJetsAK5PF' #-------------------------------------------------------------------------------- # # produce combinations of muon + tau-jet pairs # for collection of pat::Tau objects representing CaloTaus # switchToCaloTau(process) process.patCaloTauProducer = copy.deepcopy(process.patTaus) retVal_caloTau = patSequenceBuilder( process, collectionName=["patCaloTaus", ""], jetCollectionName="patJetsAK5Calo", patTauProducerPrototype=process.patCaloTauProducer, patTauCleanerPrototype=patCaloTauCleanerPrototype, triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType, addGenInfo=isMC, applyTauJEC=False, applyTauVertexMatch=applyTauVertexMatch) process.caloTauSequence = retVal_caloTau["sequence"] process.patMuonCaloTauPairs = process.allMuTauPairs.clone( srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'), srcLeg2=cms.InputTag(retVal_caloTau["collection"]), srcMET=cms.InputTag('patMETs'), srcGenParticles=cms.InputTag(''), doSVreco=cms.bool(False), doPFMEtSign=cms.bool(False)) if hasattr(process.patMuonCaloTauPairs, "nSVfit"): delattr(process.patMuonCaloTauPairs, "nSVfit") if hasattr(process.patMuonCaloTauPairs, "pfMEtSign"): delattr(process.patMuonCaloTauPairs, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by fixed signal cone algorithm # (plus combinations of muon + tau-jet pairs) # #switchToPFTauFixedCone(process) #process.patPFTauProducerFixedCone = copy.deepcopy(process.patTaus) # #retVal_pfTauFixedCone = patSequenceBuilder( # process, # collectionName = [ "patPFTaus", "FixedCone" ], # jetCollectionName = pfJetCollection, # patTauProducerPrototype = process.patPFTauProducerFixedCone, # patTauCleanerPrototype = patPFTauCleanerPrototype, # triggerMatcherProtoType = process.patTauTriggerMatchHLTprotoType, # addGenInfo = isMC, # applyTauJEC = False, # applyTauVertexMatch = applyTauVertexMatch #) #process.pfTauSequenceFixedCone = retVal_pfTauFixedCone["sequence"] # #process.patMuonPFTauPairsFixedCone = process.allMuTauPairs.clone( # srcLeg1 = cms.InputTag('selectedPatMuonsVBTFid'), # srcLeg2 = cms.InputTag(retVal_pfTauFixedCone["collection"]), # srcMET = cms.InputTag(pfMEtCollection), # srcGenParticles = cms.InputTag(''), # doSVreco = cms.bool(False) #) #if hasattr(process.patMuonPFTauPairsFixedCone, "nSVfit"): # delattr(process.patMuonPFTauPairsFixedCone, "nSVfit") #if hasattr(process.patMuonPFTauPairsFixedCone, "pfMEtSign"): # delattr(process.patMuonPFTauPairsFixedCone, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by shrinking signal cone algorithm # (plus combinations of muon + tau-jet pairs) # #switchToPFTauShrinkingCone(process) #process.patPFTauProducerShrinkingCone = copy.deepcopy(process.patTaus) # #retVal_pfTauShrinkingCone = patSequenceBuilder( # process, # collectionName = [ "patPFTaus", "ShrinkingCone" ], # jetCollectionName = pfJetCollection, # patTauProducerPrototype = process.patPFTauProducerShrinkingCone, # patTauCleanerPrototype = patPFTauCleanerPrototype, # triggerMatcherProtoType = process.patTauTriggerMatchHLTprotoType, # addGenInfo = isMC, # applyTauJEC = False, # applyTauVertexMatch = applyTauVertexMatch #) #process.pfTauSequenceShrinkingCone = retVal_pfTauShrinkingCone["sequence"] # #process.patMuonPFTauPairsShrinkingCone = process.allMuTauPairs.clone( # srcLeg1 = cms.InputTag('selectedPatMuonsVBTFid'), # srcLeg2 = cms.InputTag(retVal_pfTauShrinkingCone["collection"]), # srcMET = cms.InputTag(pfMEtCollection), # srcGenParticles = cms.InputTag(''), # doSVreco = cms.bool(False) #) #if hasattr(process.patMuonPFTauPairsShrinkingCone, "nSVfit"): # delattr(process.patMuonPFTauPairsShrinkingCone, "nSVfit") #if hasattr(process.patMuonPFTauPairsShrinkingCone, "pfMEtSign"): # delattr(process.patMuonPFTauPairsShrinkingCone, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by hadron + strips (HPS) algorithm # (plus combinations of muon + tau-jet pairs) # # NOTE: switchToPFTauHPS function overwrites process.cleanPatTaus.preselection using HPS specific discriminators; # undo overwriting, in order to prevent run-time errors in case of subsequence _switchToPFTau call, # arising from the fact that HPS specific discriminators are not available for all tau types # switchToPFTauHPS(process) process.cleanPatTaus.preselection = cms.string('') process.patPFTauProducerHPS = copy.deepcopy(process.patTaus) retVal_pfTauHPS = patSequenceBuilder( process, collectionName=["patPFTaus", "HPS"], jetCollectionName=pfJetCollection, patTauProducerPrototype=process.patPFTauProducerHPS, patTauCleanerPrototype=patPFTauCleanerPrototype, triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType, addGenInfo=isMC, applyTauJEC=True, applyTauVertexMatch=applyTauVertexMatch) process.pfTauSequenceHPS = retVal_pfTauHPS["sequence"] process.patMuonPFTauPairsHPS = process.allMuTauPairs.clone( srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'), srcLeg2=cms.InputTag(retVal_pfTauHPS["collection"]), srcMET=cms.InputTag(pfMEtCollection), srcGenParticles=cms.InputTag(''), doSVreco=cms.bool(False)) if hasattr(process.patMuonPFTauPairsHPS, "nSVfit"): delattr(process.patMuonPFTauPairsHPS, "nSVfit") if hasattr(process.patMuonPFTauPairsHPS, "pfMEtSign"): delattr(process.patMuonPFTauPairsHPS, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by HPS + TaNC combined tau id. algorithm # (plus combinations of muon + tau-jet pairs) # switchToPFTauHPSpTaNC(process) process.cleanPatTaus.preselection = cms.string('') process.patPFTauProducerHPSpTaNC = copy.deepcopy(process.patTaus) retVal_pfTauHPSpTaNC = patSequenceBuilder( process, collectionName=["patPFTaus", "HPSpTaNC"], jetCollectionName=pfJetCollection, patTauProducerPrototype=process.patPFTauProducerHPSpTaNC, patTauCleanerPrototype=patPFTauCleanerPrototype, triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType, addGenInfo=isMC, applyTauJEC=True, applyTauVertexMatch=applyTauVertexMatch) process.pfTauSequenceHPSpTaNC = retVal_pfTauHPSpTaNC["sequence"] process.patMuonPFTauPairsHPSpTaNC = process.allMuTauPairs.clone( srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'), srcLeg2=cms.InputTag(retVal_pfTauHPSpTaNC["collection"]), srcMET=cms.InputTag(pfMEtCollection), srcGenParticles=cms.InputTag(''), doSVreco=cms.bool(False)) if hasattr(process.patMuonPFTauPairsHPSpTaNC, "nSVfit"): delattr(process.patMuonPFTauPairsHPSpTaNC, "nSVfit") if hasattr(process.patMuonPFTauPairsHPSpTaNC, "pfMEtSign"): delattr(process.patMuonPFTauPairsHPSpTaNC, "pfMEtSign") #-------------------------------------------------------------------------------- process.patTupleProductionSequence = cms.Sequence( process.muonPFIsolationSequence + process.patDefaultSequence ##+ process.patTrigger + process.patTriggerEvent + process.patMuonsWithinAcc + process.selectedPatMuonsVBTFid + process.patMEtProductionSequence + process.caloTauSequence # store TaNC inputs as discriminators #+ process.produceTancMVAInputDiscriminators #+ process.pfTauSequenceFixedCone #+ process.pfTauSequenceShrinkingCone + process.pfTauSequenceHPS + process.pfTauSequenceHPSpTaNC + process.patMuonCaloTauPairs #+ process.patMuonPFTauPairsFixedCone #+ process.patMuonPFTauPairsShrinkingCone + process.patMuonPFTauPairsHPS + process.patMuonPFTauPairsHPSpTaNC) # return names of "final" collections of CaloTaus/different types of PFTaus # to be used as InputTag for further processing retVal = {} retVal["caloTauCollection"] = retVal_caloTau["collection"] retVal["muonCaloTauCollection"] = process.patMuonCaloTauPairs.label() #retVal["pfTauCollectionFixedCone"] = retVal_pfTauFixedCone["collection"] #retVal["muonPFTauCollectionFixedCone"] = process.patMuonPFTauPairsFixedCone.label() #retVal["pfTauCollectionShrinkingCone"] = retVal_pfTauShrinkingCone["collection"] #retVal["muonPFTauCollectionShrinkingCone"] = process.patMuonPFTauPairsShrinkingCone.label() retVal["pfTauCollectionHPS"] = retVal_pfTauHPS["collection"] retVal["muonPFTauCollectionHPS"] = process.patMuonPFTauPairsHPS.label() retVal["pfTauCollectionHPSpTaNC"] = retVal_pfTauHPSpTaNC["collection"] retVal[ "muonPFTauCollectionHPSpTaNC"] = process.patMuonPFTauPairsHPSpTaNC.label( ) return retVal
) # Weights process.pileupReweighter= cms.EDFilter("RSPileupReweighter", generatedFile = cms.string("pileup_Wjets.root"), dataFile = cms.string("Pileup_2011_EPS_8_jul.root"), genHistName = cms.string("pileup"), dataHistName = cms.string("pileup"), useROOThistos = cms.bool(False) ) # MET systematics # apply type I/type I + II PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process) process.cleanPatMuons.src = "selectedPatMuonsPFlow" process.cleanPatElectrons.src = "selectedPatElectronsPFlow" process.cleanPatTaus.src = "selectedPatTausPFlow" process.cleanPatJets.src = "selectedPatJetsPFlow" process.patseq = cms.Sequence( process.preselection* getattr(process,"patPF2PATSequence"+postfix)* process.patDefaultSequence* process.goodPatJetsPFlow* process.goodPatJetsCA8PrunedPF* process.cutOnJet )
from PhysicsTools.PatAlgos.tools.metTools import * postfix = "PFlow" jetAlgo="AK5" #addPfMET(process, postfixLabel=postfix) usePF2PAT(process,runPF2PAT=True,jetAlgo=jetAlgo,runOnMC=True,postfix=postfix,jetCorrections=('AK5PF',['L1FastJet','L2Relative','L3Absolute']),typeIMetCorrections=True,outputModules=[]) # to use tau-cleaned jet collection uncomment the following: #getattr(process,"pfNoTau"+postfix).enable = True # to switch default tau to HPS tau uncomment the following: #adaptPFTaus(process,"hpsPFTau",postfix=postfix) from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties(process, electronCollection='selectedPatElectronsPFlow', muonCollection='selectedPatMuonsPFlow', tauCollection='selectedPatTausPFlow', jetCollection='selectedPatJetsPFlow',doApplyType0corr=False) process.PF2PAT = cms.Sequence( # process.patDefaultSequence + getattr(process,"patPF2PATSequence"+postfix) + process.metUncertaintySequence ) #output commands skimEventContent = cms.PSet( outputCommands = cms.untracked.vstring( "keep *", "drop *_*ak7*_*_*", "drop *_*kt4*_*_*", "drop *_kt6GenJets_*_*", "drop *_kt6CaloJets*_*_*",
def SingleTopStep1(process, ): options = VarParsing('analysis') options.register('isMC', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Run on MC") options.register('doDebug', False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Run in debugging mode") options.register('doSkimming', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Preselect events") options.register('doSlimming', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Drop unnecessary collections") options.register('doMuon', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Do muon paths") options.register('doElectron', True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Do electron paths") #Tag from https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideFrontierConditions?redirectedfrom=CMS.SWGuideFrontierConditions#2012_MC_production # Latest for "53Y Releases (MC)" options.register('globalTag', Config.globalTagMC, VarParsing.multiplicity.singleton, VarParsing.varType.string, "Global tag") options.parseArguments() process.source.fileNames = cms.untracked.vstring(options.inputFiles) process.maxEvents = cms.untracked.PSet( input=cms.untracked.int32(options.maxEvents)) process.out.fileName = cms.untracked.string(options.outputFile) process.options = cms.untracked.PSet( wantSummary=cms.untracked.bool(options.doDebug)) if options.doDebug: process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger = cms.Service( "MessageLogger", destinations=cms.untracked.vstring('cout', 'debug'), debugModules=cms.untracked.vstring('*'), cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')), debug=cms.untracked.PSet(threshold=cms.untracked.string('DEBUG')), ) else: process.load("FWCore.MessageService.MessageLogger_cfi") postfix = "" jetCorr = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not options.isMC: jetCorr += ['L2L3Residual'] usePF2PAT( process, runPF2PAT=True, jetAlgo='AK5', runOnMC=options.isMC, postfix=postfix, jetCorrections=('AK5PFchs', jetCorr), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), #typeIMetCorrections = True typeIMetCorrections= False #Type1 MET now applied later using runMETUncertainties ) # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012 process.pfPileUp.Enable = True process.pfPileUp.checkClosestZVertex = False #------------------------------------------------- # selection step 2: vertex filter #------------------------------------------------- # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012 # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams=cms.PSet(minNdof=cms.double(4.0), maxZ=cms.double(24.0), maxRho=cms.double(2.0)), filter=cms.bool(True), src=cms.InputTag('offlinePrimaryVertices')) #------------------------------------------------- # Muons #------------------------------------------------- #if not maxLeptonIso is None: # process.pfIsolatedMuons.isolationCut = maxLeptonIso #Use both isolated and non-isolated muons as a patMuon source #process.patMuons.pfMuonSource = cms.InputTag("pfMuons") #process.muonMatch.src = cms.InputTag("pfMuons") process.patMuons.pfMuonSource = cms.InputTag("pfIsolatedMuons") process.muonMatch.src = cms.InputTag("pfIsolatedMuons") process.selectedPatMuons.cut = "pt>20 && abs(eta)<3.0" # muon ID production (essentially track count embedding) must be here # because tracks get dropped from the collection after this step, resulting # in null ptrs. process.muonsWithID = cms.EDProducer( 'MuonIDProducer', muonSrc=cms.InputTag("selectedPatMuons"), primaryVertexSource=cms.InputTag("goodOfflinePrimaryVertices")) #process.muonClones = cms.EDProducer("MuonShallowCloneProducer", # src = cms.InputTag("selectedPatMuons") #) #------------------------------------------------- # Electrons # Implemented as in https://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=208765 #------------------------------------------------- #if not maxLeptonIso is None: # process.pfIsolatedElectrons.isolationCut = maxLeptonIso #Use both isolated and un-isolated electrons as patElectrons. #NB: no need to change process.electronMatch.src to pfElectrons, # it's already gsfElectrons, which is a superset of the pfElectrons process.patElectrons.pfElectronSource = cms.InputTag("pfElectrons") process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi') process.mvaID = cms.Sequence(process.mvaTrigV0 + process.mvaNonTrigV0) process.patElectrons.electronIDSources.mvaTrigV0 = cms.InputTag( "mvaTrigV0") process.patElectrons.electronIDSources.mvaNonTrigV0 = cms.InputTag( "mvaNonTrigV0") process.patPF2PATSequence.replace(process.patElectrons, process.mvaID * process.patElectrons) process.selectedPatElectrons.cut = "pt>25 && abs(eta)<3.0" process.electronsWithID = cms.EDProducer( 'ElectronIDProducer', electronSrc=cms.InputTag("selectedPatElectrons"), primaryVertexSource=cms.InputTag("goodOfflinePrimaryVertices")) #process.electronClones = cms.EDProducer("ElectronShallowCloneProducer", # src = cms.InputTag("selectedPatElectrons") #) #if not maxLeptonIso is None: # process.pfIsolatedElectrons.isolationCut = maxLeptonIso #electron dR=0.3 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.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag( "elPFIsoValuePU03PFId") process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag( cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId")) process.patElectrons.isolationValues.pfNeutralHadrons = cms.InputTag( "elPFIsoValueNeutral03PFId") process.patElectrons.isolationValues.pfChargedAll = cms.InputTag( "elPFIsoValueChargedAll03PFId") process.patElectrons.isolationValues.pfPUChargedHadrons = cms.InputTag( "elPFIsoValuePU03PFId") process.patElectrons.isolationValues.pfPhotons = cms.InputTag( "elPFIsoValueGamma03PFId") process.patElectrons.isolationValues.pfChargedHadrons = cms.InputTag( "elPFIsoValueCharged03PFId") 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")) #------------------------------------------------- # Jets # MET corrections as https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_0_with_PAT #------------------------------------------------- #pfNoTau == True => remove taus from jets #process.pfNoTau.enable = noTau process.selectedPatJets.cut = cms.string("pt>30 && abs(eta)<5.0") process.load("CMGTools.External.pujetidsequence_cff") process.patPF2PATSequence += process.puJetIdSqeuence #process.jetClones = cms.EDProducer("CaloJetShallowCloneProducer", # src = cms.InputTag("seletedPatJets") #) #------------------------------------------------- # MET uncertainty step #------------------------------------------------- #Embed the reference to the original jet in the jets, which is constant during the propagation process.patJetsWithOwnRef = cms.EDProducer( 'PatObjectOwnRefProducer<pat::Jet>', src=cms.InputTag("selectedPatJets")) #Note: this module causes a large memory increase when crossing the file boundary #Reason - unknown, solution: limit processing to ~1 file. from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties runMEtUncertainties( process, electronCollection=cms.InputTag("electronsWithID"), photonCollection=None, muonCollection=cms.InputTag("muonsWithID"), tauCollection="", # "" means emtpy, None means cleanPatTaus jetCollection=cms.InputTag("patJetsWithOwnRef"), jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual", doSmearJets=options.isMC, jetCorrPayloadName="AK5PFchs", addToPatDefaultSequence=False) process.stpolMetUncertaintySequence = cms.Sequence( process.metUncertaintySequence) if not options.doSlimming: process.out.outputCommands = cms.untracked.vstring('keep *') else: process.out.outputCommands = cms.untracked.vstring([ 'drop *', 'keep edmMergeableCounter_*_*_*', # Keep the lumi-block counter information 'keep edmTriggerResults_TriggerResults__*', #Keep the trigger results 'keep *_genParticles__*', #keep all the genParticles #'keep recoVertexs_offlinePrimaryVertices__*', #keep the offline PV-s 'keep recoVertexs_goodOfflinePrimaryVertices__*', #keep the offline PV-s # Jets 'keep patJets_*__*', 'keep double_*_rho_*', #For rho-corr rel iso 'keep recoGenJets_selectedPatJets_genJets_*', #For Jet MC smearing we need to keep the genJets "keep *_puJetId_*_*", # input variables "keep *_puJetMva_*_*", # final MVAs and working point flags 'keep *_jetClones__*', # Muons 'keep patMuons_*__*', 'keep *_muonClones__*', # Electrons 'keep patElectrons_*__*', 'keep *_electronClones__*', # METs 'keep patMETs_*__*', #ECAL laser corr filter 'keep bool_ecalLaserCorrFilter__*', #For flavour analyzer 'keep GenEventInfoProduct_generator__*', #PU info 'keep PileupSummaryInfos_addPileupInfo__*', ##PFCandidates #'keep recoPFCandidates_*_pfCandidates_PAT', #'keep recoPFMETs_pfMET__*', #'keep recoPFMETs_pfMet__*', #'keep recoGenMETs_genMetTrue__*', #'keep recoPFCandidates_particleFlow__*', #'keep recoConversions_allConversions__*', #'keep recoVertexCompositeCandidates_generalV0Candidates_*_*', #'keep recoTracks_generalTracks__*', #'keep recoBeamSpot_offlineBeamSpot__*', #'keep recoMuons_muons__*', 'keep int_*__PAT', 'keep ints_*__PAT', 'keep double_*__PAT', 'keep doubles_*__PAT', 'keep float_*__PAT', 'keep floats_*__PAT', ]) #FIXME: is this correct? #Keep events that pass either the muon OR the electron path process.out.SelectEvents = cms.untracked.PSet(SelectEvents=cms.vstring([])) #------------------------------------------------- # Paths #------------------------------------------------- process.goodOfflinePVCount = cms.EDProducer( "CollectionSizeProducer<reco::Vertex>", src=cms.InputTag("goodOfflinePrimaryVertices")) process.preCalcSequences = cms.Sequence(process.patJetsWithOwnRef * process.goodOfflinePVCount) process.patPF2PATSequence.insert( process.patPF2PATSequence.index(process.selectedPatMuons) + 1, process.muonsWithID) process.patPF2PATSequence.insert( process.patPF2PATSequence.index(process.selectedPatElectrons) + 1, process.electronsWithID) #Need separate paths because of skimming if options.doMuon: process.singleTopPathStep1Mu = cms.Path( process.goodOfflinePrimaryVertices * process.patPF2PATSequence #* process.muonClones #* process.electronClones #* process.jetClones ) if options.doElectron: process.singleTopPathStep1Ele = cms.Path( process.goodOfflinePrimaryVertices * process.patPF2PATSequence #* process.muonClones #* process.electronClones #* process.jetClones ) if options.doMuon: process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Mu") if options.doElectron: process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Ele") process.GlobalTag.globaltag = cms.string(options.globalTag) process.singleTopPathStep1Mu += process.preCalcSequences process.singleTopPathStep1Ele += process.preCalcSequences if options.doMuon: process.singleTopPathStep1Mu += process.stpolMetUncertaintySequence if options.doElectron: process.singleTopPathStep1Ele += process.stpolMetUncertaintySequence if options.isMC: #https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC process.GlobalTag.toGet = cms.VPSet( cms.PSet(record=cms.string("BTagTrackProbability2DRcd"), tag=cms.string("TrackProbabilityCalibration_2D_MC53X_v2"), connect=cms.untracked.string( "frontier://FrontierPrep/CMS_COND_BTAU")), cms.PSet(record=cms.string("BTagTrackProbability3DRcd"), tag=cms.string("TrackProbabilityCalibration_3D_MC53X_v2"), connect=cms.untracked.string( "frontier://FrontierPrep/CMS_COND_BTAU"))) else: #https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC process.GlobalTag.toGet = cms.VPSet( cms.PSet( record=cms.string("BTagTrackProbability2DRcd"), tag=cms.string("TrackProbabilityCalibration_2D_Data53X_v2"), connect=cms.untracked.string( "frontier://FrontierPrep/CMS_COND_BTAU")), cms.PSet( record=cms.string("BTagTrackProbability3DRcd"), tag=cms.string("TrackProbabilityCalibration_3D_Data53X_v2"), connect=cms.untracked.string( "frontier://FrontierPrep/CMS_COND_BTAU"))) process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi') process.ecalLaserCorrFilter.taggingMode = True # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters process.scrapingFilter = cms.EDFilter( "FilterOutScraping", applyfilter=cms.untracked.bool(True), debugOn=cms.untracked.bool(False), numtrack=cms.untracked.uint32(10), thresh=cms.untracked.double(0.25)) #if doElectron: # process.singleTopPathStep1Ele.insert(0, process.scrapingFilter) #if doMuon: # process.singleTopPathStep1Mu.insert(0, process.scrapingFilter) process.patPF2PATSequence += process.scrapingFilter process.patPF2PATSequence += process.ecalLaserCorrFilter #if not onGrid: # from SingleTopPolarization.Analysis.cmdlineParsing import enableCommandLineArguments # enableCommandLineArguments(process) #else: # process.out.fileName = "step1.root" if options.doSkimming: process.out.fileName.setValue(process.out.fileName.value().replace( ".root", "_Skim.root")) else: process.out.fileName.setValue(process.out.fileName.value().replace( ".root", "_noSkim.root")) #----------------------------------------------- # Skimming #----------------------------------------------- #Throw away events before particle flow? if options.doSkimming: from SingleTopPolarization.Analysis.eventSkimming_cfg import skimFilters skimFilters(process) if options.doMuon: process.singleTopPathStep1Mu.insert(0, process.muonSkim) if options.doElectron: process.singleTopPathStep1Ele.insert(0, process.electronSkim) #----------------------------------------------- # Skim efficiency counters #----------------------------------------------- #count all processed events countProcessed(process) #count events passing mu and ele paths if options.doMuon: countInSequence(process, process.singleTopPathStep1Mu) if options.doElectron: countInSequence(process, process.singleTopPathStep1Ele) #------------------------------------------------- # #------------------------------------------------- if not options.doSlimming: process.out.fileName.setValue(process.out.fileName.value().replace( ".root", "_noSlim.root")) return process