def switchToData(process): #remove MC matching from standard PAT sequences #from AnalysisSpace.TreeMaker.SwitchToData import switchToData # remove MC matching coreTools.runOnData(process, outputInProcess=False) #coreTools.removeMCMatching(process, ["All"], outputInProcess = False) coreTools.removeMCMatching(process, ['METs'], "TC", outputInProcess=False) coreTools.removeMCMatching(process, ['METs'], "PF", outputInProcess=False) coreTools.removeMCMatching(process, ['METs'], "AK5Calo", outputInProcess=False) process.patDefaultSequence.remove(process.patJetPartonMatch) process.patDefaultSequence.remove(process.patJetPartonMatchAK5PF) process.patDefaultSequence.remove(process.patJetPartonMatchAK5Calo) process.patDefaultSequence.remove(process.patJetGenJetMatchAK5PF) process.patDefaultSequence.remove(process.patJetGenJetMatchAK5Calo) process.patDefaultSequence.remove(process.patJetFlavourId) process.patDefaultSequence.remove(process.patJetPartons) process.patDefaultSequence.remove(process.patJetPartonAssociation) process.patDefaultSequence.remove(process.patJetPartonAssociationAK5PF) process.patDefaultSequence.remove(process.patJetPartonAssociationAK5Calo) process.patDefaultSequence.remove(process.patJetFlavourAssociation) process.patDefaultSequence.remove(process.patJetFlavourAssociationAK5PF) process.patDefaultSequence.remove(process.patJetFlavourAssociationAK5Calo)
def miniAOD_customizeData(process): from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process, outputModules=[]) process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cff") process.load("RecoCTPPS.ProtonReconstruction.ctppsProtons_cff") task = getPatAlgosToolsTask(process) task.add(process.ctppsLocalTrackLiteProducer) task.add(process.ctppsProtons)
def miniAOD_customizeData(process): from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process, outputModules = [] ) process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cff") process.load("RecoCTPPS.ProtonReconstruction.ctppsProtons_cff") process.load("Geometry.VeryForwardGeometry.geometryRPFromDB_cfi") task = getPatAlgosToolsTask(process) from Configuration.Eras.Modifier_ctpps_2016_cff import ctpps_2016 ctpps_2016.toModify(task, func=lambda t: t.add(process.ctppsLocalTrackLiteProducer)) ctpps_2016.toModify(task, func=lambda t: t.add(process.ctppsProtons))
def miniAOD_customizeData(process): from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process, outputModules = [] ) process.load("RecoPPS.Local.ctppsLocalTrackLiteProducer_cff") process.load("RecoPPS.ProtonReconstruction.ctppsProtons_cff") process.load("Geometry.VeryForwardGeometry.geometryRPFromDB_cfi") process.load('L1Trigger.L1TGlobal.simGtExtFakeProd_cfi') task = getPatAlgosToolsTask(process) from Configuration.Eras.Modifier_ctpps_cff import ctpps ctpps.toModify(task, func=lambda t: t.add(process.ctppsLocalTrackLiteProducer)) ctpps.toModify(task, func=lambda t: t.add(process.ctppsProtons)) from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL run2_miniAOD_UL.toModify(task, func=lambda t: t.add(process.simGtExtUnprefireable))
def removeMCUse(process): # Remove anything that requires MC truth. # from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching # removeMCMatching(process, ['All']) from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process) # I have no idea why all gen processes also have to be removed by hand... process.patDefaultSequence.remove(process.electronMatch) process.patDefaultSequence.remove(process.muonMatch) process.patDefaultSequence.remove(process.tauMatch) process.patDefaultSequence.remove(process.tauGenJets) process.patDefaultSequence.remove(process.tauGenJetsSelectorAllHadrons) process.patDefaultSequence.remove(process.tauGenJetMatch) process.patDefaultSequence.remove(process.photonMatch) process.patDefaultSequence.remove(process.patJetPartonMatch) process.patDefaultSequence.remove(process.patJetGenJetMatch) process.patDefaultSequence.remove(process.patJetPartonsLegacy) process.patDefaultSequence.remove(process.patJetPartonAssociationLegacy) process.patDefaultSequence.remove(process.patJetFlavourAssociationLegacy) process.patDefaultSequence.remove(process.patJetPartons) process.patDefaultSequence.remove(process.patJetFlavourAssociation)
def switchToData(process): #remove MC matching from standard PAT sequences #from AnalysisSpace.TreeMaker.SwitchToData import switchToData # remove MC matching coreTools.runOnData(process, outputModules = []) #coreTools.removeMCMatching(process, ["All"], outputModules = []) coreTools.removeMCMatching(process, ['METs'], "TC", outputModules = []) coreTools.removeMCMatching(process, ['METs'], "PF", outputModules = []) coreTools.removeMCMatching(process, ['METs'], "AK5Calo", outputModules = []) process.patDefaultSequence.remove(process.patJetPartonMatch) process.patDefaultSequence.remove(process.patJetPartonMatchAK5PF) process.patDefaultSequence.remove(process.patJetPartonMatchAK5Calo) process.patDefaultSequence.remove(process.patJetGenJetMatchAK5PF) process.patDefaultSequence.remove(process.patJetGenJetMatchAK5Calo) process.patDefaultSequence.remove(process.patJetFlavourId) process.patDefaultSequence.remove(process.patJetPartons) process.patDefaultSequence.remove(process.patJetPartonAssociation) process.patDefaultSequence.remove(process.patJetPartonAssociationAK5PF) process.patDefaultSequence.remove(process.patJetPartonAssociationAK5Calo) process.patDefaultSequence.remove(process.patJetFlavourAssociation) process.patDefaultSequence.remove(process.patJetFlavourAssociationAK5PF) process.patDefaultSequence.remove(process.patJetFlavourAssociationAK5Calo)
pfTools.applyPostfix( process, 'pfIsolatedMuons' , postfix ).isolationCut = patRefSel_refMuJets.pfMuonCombIsoCut pfTools.applyPostfix( process, 'pfElectronsFromVertex' , postfix ).vertices = cms.InputTag( patRefSel_refMuJets.pfVertices ) pfTools.applyPostfix( process, 'pfElectronsFromVertex' , postfix ).d0Cut = patRefSel_refMuJets.pfD0Cut pfTools.applyPostfix( process, 'pfElectronsFromVertex' , postfix ).dzCut = patRefSel_refMuJets.pfDzCut pfTools.applyPostfix( process, 'pfSelectedElectrons' , postfix ).cut = patRefSel_refMuJets.pfElectronSelectionCut pfTools.applyPostfix( process, 'pfIsolatedElectrons' , postfix ).isolationCut = patRefSel_refMuJets.pfElectronCombIsoCut pfTools.applyPostfix( process, 'patElectrons', postfix ).pvSrc = cms.InputTag( patRefSel_refMuJets.pfVertices ) pfTools.applyPostfix( process, 'patMuons' , postfix ).pvSrc = cms.InputTag( patRefSel_refMuJets.pfVertices ) import TopQuarkAnalysis.Configuration.patRefSel_refMuJets_cfi as patRefSel_refMuJets_cfi # remove MC matching, object cleaning, objects etc. ## remove MCMatching if run on Data if options.runOnData: from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process, names = [ 'PFAll' ],postfix =postfix) print "removeMatching" if not runOnMC: runOnData( process , names = [ 'PFAll' ] , postfix = postfix ) PhysPatAlgCoreTools.removeSpecificPATObjects( process , names = [ 'Photons', 'Taus' ] , postfix = postfix ) # includes 'removeCleaning' # additional event content has to be (re-)added _after_ the call to 'removeCleaning()': process.out.outputCommands += [ 'keep edmTriggerResults_*_*_*' , 'keep *_hltTriggerSummaryAOD_*_*' # vertices and beam spot , 'keep *_offlineBeamSpot_*_*'
def addPlainPat(process, dataVersion, doPatTrigger=True, doPatTaus=True, doHChTauDiscriminators=True, doPatMET=True, doPatElectronID=True, doPatCalo=True, doBTagging=True, doPatMuonPFIsolation=False, doPatTauIsoDeposits=False, doTauHLTMatching=True, matchingTauTrigger=None, matchingJetTrigger=None, includePFCands=False): out = None outdict = process.outputModules_() if outdict.has_key("out"): out = outdict["out"] outputCommands = [] # Tau Discriminators process.hplusPatTauSequence = cms.Sequence() if doPatTaus: process.hplusPatTauSequence = addPFTausAndDiscriminators(process, dataVersion, doPatCalo, doHChTauDiscriminators) # PAT Layer 0+1 process.load("PhysicsTools.PatAlgos.patSequences_cff") sequence = cms.Sequence( process.hplusPatTauSequence ) # Restrict input to AOD restrictInputToAOD(process, ["All"]) # Remove MC stuff if we have collision data (has to be done any add*Collection!) # This also adds the L2L3Residual JEC correction to the process.patJetCorrFactors if dataVersion.isData(): runOnData(process, outputInProcess = out!=None) # Jets # Produce kt6 rho for L1Fastjet process.load('RecoJets.Configuration.RecoPFJets_cff') process.kt6PFJets.doRhoFastjet = True process.ak5PFJets.doAreaFastjet = True process.ak5PFJetSequence = cms.Sequence(process.kt6PFJets * process.ak5PFJets) # Set defaults process.patJets.jetSource = cms.InputTag("ak5CaloJets") process.patJets.trackAssociationSource = cms.InputTag("ak5JetTracksAssociatorAtVertex") setPatJetDefaults(process.patJets) setPatJetCorrDefaults(process.patJetCorrFactors, dataVersion) process.patDefaultSequence.replace(process.patJetCorrFactors, process.ak5PFJetSequence*process.patJetCorrFactors) process.selectedPatJets.cut = jetPreSelection # The default JEC to be embedded to pat::Jets are L2Relative, # L3Absolute, L5Flavor and L7Parton. The default JEC to be applied # is L2L3Residual, or L3Absolute, or Uncorrected (in this order). if doPatCalo: # Add JPT jets # FIXME: Disabled for now until the JEC for JPT works again (with the latest JEC) # addJetCollection(process, cms.InputTag('JetPlusTrackZSPCorJetAntiKt5'), # 'AK5', 'JPT', # doJTA = True, # doBTagging = doBTagging, # jetCorrLabel = ('AK5JPT', process.patJetCorrFactors.levels), # doType1MET = False, # doL1Cleaning = False, # doL1Counters = True, # genJetCollection = cms.InputTag("ak5GenJets"), # doJetID = True # ) # Add PF jets addJetCollection(process, cms.InputTag('ak5PFJets'), 'AK5', 'PF', doJTA = True, doBTagging = doBTagging, jetCorrLabel = ('AK5PF', process.patJetCorrFactors.levels), doType1MET = False, doL1Cleaning = False, doL1Counters = True, genJetCollection = cms.InputTag("ak5GenJets"), doJetID = True ) setPatJetCorrDefaults(process.patJetCorrFactorsAK5PF, dataVersion, True) else: setPatJetCorrDefaults(process.patJetCorrFactors, dataVersion, True) switchJetCollection(process, cms.InputTag('ak5PFJets'), doJTA = True, doBTagging = doBTagging, jetCorrLabel = ('AK5PF', process.patJetCorrFactors.levels), doType1MET = False, genJetCollection = cms.InputTag("ak5GenJets"), doJetID = True ) outputCommands.extend([ "keep *_selectedPatJets_*_*", "keep *_selectedPatJetsAK5JPT_*_*", "keep *_selectedPatJetsAK5PF_*_*", 'drop *_selectedPatJets_pfCandidates_*', ## drop for default patJets which are CaloJets 'drop *_*PF_caloTowers_*', 'drop *_*JPT_pfCandidates_*', 'drop *_*Calo_pfCandidates_*', ]) # Taus # Set default PATTauProducer options here, they should be # replicated to all added tau collections (and the first call to # addTauCollection should replace the default producer modified # here) setPatTauDefaults(process.patTaus, includePFCands) process.selectedPatTaus.cut = tauPreSelection if doPatTaus: if doHChTauDiscriminators: addHChTauDiscriminators() # Don't enable TCTau nor shrinking cone tau # if doPatCalo: # tauTools.addTauCollection(process,cms.InputTag('caloRecoTauProducer'), # algoLabel = "caloReco", # typeLabel = "Tau") # setPatTauDefaults(process.patTausCaloRecoTau, True) # process.patTausCaloRecoTau.embedLeadTrack = not includePFCands # process.patTausCaloRecoTau.embedLeadPFChargedHadrCand = False # tauTools.addTauCollection(process,cms.InputTag('shrinkingConePFTauProducer'), # algoLabel = "shrinkingCone", # typeLabel = "PFTau") # # Disable isoDeposits like this until the problem with doPFIsoDeposits is fixed # if not doPatTauIsoDeposits: # process.patTausShrinkingConePFTau.isoDeposits = cms.PSet() tauTools.addTauCollection(process,cms.InputTag('hpsPFTauProducer'), algoLabel = "hps", typeLabel = "PFTau") if not doPatTauIsoDeposits: process.patTausHpsPFTau.isoDeposits = cms.PSet() addPatTauIsolationEmbedding(process, process.patDefaultSequence, "HpsPFTau") tauTools.addTauCollection(process,cms.InputTag('hpsTancTaus'), algoLabel = "hpsTanc", typeLabel = "PFTau") if not doPatTauIsoDeposits: process.patTausHpsTancPFTau.isoDeposits = cms.PSet() # Disable discriminators which are not in AOD # del process.patTausHpsTancPFTau.tauIDSources.againstCaloMuon # del process.patTausHpsTancPFTau.tauIDSources.byHPSvloose addPatTauIsolationEmbedding(process, process.patDefaultSequence, "HpsTancPFTau") # Add visible taus if dataVersion.isMC(): process.VisibleTaus = cms.EDProducer("HLTTauMCProducer", GenParticles = cms.untracked.InputTag("genParticles"), ptMinTau = cms.untracked.double(3), ptMinMuon = cms.untracked.double(3), ptMinElectron = cms.untracked.double(3), BosonID = cms.untracked.vint32(23), EtaMax = cms.untracked.double(2.5) ) sequence *= process.VisibleTaus outputCommands.append("keep *_VisibleTaus_*_*") else: # FIXME: this is broken at the moment #removeSpecificPATObjects(process, ["Taus"], outputInProcess= out != None) process.patDefaultSequence.remove(process.patTaus) process.patDefaultSequence.remove(process.selectedPatTaus) outputCommands.extend(["drop *_selectedPatTaus_*_*", # "keep *_selectedPatTausCaloRecoTau_*_*", # "keep *_selectedPatTausShrinkingConePFTau_*_*", "keep *_selectedPatTausHpsPFTau_*_*", "keep *_selectedPatTausHpsTancPFTau_*_*", #"keep *_cleanPatTaus_*_*", #"drop *_cleanPatTaus_*_*", #"keep *_patTaus*_*_*", #"keep *_patPFTauProducerFixedCone_*_*", # keep these until the embedding problem with pat::Tau is fixed #"keep recoPFCandidates_particleFlow_*_*", #"keep recoTracks_generalTracks_*_*" ]) # MET addPfMET(process, 'PF') if doPatCalo: addTcMET(process, 'TC') else: # FIXME: This is broken at the moment... #removeSpecificPATObjects(process, ["METs"], outputInProcess= out != None) #process.patDefaultSequen process.patDefaultSequence.remove(process.patMETCorrections) process.patDefaultSequence.remove(process.patMETs) del process.patMETCorrections del process.patMETs outputCommands.extend([ "keep *_patMETs_*_*", "keep *_patMETsTC_*_*", "keep *_patMETsPF_*_*", "keep *_genMetTrue_*_*", ]) # Muons setPatLeptonDefaults(process.patMuons, includePFCands) if doPatMuonPFIsolation: addPFMuonIsolation(process, process.patMuons, sequence, verbose=True) outputCommands.extend([ "keep *_selectedPatMuons_*_*" ]) # Electrons # In order to calculate the transverse impact parameter w.r.t. # beam spot instead of primary vertex, see setPatLeptonDefaults(process.patMuons, includePFCands) # Electron ID, see # https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID if doPatElectronID: addPatElectronID(process, process.patElectrons, process.patDefaultSequence) outputCommands.extend([ "keep *_selectedPatElectrons_*_*" ]) # Photons # process.patPhotons.embedGenMatch = False outputCommands.extend([ "keep *_selectedPatPhotons_*_*" ]) # Trigger if doPatTrigger: outMod= '' if out != None: outMod = 'out' switchOnTrigger(process, hltProcess=dataVersion.getTriggerProcess(), outputModule=outMod) process.patTrigger.addL1Algos = cms.bool(True) process.patTrigger.l1ExtraMu = cms.InputTag("l1extraParticles") process.patTrigger.l1ExtraCenJet = cms.InputTag("l1extraParticles", "Central") process.patTrigger.l1ExtraTauJet = cms.InputTag("l1extraParticles", "Tau") process.patTrigger.l1ExtraForJet = cms.InputTag("l1extraParticles", "Forward") process.patTrigger.l1ExtraETM = cms.InputTag("l1extraParticles", "MET") process.patTrigger.l1ExtraHTM = cms.InputTag("l1extraParticles", "MHT") # Keep StandAlone trigger objects for enabling trigger # matching in the analysis phase with PAT tools outputCommands.extend(patTriggerStandAloneEventContent) # Remove cleaning step and set the event content if out == None: myRemoveCleaning(process) else: backup = out.outputCommands[:] myRemoveCleaning(process) # backup_pat = out.outputCommands[:] # Remove PFParticles here, they are explicitly included when needed # backup_pat = filter(lambda n: "selectedPatPFParticles" not in n, backup_pat) out.outputCommands = backup # out.outputCommands.extend(backup_pat) out.outputCommands.extend(outputCommands) # Build sequence sequence *= process.patDefaultSequence # Tau+HLT matching if doTauHLTMatching: sequence *= HChTriggerMatching.addTauHLTMatching(process, matchingTauTrigger, matchingJetTrigger) return sequence
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.source = cms.Source( "PoolSource", fileNames = cms.untracked.vstring( 'file:/scratch/efriis/results/infn_mmt_events.root' ), eventsToProcess = cms.untracked.VEventRange('175990:120477532') ) process.GlobalTag.globaltag = cms.string('GR_R_42_V21::All') import PhysicsTools.PatAlgos.tools.tauTools as tautools import PhysicsTools.PatAlgos.tools.coreTools as coreTools tautools.switchToPFTauHPS(process) coreTools.runOnData(process) process.patJetCorrFactors.useRho = False process.selectOurWeirdTau = cms.EDFilter( "PATTauSelector", src = cms.InputTag("patTaus"), cut = cms.string('eta < -0.1 & eta > -0.12 & pt > 36 & pt < 38'), filter = cms.bool(True) ) process.ourTauPassesDecayMode = cms.EDFilter( "PATTauSelector", src = cms.InputTag("selectOurWeirdTau"), cut = cms.string('tauID("decayModeFinding")'), filter = cms.bool(True) )
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32( 100 ) ) ## Output from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out = cms.OutputModule( "PoolOutputModule" , fileName = cms.untracked.string( 'patTuple_data.root' ) , outputCommands = cms.untracked.vstring( *patEventContentNoCleaning ) ) process.out.outputCommands += [ 'drop recoGenJets_*_*_*' ] process.outpath = cms.EndPath( process.out, patAlgosToolsTask ) ## Processing process.load( "PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff" ) patAlgosToolsTask.add(process.patCandidatesTask) #Temporary customize to the unit tests that fail due to old input samples process.patTaus.skipMissingTauID = True process.load( "PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff" ) patAlgosToolsTask.add(process.selectedPatCandidatesTask) # for data: from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process )
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)
def miniAOD_customizeData(process): from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process, outputModules=[]) process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cfi")
cms.PSet(type=cms.untracked.string("ObjectVariableCombined"), name=cms.string("SaveMuon"), cutList=cms.vstring("isMuon","PT5"), doAnd=cms.bool(True), ), cms.PSet(type=cms.untracked.string("ObjectVariableCombined"), name=cms.string("SaveElectron"), cutList=cms.vstring("isElectron","PT5"), doAnd=cms.bool(True), ), cms.PSet(type=cms.untracked.string("ObjectVariableCombined"), name=cms.string("WRITEOBJECT"), cutList=cms.vstring("SaveJet","SaveTrack","SaveAllOfType","SaveMuon","SaveElectron","SaveTau"), doAnd=cms.bool(False), ), cms.PSet(type=cms.untracked.string("Signature"), name=cms.string("testSignature"), cutList=cms.vstring(), ), ) process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi') # for data: from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process ,names=['Photons', 'Electrons','Muons', 'Taus', 'METs', 'PFAll', 'PFElectrons','PFTaus','PFMuons'] ) #runOnData( process ,outputModules = []) process.p = cms.Path( process.egmPhotonIDSequence * process.displacedAOD)
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ # '*', '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsCentralHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', #for zz muons '*_photonCore_*_*', # for Zmumu -> embedded samples '*_generator_weight_*', # 2k11 "GenFilterInfo_generator_minVisPtFilter_*", #2k12 '*_genDaughters_*_*', '*_boosted*_*_*', '*_tmfTracks_*_*', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex_*_*') output_commands.append('*_selectPrimaryVerticesQuality_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Rho_EtaMax = cms.double(2.5), Ghost_EtaMax = cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Standard services process.load('Configuration.StandardSequences.Services_cff') # tack on seeds for FSA PATTuple modules add_fsa_random_seeds(process) if cmssw_major_version() == 5 and cmssw_minor_version() >= 3: process.load('Configuration.Geometry.GeometryIdeal_cff') else: process.load('Configuration.StandardSequences.GeometryIdeal_cff') process.load('Configuration.StandardSequences.MagneticField_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') # Rerun tau ID if cmssw_major_version() == 4: process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove(process.pfRecoTauTagInfoProducer) process.recoTauClassicHPSSequence.remove(process.ak5PFJetTracksAssociatorAtVertex) assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] # Don't build junky taus below 19 GeV process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17) process.tuplize += process.recoTauClassicHPSSequence else: # We can run less tau stuff in 52, since HPS taus already built. process.load("RecoTauTag.Configuration.updateHPSPFTaus_cff") process.tuplize += process.updateHPSPFTaus ## Run rho computation. Only necessary in 42X if cmssw_major_version() == 4: from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets kt6PFJets.Rho_EtaMax = cms.double(4.4) kt6PFJets.doRhoFastjet = True process.kt6PFJets = kt6PFJets process.tuplize += process.kt6PFJets # In 4_X we have to rerun ak5PFJets with area computation enabled. if cmssw_major_version() == 4: process.load("RecoJets.Configuration.RecoPFJets_cff") process.ak5PFJets.doAreaFastjet = True process.tuplize += process.ak5PFJets # Only keep the new ak5PFJets output_commands.append('*_ak5PFJets_*_%s' % process.name_()) else: # Just keep the normal ones output_commands.append('*_ak5PFJets_*_*') # In the embedded samples, we need to re-run the b-tagging if kwargs['embedded']: process.load('RecoBTag/Configuration/RecoBTag_cff') process.load('RecoJets/JetAssociationProducers/ak5JTA_cff') process.ak5JetTracksAssociatorAtVertex.jets = cms.InputTag("ak5PFJets") process.ak5JetTracksAssociatorAtVertex.tracks = cms.InputTag("tmfTracks") process.tuplize += process.ak5JetTracksAssociatorAtVertex process.tuplize += process.btagging # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") process.tuplize += process.recoElectronID process.patElectrons.electronIDSources = process.electronIDSources process.patElectrons.embedTrack = True # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False # Use PFJets and turn on JEC jec = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend([ 'L2L3Residual' ]) # Define options for BTagging - these are release dependent. btag_options = {'doBTagging' : True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', ] # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA = False, jetCorrLabel = ('AK5PF', jec), #jetCorrLabel = None, doType1MET = False, doJetID = True, genJetCollection = cms.InputTag("ak5GenJets"), **btag_options ) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False #process.patJetCorrFactors.useRho = True ## Let's use the same rho as in the TauID, so we don't need to do it twice. #process.patJetCorrFactors.rho = cms.InputTag( #"kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('*_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") # We have to keep all jets (for the MVA MET...) process.patJetGarbageRemoval.cut = 'pt > 0' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons") process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) process.cleanPatElectrons.src = final_electron_collection #setup the energy regression for the specific dataset process.patElectronEnergyCorrections.isMC = cms.bool(bool(isMC)) process.patElectronEnergyCorrections.isAOD = \ cms.bool(bool(kwargs['isAOD'])) process.patElectronEnergyCorrections.dataSet = \ cms.string(kwargs['calibrationTarget']) process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Apply a loose preselection process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & pt > 17' # Don't apply any "final" cut process.cleanPatTaus.finalCut = '' # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #inject photons into pat sequence process.customizePhotonSequence.insert(0,process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src = final_tau_collection, algorithm = cms.string("byDeltaR"), preselection = cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') output_commands.append('*_%s_*_*' % final_met_collection.value()) trigtools.switchOnTrigger(process) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons' : 'cleanPatElectrons', 'muons' : 'cleanPatMuons', 'taus' : 'cleanPatTaus', 'photons' : 'cleanPatPhotons', 'jets' : 'selectedPatJets', 'met' : final_met_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag']) return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_gsfElectrons_*_*', '*_gsfElectronCores_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', # for zz muons '*_photonCore_*_*', '*_boostedFsrPhotons_*_*', # for Zmumu -> embedded samples # https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit '*_generalTracksORG_*_EmbeddedRECO', '*_electronGsfTracksORG_*_EmbeddedRECO', 'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN', 'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO', 'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO', 'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex*_*_*') output_commands.append('*_selectPrimaryVerticesQuality*_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), Rho_EtaMax=cms.double(2.5), Ghost_EtaMax=cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Standard services process.load('Configuration.StandardSequences.Services_cff') # tack on seeds for FSA PATTuple modules add_fsa_random_seeds(process) if cmssw_major_version() == 5 and cmssw_minor_version() >= 3: process.load('Configuration.Geometry.GeometryDB_cff') else: process.load('Configuration.StandardSequences.GeometryDB_cff') process.load('Configuration.StandardSequences.MagneticField_cff') process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') # Rerun tau ID process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove( process.pfRecoTauTagInfoProducer) process.recoTauClassicHPSSequence.remove( process.ak5PFJetTracksAssociatorAtVertex) assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] # Don't build junky taus below 19 GeV process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17) process.tuplize += process.recoTauClassicHPSSequence ## Run rho computation. Only necessary in 42X if cmssw_major_version() == 4: # This function call can klobber everything if it isn't done # before the other things are attached to the process, so do it now. # The klobbering would occur through usePFIso->setupPFIso->_loadPFBRECO from CommonTools.ParticleFlow.Tools.pfIsolation import _loadPFBRECO _loadPFBRECO(process) process.load("RecoJets.Configuration.RecoPFJets_cff") process.kt6PFJets.Rho_EtaMax = cms.double(4.4) process.kt6PFJets.doRhoFastjet = True process.tuplize += process.kt6PFJets # In 4_X we have to rerun ak5PFJets with area computation enabled. if cmssw_major_version() == 4: process.load("RecoJets.Configuration.RecoPFJets_cff") process.ak5PFJets.doAreaFastjet = True process.tuplize += process.ak5PFJets # Only keep the new ak5PFJets output_commands.append('*_ak5PFJets_*_%s' % process.name_()) else: # Just keep the normal ones output_commands.append('*_ak5PFJets_*_*') # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) #alter the photon matching to accept various fakes # and sort matches by d-pt-rel if isMC: process.photonMatch = cms.EDProducer( "MCMatcherByPt", src=cms.InputTag("photons"), maxDPtRel=cms.double(100.0), mcPdgId=cms.vint32(), mcStatus=cms.vint32(1), resolveByMatchQuality=cms.bool(False), maxDeltaR=cms.double(0.3), checkCharge=cms.bool(False), resolveAmbiguities=cms.bool(True), matched=cms.InputTag("genParticles") ) # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") if cmssw_major_version() == 4: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID42X + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources42X else: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID5YX + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources5YX process.electronMatch.checkCharge = cms.bool(False) process.patElectrons.embedTrack = False process.patElectrons.embedPFCandidate = False process.patElectrons.embedGsfElectronCore = False process.patElectrons.embedSuperCluster = True # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False process.patPhotons.embedGenMatch = False # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', ] # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=False, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options ) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False #process.patJetCorrFactors.useRho = True ## Let's use the same rho as in the TauID, so we don't need to do it twice. #process.patJetCorrFactors.rho = cms.InputTag( #"kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('*_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") process.patJetGarbageRemoval.cut = 'pt > 12' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") # Electron Energy Regression and Calibrations process.load( "EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi") process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi") #setup the energy regression for the specific dataset if kwargs['eleReg']: print "-- Applying Electron Regression and Calibration --" process.customizeElectronSequence += process.eleRegressionEnergy process.customizeElectronSequence += process.calibratedPatElectrons process.eleRegressionEnergy.energyRegressionType = cms.uint32(2) process.calibratedPatElectrons.correctionsType = cms.int32(2) if isMC: process.calibratedPatElectrons.inputDataset = cms.string( "Summer12_LegacyPaper") else: process.calibratedPatElectrons.inputDataset = cms.string( "22Jan2013ReReco") process.calibratedPatElectrons.combinationType = cms.int32(3) process.calibratedPatElectrons.lumiRatio = cms.double(1.0) process.calibratedPatElectrons.synchronization = cms.bool(True) process.calibratedPatElectrons.isMC = cms.bool(isMC == 1) process.calibratedPatElectrons.verbose = cms.bool(False) final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons", # Some of the EGamma modules have non-standard src InputTags, # specify them here. ("src", "inputPatElectronsTag", "inputElectronsTag") ) process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) # Define cleanPatElectrons input collection process.cleanPatElectrons.src = final_electron_collection process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") # Require all taus to pass decay mode finding and have high PT process.patTauGarbageRemoval.cut = cms.string( "pt > 17 && abs(eta) < 2.5 && tauID('decayModeFinding')") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Cuts already applied by the garbage removal process.cleanPatTaus.preselection = '' process.cleanPatTaus.finalCut = '' # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #setup PHOSPHOR for a specific dataset if cmssw_major_version() == 4: # for now 2011 = CMSSW42X process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011) else: # 2012 is 5YX process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012) process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC)) #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection # We cut out a lot of the junky taus and jets - but we need these # to correctly apply the MET uncertainties. So, let's make a # non-cleaned version of the jet and tau sequence. process.jetsForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'ForMETSyst') process.tausForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeTauSequence, 'ForMETSyst') # Don't apply any cut for these process.patTauGarbageRemovalForMETSyst.cut = '' process.patJetGarbageRemovalForMETSyst.cut = '' process.tuplize += process.jetsForMetSyst process.tuplize += process.tausForMetSyst # We have to make our clone of cleanPatTaus separately, since e/mu # cleaning is applied - therefore it isn't in the customizeTausSequence. process.cleanPatTausForMETSyst = process.cleanPatTaus.clone( src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst")) process.cleanPatTausForMETSyst.preselection = '' process.cleanPatTausForMETSyst.finalCut = '' process.patTausEmbedJetInfoForMETSyst.jetSrc = \ final_jet_collection.value() + "ForMETSyst" process.tuplize += process.cleanPatTausForMETSyst # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence output_commands.append('*_%s_*_*' % final_met_collection.value()) # Make a version with the MVA MET reconstruction method process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff") process.tuplize += process.pfMEtMVAsequence mva_met_sequence = helpers.cloneProcessingSnippet( process, process.customizeMETSequence, "MVA") final_mvamet_collection = chain_sequence( mva_met_sequence, "patMEtMVA") process.tuplize += mva_met_sequence output_commands.append('*_%s_*_*' % final_mvamet_collection.value()) # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # We can drop to jet and tau MET specific products. They were only used for # computation of the MET numbers. output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string( 'pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') trigtools.switchOnTrigger(process) #configure the PAT trigger if kwargs['HLTprocess']: process.patTrigger.processName = cms.string(kwargs['HLTprocess']) process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess']) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'pfmet': final_met_collection, 'mvamet': final_mvamet_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag'], zzMode=kwargs.get('zzMode', False)) return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): ''' Core function for PATTuple production ''' #fix argparser output isMC = bool(isMC) ######################## ## ## ## PATTuple content ## ## ## ######################## # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_gsfElectrons_*_*', '*_gsfElectronCores_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', # for zz muons '*_photonCore_*_*', '*_boostedFsrPhotons_*_*', # for Zmumu -> embedded samples # https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit '*_generalTracksORG_*_EmbeddedRECO', '*_electronGsfTracksORG_*_EmbeddedRECO', 'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN', 'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO', 'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO', 'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') ######################## ## ## ## PAT ## ## ## ######################## # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence ######################## ## GEN ## ######################## # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False process.patPhotons.embedGenMatch = False if not isMC: coreTools.runOnData(process) ######################## ## MUONS ## ######################## # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence(process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) ######################## ## TAUS ## ######################## # Use HPS taus tautools.switchToPFTauHPS( process) #this NEEDS a sequence called patDefaultSequence # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") # Require all taus to pass decay mode finding and have high PT process.patTauGarbageRemoval.cut = cms.string( "pt > 17 && abs(eta) < 2.5 && tauID('decayModeFindingNewDMs')") final_tau_collection = chain_sequence(process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Cuts already applied by the garbage removal process.cleanPatTaus.preselection = '' process.cleanPatTaus.finalCut = '' ######################## ## ELECTRONS ## ######################## # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") if cmssw_major_version() == 4: process.patDefaultSequence.replace( process.patElectrons, process.recoElectronID42X + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources42X else: process.patDefaultSequence.replace( process.patElectrons, process.recoElectronID5YX + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources5YX process.electronMatch.checkCharge = cms.bool(False) process.patElectrons.embedTrack = False process.patElectrons.embedPFCandidate = False process.patElectrons.embedGsfElectronCore = False process.patElectrons.embedSuperCluster = True # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") # Electron Energy Regression and Calibrations process.load( "EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi") process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi") #setup the energy regression for the specific dataset if kwargs['eleReg']: print "-- Applying Electron Regression and Calibration --" process.customizeElectronSequence += process.eleRegressionEnergy process.customizeElectronSequence += process.calibratedPatElectrons process.eleRegressionEnergy.energyRegressionType = cms.uint32(2) process.calibratedPatElectrons.correctionsType = cms.int32(2) if isMC: process.calibratedPatElectrons.inputDataset = cms.string( "Summer12_LegacyPaper") else: process.calibratedPatElectrons.inputDataset = cms.string( "22Jan2013ReReco") process.calibratedPatElectrons.combinationType = cms.int32(3) process.calibratedPatElectrons.lumiRatio = cms.double(1.0) process.calibratedPatElectrons.synchronization = cms.bool(True) process.calibratedPatElectrons.isMC = cms.bool(isMC == 1) process.calibratedPatElectrons.verbose = cms.bool(False) final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons", # Some of the EGamma modules have non-standard src InputTags, # specify them here. ("src", "inputPatElectronsTag", "inputElectronsTag")) #process.tuplize += process.customizeElectronSequence #why do we need this? process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) # Define cleanPatElectrons input collection process.cleanPatElectrons.src = final_electron_collection # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10"), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) ######################## ## JETS ## ######################## # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # tmp # define the b-tag squences for offline reconstruction process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff") process.load("RecoBTau.JetTagComputer.combinedMVA_cff") process.load('RecoVertex/AdaptiveVertexFinder/inclusiveVertexing_cff') process.load('RecoBTag/SecondaryVertex/bToCharmDecayVertexMerger_cfi') #process.load("PhysicsTools.PatAlgos.patSequences_cff") # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos', 'inclusiveSecondaryVertexFinderFilteredTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'trackCountingHighPurBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'simpleSecondaryVertexHighPurBJetTags', 'simpleInclusiveSecondaryVertexHighEffBJetTags', 'simpleInclusiveSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', 'jetBProbabilityBJetTags', 'jetProbabilityBJetTags', ] #Avoid embedding process.patJets.embedPFCandidates = True process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = True process.patJets.addAssociatedTracks = True process.patJets.embedGenPartonMatch = True # Add AK5chs PFJets jettools.addJetCollection(process, cms.InputTag('ak5PFchsJets'), algoLabel="AK5", typeLabel="PFchs", doJTA=True, jetCorrLabel=('AK5PFchs', jec), doType1MET=False, doL1Cleaning=False, doL1Counters=False, genJetCollection=cms.InputTag('ak5GenJets'), doJetID=True, **btag_options) # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=True, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options) # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") helpers.cloneProcessingSnippet(process, process.customizeJetSequence, 'AK5PFchs') process.patJetGarbageRemoval.cut = 'pt > 12' final_jet_collection = chain_sequence(process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # process.customizeJetSequence += process.btagging # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) process.customizeJetSequenceAK5PFchs.remove(process.patJetsPUIDAK5PFchs) process.customizeJetSequenceAK5PFchs.remove( process.pileupJetIdProducerAK5PFchs) process.patJetGarbageRemovalAK5PFchs.cut = 'pt > 20' process.patJetCorrFactorsAK5PFchs.payload = cms.string('AK5PFchs') final_jetchs_collection = chain_sequence( process.customizeJetSequenceAK5PFchs, "patJetsAK5PFchs") process.customizeJetSequenceAK5PFchs.insert(0, process.patJetsAK5PFchs) # Make it a "complete" sequence process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5PFchs # We can't mess up the selected pat jets because the taus use them. process.selectedPatJetsAK5PFchs.src = final_jetchs_collection process.selectedPatJetsAK5chsPF = process.selectedPatJetsAK5PFchs.clone( ) #that's what we keep process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5chsPF process.patDefaultSequence.replace(process.patJetsAK5PFchs, process.customizeJetSequenceAK5PFchs) output_commands.append('*_selectedPatJets_*_*') output_commands.append('*_selectedPatJetsAK5chsPF_*_*') output_commands.append('*SecondaryVertexTagInfo*_*_*_*') output_commands.append('*TrackIPTagInfo*_*_*_*') output_commands.append('*SoftLeptonTagInfo*_*_*_*') output_commands.append('*_ak5PFJets_*_*') output_commands.append('*_ak5PFchsJets_*_*') ######################## ## MET ## ######################## # Use PFMEt mettools.addPfMET(process) # We cut out a lot of the junky taus and jets - but we need these # to correctly apply the MET uncertainties. So, let's make a # non-cleaned version of the jet and tau sequence. process.jetsForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'ForMETSyst') process.tausForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeTauSequence, 'ForMETSyst') # Don't apply any cut for these process.patTauGarbageRemovalForMETSyst.cut = '' process.patJetGarbageRemovalForMETSyst.cut = '' process.tuplize += process.jetsForMetSyst process.tuplize += process.tausForMetSyst # We have to make our clone of cleanPatTaus separately, since e/mu # cleaning is applied - therefore it isn't in the customizeTausSequence. process.cleanPatTausForMETSyst = process.cleanPatTaus.clone( src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst")) process.cleanPatTausForMETSyst.preselection = '' process.cleanPatTausForMETSyst.finalCut = '' process.patTausEmbedJetInfoForMETSyst.jetSrc = \ final_jet_collection.value() + "ForMETSyst" process.tuplize += process.cleanPatTausForMETSyst # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") final_met_collection = chain_sequence(process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence process.patMETsPF.addGenMET = bool(isMC) output_commands.append('*_%s_*_*' % final_met_collection.value()) # Make a version with the MVA MET reconstruction method process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff") process.tuplize += process.pfMEtMVAsequence mva_met_sequence = helpers.cloneProcessingSnippet( process, process.customizeMETSequence, "MVA") final_mvamet_collection = chain_sequence(mva_met_sequence, "patMEtMVA") process.tuplize += mva_met_sequence output_commands.append('*_%s_*_*' % final_mvamet_collection.value()) # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # We can drop to jet and tau MET specific products. They were only used for # computation of the MET numbers. output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s' % process.name_()) ######################## ## PHOTONS ## ######################## #alter the photon matching to accept various fakes # and sort matches by d-pt-rel if isMC: process.photonMatch = cms.EDProducer( "MCMatcherByPt", src=cms.InputTag("photons"), maxDPtRel=cms.double(100.0), mcPdgId=cms.vint32(), mcStatus=cms.vint32(1), resolveByMatchQuality=cms.bool(False), maxDeltaR=cms.double(0.3), checkCharge=cms.bool(False), resolveAmbiguities=cms.bool(True), matched=cms.InputTag("genParticles")) # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #setup PHOSPHOR for a specific dataset if cmssw_major_version() == 4: # for now 2011 = CMSSW42X process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011) else: # 2012 is 5YX process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012) process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC)) #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection ######################## ## TRIGGER ## ######################## trigtools.switchOnTrigger(process) #configure the PAT trigger if kwargs['HLTprocess']: process.patTrigger.processName = cms.string(kwargs['HLTprocess']) process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess']) ######################## ## -------------- ## ######################## output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') ######################## ## ## ## FSA ## ## ## ######################## # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'pfmet': final_met_collection, 'mvamet': final_mvamet_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag'], zzMode=kwargs.get('zzMode', False)) return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ # '*', '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsCentralHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', #for zz muons '*_photonCore_*_*', # for Zmumu -> embedded samples '*_generator_weight_*', # 2k11 "GenFilterInfo_generator_minVisPtFilter_*", #2k12 '*_genDaughters_*_*', '*_boosted*_*_*', '*_tmfTracks_*_*', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex_*_*') output_commands.append('*_selectPrimaryVerticesQuality_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), Rho_EtaMax=cms.double(2.5), Ghost_EtaMax=cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Standard services process.load('Configuration.StandardSequences.Services_cff') # tack on seeds for FSA PATTuple modules add_fsa_random_seeds(process) if cmssw_major_version() == 5 and cmssw_minor_version() >= 3: process.load('Configuration.Geometry.GeometryIdeal_cff') else: process.load('Configuration.StandardSequences.GeometryIdeal_cff') process.load('Configuration.StandardSequences.MagneticField_cff') process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') # Rerun tau ID if cmssw_major_version() == 4: process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove( process.pfRecoTauTagInfoProducer) process.recoTauClassicHPSSequence.remove( process.ak5PFJetTracksAssociatorAtVertex) assert (process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] # Don't build junky taus below 19 GeV process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17) process.tuplize += process.recoTauClassicHPSSequence else: # We can run less tau stuff in 52, since HPS taus already built. process.load("RecoTauTag.Configuration.updateHPSPFTaus_cff") process.tuplize += process.updateHPSPFTaus ## Run rho computation. Only necessary in 42X if cmssw_major_version() == 4: from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets kt6PFJets.Rho_EtaMax = cms.double(4.4) kt6PFJets.doRhoFastjet = True process.kt6PFJets = kt6PFJets process.tuplize += process.kt6PFJets # In 4_X we have to rerun ak5PFJets with area computation enabled. if cmssw_major_version() == 4: process.load("RecoJets.Configuration.RecoPFJets_cff") process.ak5PFJets.doAreaFastjet = True process.tuplize += process.ak5PFJets # Only keep the new ak5PFJets output_commands.append('*_ak5PFJets_*_%s' % process.name_()) else: # Just keep the normal ones output_commands.append('*_ak5PFJets_*_*') # In the embedded samples, we need to re-run the b-tagging if kwargs['embedded']: process.load('RecoBTag/Configuration/RecoBTag_cff') process.load('RecoJets/JetAssociationProducers/ak5JTA_cff') process.ak5JetTracksAssociatorAtVertex.jets = cms.InputTag("ak5PFJets") process.ak5JetTracksAssociatorAtVertex.tracks = cms.InputTag( "tmfTracks") process.tuplize += process.ak5JetTracksAssociatorAtVertex process.tuplize += process.btagging # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") process.tuplize += process.recoElectronID process.patElectrons.electronIDSources = process.electronIDSources process.patElectrons.embedTrack = True # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', ] # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=False, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False #process.patJetCorrFactors.useRho = True ## Let's use the same rho as in the TauID, so we don't need to do it twice. #process.patJetCorrFactors.rho = cms.InputTag( #"kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('*_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") # We have to keep all jets (for the MVA MET...) process.patJetGarbageRemoval.cut = 'pt > 0' final_jet_collection = chain_sequence(process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons") process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) process.cleanPatElectrons.src = final_electron_collection #setup the energy regression for the specific dataset process.patElectronEnergyCorrections.isMC = cms.bool(bool(isMC)) process.patElectronEnergyCorrections.isAOD = \ cms.bool(bool(kwargs['isAOD'])) process.patElectronEnergyCorrections.dataSet = \ cms.string(kwargs['calibrationTarget']) process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence(process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") final_tau_collection = chain_sequence(process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Apply a loose preselection process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & pt > 17' # Don't apply any "final" cut process.cleanPatTaus.finalCut = '' # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") final_met_collection = chain_sequence(process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10"), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') output_commands.append('*_%s_*_*' % final_met_collection.value()) trigtools.switchOnTrigger(process) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'met': final_met_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag']) return process.tuplize, output_commands
def CompactSkim(process, inFileNames, outFileName, Global_Tag='auto:run2_mc', MC=True, Filter=True): process.load('Configuration.StandardSequences.Services_cff') process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') process.load('FWCore.MessageService.MessageLogger_cfi') process.load('Configuration.EventContent.EventContent_cff') process.load('Configuration.StandardSequences.GeometryRecoDB_cff') process.load( 'Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff') process.load('Configuration.StandardSequences.EndOfProcess_cff') process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff' ) process.MessageLogger.cerr.FwkReport.reportEvery = 100 process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(False)) process.options.allowUnscheduled = cms.untracked.bool(True) process.source = cms.Source('PoolSource', fileNames=cms.untracked.vstring(inFileNames)) process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1)) from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, Global_Tag, '') # make patCandidates, select and clean them process.load('PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff') process.load( 'PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff') process.load('PhysicsTools.PatAlgos.cleaningLayer1.cleanPatCandidates_cff') process.patMuons.embedTrack = True process.selectedPatMuons.cut = cms.string( 'muonID(\"TMOneStationTight\")' ' && abs(innerTrack.dxy) < 0.3' ' && abs(innerTrack.dz) < 20.' ' && innerTrack.hitPattern.trackerLayersWithMeasurement > 5' ' && innerTrack.hitPattern.pixelLayersWithMeasurement > 0' ' && innerTrack.quality(\"highPurity\")') #make patTracks from PhysicsTools.PatAlgos.tools.trackTools import makeTrackCandidates makeTrackCandidates( process, label='TrackCands', # output collection tracks=cms.InputTag('generalTracks'), # input track collection particleType='pi+', # particle type (for assigning a mass) preselection='pt > 0.7', # preselection cut on candidates selection='pt > 0.7', # selection on PAT Layer 1 objects isolation={}, # isolations to use (set to {} for None) isoDeposits=[], mcAs=None # replicate MC match as the one used for Muons ) process.patTrackCands.embedTrack = True # dimuon = Onia2MUMU process.load('HeavyFlavorAnalysis.Onia2MuMu.onia2MuMuPAT_cfi') process.onia2MuMuPAT.muons = cms.InputTag('cleanPatMuons') process.onia2MuMuPAT.primaryVertexTag = cms.InputTag( 'offlinePrimaryVertices') process.onia2MuMuPAT.beamSpotTag = cms.InputTag('offlineBeamSpot') process.onia2MuMuPATCounter = cms.EDFilter( 'CandViewCountFilter', src=cms.InputTag('onia2MuMuPAT'), minNumber=cms.uint32(1), filter=cms.bool(True)) # reduce MC genParticles a la miniAOD process.load('PhysicsTools.PatAlgos.slimming.genParticles_cff') process.packedGenParticles.inputVertices = cms.InputTag( 'offlinePrimaryVertices') # make photon candidate conversions for P-wave studies process.load( 'HeavyFlavorAnalysis.Onia2MuMu.OniaPhotonConversionProducer_cfi') # add v0 with tracks embed process.load('HeavyFlavorAnalysis.Onia2MuMu.OniaAddV0TracksProducer_cfi') # Pick branches you want to keep SlimmedEventContent = [ 'keep recoVertexs_offlinePrimaryVertices_*_*', 'keep *_inclusiveSecondaryVertices_*_*', 'keep *_offlineBeamSpot_*_*', 'keep *_TriggerResults_*_HLT', 'keep *_gtDigis_*_RECO', 'keep *_cleanPatTrackCands_*_*', 'keep *_PhotonCandidates_*_*', 'keep *_onia2MuMuPAT_*_*', 'keep *_generalV0Candidates_*_*', 'keep *_oniaV0Tracks_*_*', 'keep PileupSummaryInfos_*_*_*' ] if not MC: from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process, outputModules=[]) else: SlimmedEventContent += [ 'keep patPackedGenParticles_packedGenParticles_*_*', 'keep recoGenParticles_prunedGenParticles_*_*', 'keep GenFilterInfo_*_*_*', 'keep GenEventInfoProduct_generator_*_*', 'keep GenRunInfoProduct_*_*_*' ] process.FilterOutput = cms.Path(process.onia2MuMuPATCounter) process.out = cms.OutputModule( 'PoolOutputModule', fileName=cms.untracked.string(outFileName), outputCommands=cms.untracked.vstring('drop *', *SlimmedEventContent), SelectEvents=cms.untracked.PSet( SelectEvents=cms.vstring('FilterOutput')) if Filter else cms.untracked.PSet()) process.outpath = cms.EndPath(process.out)
process.load('PhysicsTools.PatAlgos.producersLayer1.metProducer_cff') process.load('PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi') process.patCandidates = cms.Sequence(process.makePatJets + process.makePatMETs) process.selectedPatCandidates = cms.Sequence(process.selectedPatJets) process.patDefaultSequence = cms.Sequence(process.patCandidates * process.selectedPatCandidates) process.load('RecoJets.Configuration.RecoPFJets_cff') from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection, runBTagging from PhysicsTools.PatAlgos.tools.coreTools import runOnData #---- Choose which jet correction levels to apply jetcorrlabels = ['L1FastJet', 'L2Relative', 'L3Absolute'] if isData: #---- For data we need to remove generator-level matching processes runOnData(process, ['Jets', 'METs'], "", None, []) jetcorrlabels.append('L2L3Residual') #---- Configure the addJetCollection tool #---- This process will make corrected jets with b-tagging included, and will make Type1-corrected MET process.ak5PFJets.doAreaFastjet = True addJetCollection( process, cms.InputTag('ak5PFJets'), 'AK5', 'PFCorr', doJTA=True, doBTagging=True, jetCorrLabel=('AK5PF', cms.vstring(jetcorrlabels)), doType1MET=True, doL1Cleaning=False,
def miniAOD_customizeData(process): from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process, outputModules = [] )
## particleType = 'pi+', # particle type (for assigning a mass) particleType = 'K+', # particle type (for assigning a mass) preselection = 'pt > 0.4', # preselection cut on candidates selection = 'pt > 0.4', # selection on PAT Layer 1 objects isolation = {}, # isolations to use (set to {} for None) isoDeposits = [], mcAs = None # replicate MC match as the one used for Muons ) process.load('PhysicsTools.PatAlgos.slimming.genParticles_cff') process.packedGenParticles.inputVertices = cms.InputTag('offlinePrimaryVertices') from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process, outputModules = [] ) process.ntuple = cms.EDAnalyzer( 'BsToPhiMuMu', OutputFileName = cms.string("BsToPhiMuMu_2016.root"), BuildBsToPhiMuMu = cms.untracked.bool(True), MuonMass = cms.untracked.double(0.10565837), MuonMassErr = cms.untracked.double(3.5e-9), KaonMass = cms.untracked.double(0.493677), KaonMassErr = cms.untracked.double(1.6e-5), BsMass = cms.untracked.double(5.36677), ## put the Bs Mass (pdg value) # labels GenParticlesLabel = cms.InputTag("genParticles"),
if not useHFCandidates: runMETCorrectionsAndUncertainties( process, #isData=runOnData, pfCandColl=cms.InputTag("noHFCands"), reclusterJets=True, #needed for NoHF recoMetFromPFCs=True, #needed for NoHF postfix="NoHF") if redoPuppi: from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process) runMETCorrectionsAndUncertainties( process, #isData=runOnData, pfCandColl=cms.InputTag("puppiForMET"), recoMetFromPFCs=True, reclusterJets=True, jetFlavor="AK4PFPuppi", postfix="Puppi") if runOnData: from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process) process.out.outputCommands = cms.untracked.vstring("keep *_patPFMet*_*_*", ) process.out.fileName = cms.untracked.string('corMETMiniAOD.root') process.MINIAODSIMoutput_step = cms.EndPath(process.out)
def CompactSkim(process,inFileNames,outFileName,Global_Tag='auto:run2_mc',MC=True,Filter=True): patAlgosToolsTask = getPatAlgosToolsTask(process) process.load('Configuration.StandardSequences.Services_cff') process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') process.load('FWCore.MessageService.MessageLogger_cfi') process.load('Configuration.EventContent.EventContent_cff') process.load('Configuration.StandardSequences.GeometryRecoDB_cff') process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff') process.load('Configuration.StandardSequences.EndOfProcess_cff') patAlgosToolsTask.add(process.MEtoEDMConverter) process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff') process.MessageLogger.cerr.FwkReport.reportEvery = 100 process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) ) process.source = cms.Source('PoolSource', fileNames = cms.untracked.vstring(inFileNames)) process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, Global_Tag, '') # make patCandidates, select and clean them process.load('PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff') patAlgosToolsTask.add(process.patCandidatesTask) process.load('PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff') patAlgosToolsTask.add(process.selectedPatCandidatesTask) process.load('PhysicsTools.PatAlgos.cleaningLayer1.cleanPatCandidates_cff') patAlgosToolsTask.add(process.cleanPatCandidatesTask) process.patMuons.embedTrack = True process.selectedPatMuons.cut = cms.string('muonID(\"TMOneStationTight\")' ' && abs(innerTrack.dxy) < 0.3' ' && abs(innerTrack.dz) < 20.' ' && innerTrack.hitPattern.trackerLayersWithMeasurement > 5' ' && innerTrack.hitPattern.pixelLayersWithMeasurement > 0' ' && innerTrack.quality(\"highPurity\")' ) #make patTracks from PhysicsTools.PatAlgos.tools.trackTools import makeTrackCandidates makeTrackCandidates(process, label = 'TrackCands', # output collection tracks = cms.InputTag('generalTracks'), # input track collection particleType = 'pi+', # particle type (for assigning a mass) preselection = 'pt > 0.7', # preselection cut on candidates selection = 'pt > 0.7', # selection on PAT Layer 1 objects isolation = {}, # isolations to use (set to {} for None) isoDeposits = [], mcAs = None # replicate MC match as the one used for Muons ) process.patTrackCands.embedTrack = True # dimuon = Onia2MUMU process.load('HeavyFlavorAnalysis.Onia2MuMu.onia2MuMuPAT_cfi') patAlgosToolsTask.add(process.onia2MuMuPAT) process.onia2MuMuPAT.muons=cms.InputTag('cleanPatMuons') process.onia2MuMuPAT.primaryVertexTag=cms.InputTag('offlinePrimaryVertices') process.onia2MuMuPAT.beamSpotTag=cms.InputTag('offlineBeamSpot') process.onia2MuMuPATCounter = cms.EDFilter('CandViewCountFilter', src = cms.InputTag('onia2MuMuPAT'), minNumber = cms.uint32(1), filter = cms.bool(True) ) # reduce MC genParticles a la miniAOD process.load('PhysicsTools.PatAlgos.slimming.genParticles_cff') patAlgosToolsTask.add(process.genParticlesTask) process.packedGenParticles.inputVertices = cms.InputTag('offlinePrimaryVertices') # make photon candidate conversions for P-wave studies process.load('HeavyFlavorAnalysis.Onia2MuMu.OniaPhotonConversionProducer_cfi') patAlgosToolsTask.add(process.PhotonCandidates) # add v0 with tracks embed process.load('HeavyFlavorAnalysis.Onia2MuMu.OniaAddV0TracksProducer_cfi') patAlgosToolsTask.add(process.oniaV0Tracks) # Pick branches you want to keep SlimmedEventContent = [ 'keep recoVertexs_offlinePrimaryVertices_*_*', 'keep *_inclusiveSecondaryVertices_*_*', 'keep *_offlineBeamSpot_*_*', 'keep *_TriggerResults_*_HLT', 'keep *_gtDigis_*_RECO', 'keep *_cleanPatTrackCands_*_*', 'keep *_PhotonCandidates_*_*', 'keep *_onia2MuMuPAT_*_*', 'keep *_generalV0Candidates_*_*', 'keep *_oniaV0Tracks_*_*', 'keep PileupSummaryInfos_*_*_*' ] if not MC: from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process, outputModules = [] ) else : SlimmedEventContent += [ 'keep patPackedGenParticles_packedGenParticles_*_*', 'keep recoGenParticles_prunedGenParticles_*_*', 'keep GenFilterInfo_*_*_*', 'keep GenEventInfoProduct_generator_*_*', 'keep GenRunInfoProduct_*_*_*' ] process.FilterOutput = cms.Path(process.onia2MuMuPATCounter) process.out = cms.OutputModule('PoolOutputModule', fileName = cms.untracked.string(outFileName), outputCommands = cms.untracked.vstring('drop *', *SlimmedEventContent), SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('FilterOutput')) if Filter else cms.untracked.PSet() ) process.outpath = cms.EndPath(process.out, patAlgosToolsTask)
def miniAOD_customizeData(process): from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData( process, outputModules = [] ) process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cff") task = getPatAlgosToolsTask(process) task.add(process.ctppsLocalTrackLiteProducer)
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_trackCandidates_*_*', '*_gsfTrackCandidates_*_*', #'*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5PFJets_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex_*_*') output_commands.append('*_selectPrimaryVerticesQuality_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Rho_EtaMax = cms.double(2.5), Ghost_EtaMax = cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Rerun tau-ID process.load('Configuration/StandardSequences/Services_cff') process.load('Configuration/StandardSequences/GeometryIdeal_cff') process.load('Configuration/StandardSequences/MagneticField_cff') process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff') process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove(process.pfRecoTauTagInfoProducer) assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] process.tuplize += process.recoTauClassicHPSSequence ## Run rho computation #from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets #kt6PFJets.Rho_EtaMax = cms.double(2.5) #kt6PFJets.doRhoFastjet = True #process.kt6PFJets = kt6PFJets #process.tuplize += process.kt6PFJets # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Custom veto cones process.elPFIsoValuePU04PFIdPFIso.deposits.vetos = cms.vstring() process.elPFIsoValueChargedAll04PFIdPFIso.deposits.vetos = cms.vstring( 'EcalBarrel:ConeVeto(0.01)','EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") process.tuplize += process.recoElectronID process.patElectrons.electronIDSources = process.electronIDSources process.patElectrons.embedTrack = True # Run EGamma electron energy calibration process.load("EgammaCalibratedGsfElectrons.CalibratedElectronProducers.calibratedGsfElectrons_cfi") process.RandomNumberGeneratorService.calibratedGsfElectrons = cms.PSet( initialSeed = cms.untracked.uint32(1), # A frickin billion engineName = cms.untracked.string('TRandom3') ) process.calibratedGsfElectrons.inputDataset = kwargs['dataset'] process.calibratedGsfElectrons.isMC = bool(isMC) process.calibratedGsfElectrons.isAOD = True process.calibratedGsfElectrons.updateEnergyError = cms.bool(True) # Run a sanity check on the calibration configuration. from FinalStateAnalysis.PatTools.electrons.patElectronEmbedCalibratedGsf_cfi \ import validate_egamma_calib_config validate_egamma_calib_config(process) process.tuplize += process.calibratedGsfElectrons # Keep the calibratedGsfElectrons - we embed refs to this into the # pat::Electrons output_commands.append('*_calibratedGsfElectrons_*_*') # Now run PAT process.tuplize += process.patDefaultSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False # Use PFJets and turn on JEC jec = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ] if not isMC: jec.extend([ 'L2L3Residual' ]) # Use AK5 PFJets jettools.switchJetCollection(process, cms.InputTag('ak5PFJets'), doJTA = False, doBTagging = True, jetCorrLabel = ('AK5PF', jec), #jetCorrLabel = None, doType1MET = False, doJetID = True, genJetCollection = cms.InputTag("ak5GenJets")) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False process.patJetCorrFactors.useRho = True # Let's use the same rho as in the TauID, so we don't need to do it twice. process.patJetCorrFactors.rho = cms.InputTag( "kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('patJets_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") # We have to keep all jets (for the MVA MET...) process.patJetGarbageRemoval.cut = 'pt > 0' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons") process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) process.cleanPatElectrons.src = final_electron_collection # The "effective area" calculation needs to know if it is data/mc, etc. process.patElectronMVAIsoEmbedding.target = kwargs['target'] process.patElectronEffectiveAreaEmbedder.target = kwargs['target'] process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection # The "effective area" calculation needs to know if it is data/mc, etc. process.patMuonMVAIdIsoEmbedding.target = kwargs['target'] process.patMuonEffectiveAreaEmbedder.target = kwargs['target'] process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Don't apply any prselections process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & (pt > 18 | userFloat("jetPt") > 18)' # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src = final_tau_collection, algorithm = cms.string("byDeltaR"), preselection = cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_%s_*_*' % final_met_collection.value()) #process.load("PhysicsTools.PatAlgos.triggerLayer1.triggerMatcher_cfi") #trigtools.switchOnTriggerMatchEmbedding(process) trigtools.switchOnTrigger(process) # Build the PATFinalStateEventObject process.load("FinalStateAnalysis.PatTools.finalStates.patFinalStateEventProducer_cfi") process.patFinalStateEventProducer.electronSrc = final_electron_collection process.patFinalStateEventProducer.muonSrc = cms.InputTag("cleanPatMuons") process.patFinalStateEventProducer.tauSrc = cms.InputTag("cleanPatTaus") process.patFinalStateEventProducer.jetSrc = cms.InputTag("selectedPatJets") process.patFinalStateEventProducer.metSrc = final_met_collection process.tuplize += process.patFinalStateEventProducer output_commands.append('*_patFinalStateEventProducer_*_*') process.patFinalStateEventProducer.puTag = cms.string(kwargs['puTag']) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Apply some loose PT cuts on the objects we use to create the final states # so the combinatorics don't blow up process.muonsForFinalStates = cms.EDFilter( "PATMuonRefSelector", src = cms.InputTag("cleanPatMuons"), cut = cms.string('pt > 4'), filter = cms.bool(False), ) process.electronsForFinalStates = cms.EDFilter( "PATElectronRefSelector", src = cms.InputTag("cleanPatElectrons"), cut = cms.string('abs(eta) < 2.5 & pt > 4'), filter = cms.bool(False), ) # Require that the PT of the jet (either corrected jet or tau) # to be greater than 17 process.tausForFinalStates = cms.EDFilter( "PATTauRefSelector", src = cms.InputTag("cleanPatTaus"), cut = cms.string('abs(eta) < 2.5 & pt > 17 & tauID("decayModeFinding")'), filter = cms.bool(False), ) process.selectObjectsForFinalStates = cms.Sequence( process.muonsForFinalStates + process.electronsForFinalStates + process.tausForFinalStates ) process.tuplize += process.selectObjectsForFinalStates # Now build all of our DiLeptons and TriLepton final states lepton_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates")), ('Tau', cms.InputTag("tausForFinalStates"))] #lepton_types = [('Elec', cms.InputTag("cleanPatElectrons")), #('Mu', cms.InputTag("cleanPatMuons")), #('Tau', cms.InputTag("cleanPatTaus"))] process.buildDiLeptons = cms.Sequence() process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStatesEmbedExtraCollections_cfi") # Build di-lepton pairs for dilepton in _combinatorics(lepton_types, 2): # Don't build two jet states if (dilepton[0][0], dilepton[1][0]) == ('Tau', 'Tau'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%sFinalStateProducer" % (dilepton[0][0], dilepton[1][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = dilepton[0][1], leg2Src = dilepton[1][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s" % (dilepton[0][0], dilepton[1][0]) setattr(process, producer_name + "Raw", producer) process.buildDiLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildDiLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = getattr(process, final_module_name.value()) final_module.setLabel(producer_name) setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) process.tuplize += process.buildDiLeptons # Build tri-lepton pairs process.buildTriLeptons = cms.Sequence() for trilepton in _combinatorics(lepton_types, 3): # Don't build three jet states if (trilepton[0][0], trilepton[1][0], trilepton[2][0]) == \ ('Tau', 'Tau', 'Tau'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%sFinalStateProducer" % (trilepton[0][0], trilepton[1][0], trilepton[2][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = trilepton[0][1], leg2Src = trilepton[1][1], leg3Src = trilepton[2][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s" % ( trilepton[0][0], trilepton[1][0], trilepton[2][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildTriLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildTriLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = getattr(process, final_module_name.value()) final_module.setLabel(producer_name) setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) process.tuplize += process.buildTriLeptons # Build 4 lepton final states process.buildQuadLeptons = cms.Sequence() for quadlepton in _combinatorics(lepton_types, 4): # Don't build states with more than 2 hadronic taus if [x[0] for x in quadlepton].count('Tau') > 2: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateProducer" % (quadlepton[0][0], quadlepton[1][0], quadlepton[2][0], quadlepton[3][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = quadlepton[0][1], leg2Src = quadlepton[1][1], leg3Src = quadlepton[2][1], leg4Src = quadlepton[3][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s%s" % ( quadlepton[0][0], quadlepton[1][0], quadlepton[2][0], quadlepton[3][0] ) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = getattr(process, final_module_name.value()) final_module.setLabel(producer_name) setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) process.tuplize += process.buildQuadLeptons # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 return process.tuplize, output_commands
else: # data process.output.fileName = 'miniAOD_TauReco_data.root' if reclusterJets: process.output.fileName = 'miniAOD_TauReco_ak4PFJets_data.root' process.out = cms.EndPath(process.output) ##### tauAtMiniTools.adaptTauToMiniAODReReco(reclusterJets) process.p = cms.Path( getattr(process, ("miniAODTausSequence" + postfix if not runBoosted else "miniAODTausSequenceBoosted" + postfix))) if runType == 'data': from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process, names=['Taus'], outputModules=[], postfix=(postfix if not runBoosted else 'Boosted' + postfix)) ##### process.load('FWCore.MessageService.MessageLogger_cfi') if process.maxEvents.input.value() > 10: process.MessageLogger.cerr.FwkReport.reportEvery = process.maxEvents.input.value( ) // 10 if process.maxEvents.input.value() > 10000 or process.maxEvents.input.value( ) < 0: process.MessageLogger.cerr.FwkReport.reportEvery = 1000 ##### process.options = dict( numberOfThreads=4, # numberOfThreads = 1,
filename=options.lumiFile).getVLuminosityBlockRange() if options.eventList != '': process.source.eventsToProcess = cms.untracked.VEventRange( re.split(',', options.eventList)) tau_collection = 'slimmedTaus' if options.rerunTauReco: tau_collection = 'selectedPatTaus' tauAtMiniTools.addTauReReco(process) tauAtMiniTools.adaptTauToMiniAODReReco(process, options.reclusterJets) if isData: from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process, names=['Taus'], outputModules=[]) process.combinatoricRecoTaus.builders[0].signalConeSize = cms.string( 'max(min(0.2, 4.528/(pt()^0.8982)), 0.03)') ## change to quantile 0.95 process.selectedPatTaus.cut = cms.string( 'pt > 18.' ) ## remove DMFinding filter (was pt > 18. && tauID(\'decayModeFindingNewDMs\')> 0.5) # include Phase2 specific configuration only after 11_0_X if isPhase2: tauIdConfig = importlib.import_module( 'RecoTauTag.RecoTau.tools.runTauIdMVA') updatedTauName = "slimmedTausNewID" tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, cms, updatedTauName=updatedTauName,
def configurePatTuple(process, isMC=True, **kwargs): ''' Core function for PATTuple production ''' #fix argparser output isMC = bool(isMC) ######################## ## ## ## PATTuple content ## ## ## ######################## # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_gsfElectrons_*_*', '*_gsfElectronCores_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', # for zz muons '*_photonCore_*_*', '*_boostedFsrPhotons_*_*', # for Zmumu -> embedded samples # https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit '*_generalTracksORG_*_EmbeddedRECO', '*_electronGsfTracksORG_*_EmbeddedRECO', 'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN', 'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO', 'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO', 'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') ######################## ## ## ## PAT ## ## ## ######################## # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence ######################## ## GEN ## ######################## # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False process.patPhotons.embedGenMatch = False if not isMC: coreTools.runOnData(process) ######################## ## MUONS ## ######################## # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) ######################## ## TAUS ## ######################## # Use HPS taus tautools.switchToPFTauHPS(process) #this NEEDS a sequence called patDefaultSequence # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") # Require all taus to pass decay mode finding and have high PT process.patTauGarbageRemoval.cut = cms.string( "pt > 17 && abs(eta) < 2.5 && tauID('decayModeFindingNewDMs')") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Cuts already applied by the garbage removal process.cleanPatTaus.preselection = '' process.cleanPatTaus.finalCut = '' ######################## ## ELECTRONS ## ######################## # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") if cmssw_major_version() == 4: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID42X + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources42X else: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID5YX + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources5YX process.electronMatch.checkCharge = cms.bool(False) process.patElectrons.embedTrack = False process.patElectrons.embedPFCandidate = False process.patElectrons.embedGsfElectronCore = False process.patElectrons.embedSuperCluster = True # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") # Electron Energy Regression and Calibrations process.load( "EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi") process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi") #setup the energy regression for the specific dataset if kwargs['eleReg']: print "-- Applying Electron Regression and Calibration --" process.customizeElectronSequence += process.eleRegressionEnergy process.customizeElectronSequence += process.calibratedPatElectrons process.eleRegressionEnergy.energyRegressionType = cms.uint32(2) process.calibratedPatElectrons.correctionsType = cms.int32(2) if isMC: process.calibratedPatElectrons.inputDataset = cms.string( "Summer12_LegacyPaper") else: process.calibratedPatElectrons.inputDataset = cms.string( "22Jan2013ReReco") process.calibratedPatElectrons.combinationType = cms.int32(3) process.calibratedPatElectrons.lumiRatio = cms.double(1.0) process.calibratedPatElectrons.synchronization = cms.bool(True) process.calibratedPatElectrons.isMC = cms.bool(isMC == 1) process.calibratedPatElectrons.verbose = cms.bool(False) final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons", # Some of the EGamma modules have non-standard src InputTags, # specify them here. ("src", "inputPatElectronsTag", "inputElectronsTag") ) #process.tuplize += process.customizeElectronSequence #why do we need this? process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) # Define cleanPatElectrons input collection process.cleanPatElectrons.src = final_electron_collection # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string( 'pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) ######################## ## JETS ## ######################## # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # tmp # define the b-tag squences for offline reconstruction process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff") process.load("RecoBTau.JetTagComputer.combinedMVA_cff") process.load('RecoVertex/AdaptiveVertexFinder/inclusiveVertexing_cff') process.load('RecoBTag/SecondaryVertex/bToCharmDecayVertexMerger_cfi') #process.load("PhysicsTools.PatAlgos.patSequences_cff") # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos', 'inclusiveSecondaryVertexFinderFilteredTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'trackCountingHighPurBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'simpleSecondaryVertexHighPurBJetTags', 'simpleInclusiveSecondaryVertexHighEffBJetTags', 'simpleInclusiveSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', 'jetBProbabilityBJetTags', 'jetProbabilityBJetTags', ] #Avoid embedding process.patJets.embedPFCandidates = True process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = True process.patJets.addAssociatedTracks = True process.patJets.embedGenPartonMatch = True # Add AK5chs PFJets jettools.addJetCollection( process, cms.InputTag('ak5PFchsJets'), algoLabel = "AK5", typeLabel = "PFchs", doJTA = True, jetCorrLabel = ('AK5PFchs', jec), doType1MET = False, doL1Cleaning = False, doL1Counters = False, genJetCollection = cms.InputTag('ak5GenJets'), doJetID = True, **btag_options ) # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=True, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options ) # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'AK5PFchs' ) process.patJetGarbageRemoval.cut = 'pt > 12' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # process.customizeJetSequence += process.btagging # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) process.customizeJetSequenceAK5PFchs.remove( process.patJetsPUIDAK5PFchs ) process.customizeJetSequenceAK5PFchs.remove( process.pileupJetIdProducerAK5PFchs ) process.patJetGarbageRemovalAK5PFchs.cut = 'pt > 20' process.patJetCorrFactorsAK5PFchs.payload = cms.string('AK5PFchs') final_jetchs_collection = chain_sequence( process.customizeJetSequenceAK5PFchs, "patJetsAK5PFchs") process.customizeJetSequenceAK5PFchs.insert(0, process.patJetsAK5PFchs) # Make it a "complete" sequence process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5PFchs # We can't mess up the selected pat jets because the taus use them. process.selectedPatJetsAK5PFchs.src = final_jetchs_collection process.selectedPatJetsAK5chsPF = process.selectedPatJetsAK5PFchs.clone() #that's what we keep process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5chsPF process.patDefaultSequence.replace(process.patJetsAK5PFchs, process.customizeJetSequenceAK5PFchs) output_commands.append('*_selectedPatJets_*_*') output_commands.append('*_selectedPatJetsAK5chsPF_*_*') output_commands.append('*SecondaryVertexTagInfo*_*_*_*') output_commands.append('*TrackIPTagInfo*_*_*_*') output_commands.append('*SoftLeptonTagInfo*_*_*_*') output_commands.append('*_ak5PFJets_*_*') output_commands.append('*_ak5PFchsJets_*_*') ######################## ## MET ## ######################## # Use PFMEt mettools.addPfMET(process) # We cut out a lot of the junky taus and jets - but we need these # to correctly apply the MET uncertainties. So, let's make a # non-cleaned version of the jet and tau sequence. process.jetsForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'ForMETSyst') process.tausForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeTauSequence, 'ForMETSyst') # Don't apply any cut for these process.patTauGarbageRemovalForMETSyst.cut = '' process.patJetGarbageRemovalForMETSyst.cut = '' process.tuplize += process.jetsForMetSyst process.tuplize += process.tausForMetSyst # We have to make our clone of cleanPatTaus separately, since e/mu # cleaning is applied - therefore it isn't in the customizeTausSequence. process.cleanPatTausForMETSyst = process.cleanPatTaus.clone( src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst")) process.cleanPatTausForMETSyst.preselection = '' process.cleanPatTausForMETSyst.finalCut = '' process.patTausEmbedJetInfoForMETSyst.jetSrc = \ final_jet_collection.value() + "ForMETSyst" process.tuplize += process.cleanPatTausForMETSyst # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence process.patMETsPF.addGenMET = bool(isMC) output_commands.append('*_%s_*_*' % final_met_collection.value()) # Make a version with the MVA MET reconstruction method process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff") process.tuplize += process.pfMEtMVAsequence mva_met_sequence = helpers.cloneProcessingSnippet( process, process.customizeMETSequence, "MVA") final_mvamet_collection = chain_sequence( mva_met_sequence, "patMEtMVA") process.tuplize += mva_met_sequence output_commands.append('*_%s_*_*' % final_mvamet_collection.value()) # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # We can drop to jet and tau MET specific products. They were only used for # computation of the MET numbers. output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s' % process.name_()) ######################## ## PHOTONS ## ######################## #alter the photon matching to accept various fakes # and sort matches by d-pt-rel if isMC: process.photonMatch = cms.EDProducer( "MCMatcherByPt", src=cms.InputTag("photons"), maxDPtRel=cms.double(100.0), mcPdgId=cms.vint32(), mcStatus=cms.vint32(1), resolveByMatchQuality=cms.bool(False), maxDeltaR=cms.double(0.3), checkCharge=cms.bool(False), resolveAmbiguities=cms.bool(True), matched=cms.InputTag("genParticles") ) # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #setup PHOSPHOR for a specific dataset if cmssw_major_version() == 4: # for now 2011 = CMSSW42X process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011) else: # 2012 is 5YX process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012) process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC)) #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection ######################## ## TRIGGER ## ######################## trigtools.switchOnTrigger(process) #configure the PAT trigger if kwargs['HLTprocess']: process.patTrigger.processName = cms.string(kwargs['HLTprocess']) process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess']) ######################## ## -------------- ## ######################## output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') ######################## ## ## ## FSA ## ## ## ######################## # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'pfmet': final_met_collection, 'mvamet': final_mvamet_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag'], zzMode=kwargs.get('zzMode', False)) return process.tuplize, output_commands
'abs(eta) < 2.5 && ' \ 'numberOfDaughters > 1 && ' \ 'neutralHadronEnergyFraction < 0.99 && ' \ 'neutralEmEnergyFraction < 0.99 && ' \ '(abs(eta) >= 2.4 || (chargedEmEnergyFraction < 0.99 && chargedHadronEnergyFraction > 0. && chargedMultiplicity > 0))' # The PAT producers need to know whether we're running on MC events or # data; for the latter, this next part is mainly to remove the MC # truth matching. (Each reconstructed PAT object stores a pointer to # the generator-level object that is its closest match, with matching # done in delta-R = sqrt((delta eta)^2 + (delta phi)^2; see # plugins/PAT2Ntuple.cc for an example of accessing these matches.) from PhysicsTools.PatAlgos.tools.coreTools import runOnData if not runOnMC: runOnData(process, names=['PFAll'], postfix='PF') # We remove PAT photons here because they are not fully commisssioned # in PF. (You could turn them on to check their performance.) This # also turns off a cleaning step, which in the default PAT workflow # tries to remove overlap between the physics object collections # (e.g. removing muons from being reconstructed as degenerate "jets"), # but this is not necessary with PF/the GED, especially with the top # projections described above enabled. from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects removeSpecificPATObjects(process, names=['Photons'], postfix='PF') # Now we configure the job to keep ttbar events in all three decay # modes. For hadronic, we will require that there be four # reconstructed jets (the main hadronic trigger requires this anyway).
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 miniAOD_customizeData(process): from PhysicsTools.PatAlgos.tools.coreTools import runOnData runOnData(process, outputModules=[])
def pat_tuple_process(runOnMC=True, suppress_stdout=True): process = cms.Process('PAT') process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(100)) process.source = cms.Source('PoolSource', fileNames = cms.untracked.vstring('/store/mc/Summer12_DR53X/TTJets_HadronicMGDecays_8TeV-madgraph/AODSIM/PU_S10_START53_V7A-v1/00001/FCAF3F92-5A16-E211-ACCC-E0CB4E19F95A.root' if runOnMC else '/store/data/Run2012B/MultiJet1Parked/AOD/05Nov2012-v2/10000/0003D331-5C49-E211-8210-00259020081C.root')) process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(False)) process.load('FWCore.MessageLogger.MessageLogger_cfi') process.MessageLogger.cerr.FwkReport.reportEvery = 1000000 process.MessageLogger.cerr.threshold = 'INFO' process.MessageLogger.categories.append('PATSummaryTables') process.MessageLogger.cerr.PATSummaryTables = cms.untracked.PSet(limit = cms.untracked.int32(-1)) for category in ['TwoTrackMinimumDistance']: process.MessageLogger.categories.append(category) setattr(process.MessageLogger.cerr, category, cms.untracked.PSet(limit=cms.untracked.int32(0))) process.load('Configuration.Geometry.GeometryIdeal_cff') process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag = 'START53_V27::All' if runOnMC else 'FT53_V21A_AN6::All' from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent process.out = cms.OutputModule('PoolOutputModule', fileName = cms.untracked.string('pat.root'), SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('p')), outputCommands = cms.untracked.vstring(*patEventContent), ) process.outp = cms.EndPath(process.out) process.load('JMTucker.Tools.PATTupleSelection_cfi') # Event cleaning, with MET cleaning recommendations from # https://twiki.cern.ch/twiki/bin/view/CMS/MissingETOptionalFilters process.load('HLTrigger.special.hltPhysicsDeclared_cfi') process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis' from DPGAnalysis.Skims.goodvertexSkim_cff import noscraping as FilterOutScraping process.FilterOutScraping = FilterOutScraping process.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi') process.goodOfflinePrimaryVertices.filter = cms.bool(True) process.load('RecoMET.METFilters.metFilters_cff') process.trackingFailureFilter.VertexSource = 'goodOfflinePrimaryVertices' # Instead of filtering out events at tupling time, schedule separate # paths for all the "good data" filters so that the results of them # get stored in a small TriggerResults::PAT object, which can be # accessed later. Make one path for each so they can be accessed # separately in the TriggerResults object; the "All" path that is the # product of all of the filters isn't necessary but it's nice for # convenience. process.eventCleaningAll = cms.Path() for name in process.jtupleParams.eventFilters.value(): negate = name.startswith('~') name = name.replace('~', '') filter_obj = getattr(process, name) if negate: filter_obj = ~filter_obj setattr(process, 'eventCleaning' + name, cms.Path(filter_obj)) process.eventCleaningAll *= filter_obj ################################################################################ # PAT/PF2PAT configuration inspired by TopQuarkAnalysis/Configuration # (test/patRefSel_allJets_cfg.py and included modules) with tag # V07-00-01. # First, turn off stdout so that the spam from PAT/PF2PAT doesn't # flood the screen (especially useful in batch job submission). if suppress_stdout: print 'tuple.py: PAT would spam a lot of stuff to stdout... hiding it.' from cStringIO import StringIO old_stdout = sys.stdout sys.stdout = buf = StringIO() jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not runOnMC: jecLevels.append('L2L3Residual') #jecLevels += ['L5Flavor', 'L7Parton'] postfix = 'PF' def processpostfix(name): return getattr(process, name + postfix) def setprocesspostfix(name, obj): setattr(process, name + postfix, obj) def InputTagPostFix(name): return cms.InputTag(name + postfix) process.load('PhysicsTools.PatAlgos.patSequences_cff') from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT usePF2PAT(process, runPF2PAT = True, runOnMC = runOnMC, jetAlgo = 'AK5', postfix = postfix, jetCorrections = ('AK5PFchs', jecLevels), # 'chs': using PFnoPU typeIMetCorrections = True, pvCollection = cms.InputTag('goodOfflinePrimaryVertices'), ) processpostfix('pfNoPileUp') .enable = True # usePFnoPU processpostfix('pfNoMuon') .enable = True # useNoMuon processpostfix('pfNoElectron').enable = True # useNoElectron processpostfix('pfNoJet') .enable = True # useNoJet processpostfix('pfNoTau') .enable = True # useNoTau processpostfix('pfPileUp').checkClosestZVertex = False processpostfix('pfPileUpIso').checkClosestZVertex = False processpostfix('pfMuonsFromVertex').d0Cut = processpostfix('pfElectronsFromVertex').d0Cut = 2 processpostfix('pfMuonsFromVertex').dzCut = processpostfix('pfElectronsFromVertex').dzCut = 2 processpostfix('pfSelectedMuons').cut = 'pt > 5.' #processpostfix('pfSelectedMuons').cut += process.jtupleParams.muonCut processpostfix('pfIsolatedMuons').isolationCut = 0.2 if False: # pfMuonIsoConeR03 processpostfix('pfIsolatedMuons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('muPFIsoValueCharged03')) processpostfix('pfIsolatedMuons').deltaBetaIsolationValueMap = InputTagPostFix('muPFIsoValuePU03') processpostfix('pfIsolatedMuons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('muPFIsoValueNeutral03'), InputTagPostFix('muPFIsoValueGamma03')) processpostfix('pfMuons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('muPFIsoValueCharged03')) processpostfix('pfMuons').deltaBetaIsolationValueMap = InputTagPostFix('muPFIsoValuePU03') processpostfix('pfMuons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('muPFIsoValueNeutral03'), InputTagPostFix('muPFIsoValueGamma03')) processpostfix('patMuons').isolationValues.pfNeutralHadrons = InputTagPostFix('muPFIsoValueNeutral03') processpostfix('patMuons').isolationValues.pfChargedAll = InputTagPostFix('muPFIsoValueChargedAll03') processpostfix('patMuons').isolationValues.pfPUChargedHadrons = InputTagPostFix('muPFIsoValuePU03') processpostfix('patMuons').isolationValues.pfPhotons = InputTagPostFix('muPFIsoValueGamma03') processpostfix('patMuons').isolationValues.pfChargedHadrons = InputTagPostFix('muPFIsoValueCharged03') processpostfix('pfSelectedElectrons').cut = 'pt > 5. && gsfTrackRef.isNonnull && gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits < 2' #processpostfix('pfSelectedElectrons').cut += ' && ' + process.jtupleParams.electronCut # disabled by default, but can use minimal (veto) electron selection cut on top of pfElectronSelectionCut processpostfix('pfIsolatedElectrons').isolationCut = 0.2 if True: # pfElectronIsoConeR03 processpostfix('pfIsolatedElectrons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('elPFIsoValueCharged03PFId')) processpostfix('pfIsolatedElectrons').deltaBetaIsolationValueMap = InputTagPostFix('elPFIsoValuePU03PFId') processpostfix('pfIsolatedElectrons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('elPFIsoValueNeutral03PFId'), InputTagPostFix('elPFIsoValueGamma03PFId')) processpostfix('pfElectrons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('elPFIsoValueCharged03PFId')) processpostfix('pfElectrons').deltaBetaIsolationValueMap = InputTagPostFix('elPFIsoValuePU03PFId') processpostfix('pfElectrons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('elPFIsoValueNeutral03PFId'), InputTagPostFix('elPFIsoValueGamma03PFId')) processpostfix('patElectrons').isolationValues.pfNeutralHadrons = InputTagPostFix('elPFIsoValueNeutral03PFId') processpostfix('patElectrons').isolationValues.pfChargedAll = InputTagPostFix('elPFIsoValueChargedAll03PFId') processpostfix('patElectrons').isolationValues.pfPUChargedHadrons = InputTagPostFix('elPFIsoValuePU03PFId') processpostfix('patElectrons').isolationValues.pfPhotons = InputTagPostFix('elPFIsoValueGamma03PFId') processpostfix('patElectrons').isolationValues.pfChargedHadrons = InputTagPostFix('elPFIsoValueCharged03PFId') process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') processpostfix('patElectrons').electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0") processpostfix('patElectrons').electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0") processpostfix('patMuons').embedTrack = True processpostfix('patJets').addTagInfos = True processpostfix('selectedPatElectrons').cut = process.jtupleParams.electronCut processpostfix('selectedPatMuons').cut = process.jtupleParams.muonCut processpostfix('selectedPatJets').cut = process.jtupleParams.jetCut process.load('CMGTools.External.pujetidsequence_cff') for x in (process.puJetId, process.puJetMva, process.puJetIdChs, process.puJetMvaChs): x.jets = InputTagPostFix('selectedPatJets') # fix bug in V00-03-04 of CMGTools/External if hasattr(x, 'algos'): bad, good = 'RecoJets/JetProducers', 'CMGTools/External' for ps in x.algos: if hasattr(ps, 'tmvaWeights'): s = ps.tmvaWeights.value() if s.startswith(bad): ps.tmvaWeights = s.replace(bad, good) from PhysicsTools.PatAlgos.tools.coreTools import runOnData, removeSpecificPATObjects if not runOnMC: runOnData(process, names = ['All'], postfix = postfix) removeSpecificPATObjects(process, names = ['Photons'], postfix = postfix) # will also remove cleaning # Make some extra SV producers for MFV studies. JMTBAD postfix junk for cut in (1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.): cut_name = ('%.1f' % cut).replace('.', 'p') tag_info_name = 'secondaryVertexMaxDR%sTagInfosAODPF' % cut_name tag_info_obj = process.secondaryVertexTagInfosAODPF.clone() tag_info_obj.vertexCuts.maxDeltaRToJetAxis = cut setattr(process, tag_info_name, tag_info_obj) process.patJetsPF.tagInfoSources.append(cms.InputTag(tag_info_name)) processpostfix('patPF2PATSequence').replace(processpostfix('patJets'), tag_info_obj * processpostfix('patJets')) from JMTucker.Tools.PATTupleSelection_cfi import makeLeptonProducers makeLeptonProducers(process, postfix=postfix, params=process.jtupleParams) common_seq = cms.ignore(process.goodOfflinePrimaryVertices) + cms.ignore(process.mvaTrigV0) + cms.ignore(process.mvaNonTrigV0) + processpostfix('patPF2PATSequence') + process.puJetIdSqeuenceChs process.load('JMTucker.MFVNeutralino.Vertexer_cff') common_seq *= process.mfvVertices # Require numbers of jets based on the trigger: hadronic channel will # have at least a 4-jet trigger (maybe 6!), while semileptonic uses a # 3-jet trigger. Dileptonic has no jets in trigger, but we'll require # at least one b-tag anyway. setprocesspostfix('countPatJetsHadronic', processpostfix('countPatJets').clone(minNumber = 4)) setprocesspostfix('countPatJetsSemileptonic', processpostfix('countPatJets').clone(minNumber = 3)) setprocesspostfix('countPatJetsDileptonic', processpostfix('countPatJets').clone(minNumber = 1)) channels = ('Hadronic', 'Semileptonic', 'Dileptonic') for channel in channels: setattr(process, 'p' + channel, cms.Path(common_seq)) process.pHadronic *= processpostfix('countPatJetsHadronic') process.pSemileptonic *= processpostfix('countPatJetsSemileptonic') + process.jtupleSemileptonSequence + process.countSemileptons process.pDileptonic *= processpostfix('countPatJetsDileptonic') + process.jtupleDileptonSequence + process.countDileptons process.out.SelectEvents.SelectEvents = ['p' + channel for channel in channels] process.out.outputCommands = [ 'drop *', 'keep *_selectedPatElectrons*_*_*', 'keep *_selectedPatMuons*_*_*', 'keep *_selectedPatJets*_*_*', 'drop *_selectedPatJetsForMETtype1p2CorrPF_*_*', 'drop *_selectedPatJetsForMETtype2CorrPF_*_*', 'keep *_mfvVertices*_*_*', 'drop CaloTowers_*_*_*', 'keep *_patMETs*_*_*', 'keep *_goodOfflinePrimaryVertices_*_*', 'keep edmTriggerResults_TriggerResults__PAT', # for post-tuple filtering on the goodData paths 'keep *_puJet*_*_*', ] # The normal TrigReport doesn't state how many events are written # total to the file in case of OutputModule's SelectEvents having # multiple paths. Add a summary to stdout that so that it is easy to # see what the total number of events should be (for debugging CRAB # jobs). (This means we can kill the normal TrigReport.) process.ORTrigReport = cms.EDAnalyzer('ORTrigReport', results_src = cms.InputTag('TriggerResults', '', process.name_()), paths = process.out.SelectEvents.SelectEvents ) process.pORTrigReport = cms.EndPath(process.ORTrigReport) # Must be on an EndPath. # As a simple check of the paths' efficiencies, add some lines to the # summary showing stats on events with generator-level muons/electrons # in acceptance from W decays. if runOnMC: for name, cut in [('Muon', 'abs(pdgId) == 13 && abs(eta) < 2.4 && abs(mother.pdgId) == 24 && pt > 20'), ('Electron', 'abs(pdgId) == 11 && abs(eta) < 2.5 && abs(mother.pdgId) == 24 && pt > 20'), ('Lepton', '((abs(pdgId) == 13 && abs(eta) < 2.4) || (abs(pdgId) == 11 && abs(eta) < 2.5)) && abs(mother.pdgId) == 24 && pt > 20'), ]: name = 'gen' + name + 's' filter = cms.EDFilter('CandViewSelector', src = cms.InputTag('genParticles'), cut = cms.string(cut)) counter = cms.EDFilter('CandViewCountFilter', src = cms.InputTag(name), minNumber = cms.uint32(1)) setattr(process, name, filter) setattr(process, name + 'Count', counter) setattr(process, 'p' + name + 'Count', cms.Path(filter*counter)) # Check that the stdout spam from PAT was what we expect. if suppress_stdout: pat_output = buf.getvalue() sys.stdout = old_stdout buf.close() hsh = hash(pat_output) #open('pat_spam.txt', 'wt').write(pat_output) hsh_expected = 6563257886911239637 if runOnMC else 3125511795667431709 print 'PAT is done (spam hash %s, expected %s).' % (hsh, hsh_expected) if hsh != hsh_expected: from JMTucker.Tools.general import big_warn big_warn('Unexpected spam hash! Did you change an option?') return process, common_seq