def addBoostedTaus(process): from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("RecoTauTag.Configuration.boostedHPSPFTaus_cff") patAlgosToolsTask = configtools.getPatAlgosToolsTask(process) patAlgosToolsTask.add(process.boostedHPSPFTausTask) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.ptau = cms.Path( process.PFTau ) process.PATTauSequence = cms.Sequence(process.PFTau+process.makePatTaus+process.selectedPatTaus) process.PATTauSequenceBoosted = cloneProcessingSnippet(process,process.PATTauSequence, "Boosted", addToTask = True) process.recoTauAK4PFJets08RegionBoosted.src = cms.InputTag('boostedTauSeeds') process.recoTauAK4PFJets08RegionBoosted.pfCandSrc = cms.InputTag('particleFlow') process.recoTauAK4PFJets08RegionBoosted.pfCandAssocMapSrc = cms.InputTag('boostedTauSeeds', 'pfCandAssocMapForIsolation') process.ak4PFJetsLegacyHPSPiZerosBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRcone = cms.double(0.3) process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRconeLimitedToJetArea = cms.bool(True) process.combinatoricRecoTausBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.combinatoricRecoTausBoosted.modifiers.remove(process.combinatoricRecoTausBoosted.modifiers[3]) #process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('pfNoPileUpForBoostedTaus') process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('particleFlow') #Note JetArea is not defined for subjets and restiction to jetArea is turned to dRMatch=0.1, so better use the latter explicitely #process.hpsPFTauDiscriminationByLooseMuonRejection3Boosted.dRmuonMatchLimitedToJetArea = cms.bool(True) #process.hpsPFTauDiscriminationByTightMuonRejection3Boosted.dRmuonMatchLimitedToJetArea = cms.bool(True) process.hpsPFTauDiscriminationByLooseMuonRejection3Boosted.dRmuonMatch = 0.1 process.hpsPFTauDiscriminationByTightMuonRejection3Boosted.dRmuonMatch = 0.1 massSearchReplaceAnyInputTag(process.PATTauSequenceBoosted,cms.InputTag("ak4PFJets"),cms.InputTag("boostedTauSeeds")) process.slimmedTausBoosted = process.slimmedTaus.clone(src = cms.InputTag("selectedPatTausBoosted")) patAlgosToolsTask.add(process.slimmedTausBoosted) return process
def addBoostedTaus(process): from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("RecoTauTag.Configuration.boostedHPSPFTaus_cff") patAlgosToolsTask = configtools.getPatAlgosToolsTask(process) patAlgosToolsTask.add(process.boostedHPSPFTausTask) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.ptau = cms.Path( process.PFTau ) process.PATTauSequence = cms.Sequence(process.PFTau+process.makePatTaus+process.selectedPatTaus) process.PATTauSequenceBoosted = cloneProcessingSnippet(process,process.PATTauSequence, "Boosted", addToTask = True) process.recoTauAK4PFJets08RegionBoosted.src = cms.InputTag('boostedTauSeeds') process.recoTauAK4PFJets08RegionBoosted.pfCandSrc = cms.InputTag('particleFlow') process.recoTauAK4PFJets08RegionBoosted.pfCandAssocMapSrc = cms.InputTag('boostedTauSeeds', 'pfCandAssocMapForIsolation') process.ak4PFJetsLegacyHPSPiZerosBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRcone = cms.double(0.3) process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRconeLimitedToJetArea = cms.bool(True) process.combinatoricRecoTausBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('particleFlow') ## Note JetArea is not defined for subjets (-> do not switch to True in hpsPFTauDiscriminationByLooseMuonRejection3Boosted, False is default) ## The restiction to jetArea is turned to dRMatch=0.1 (-> use explicitly this modified value) process.hpsPFTauDiscriminationByMuonRejection3Boosted.dRmuonMatch = 0.1 massSearchReplaceAnyInputTag(process.PATTauSequenceBoosted,cms.InputTag("ak4PFJets"),cms.InputTag("boostedTauSeeds")) process.slimmedTausBoosted = process.slimmedTaus.clone(src = cms.InputTag("selectedPatTausBoosted")) patAlgosToolsTask.add(process.slimmedTausBoosted) return process
def _setTriggerProcess(process, triggerTag, **kwargs): # Set the input tag for the HLT # update InputTag for all modules in sequence for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.Sequence): #print "--> Resetting HLT input tag for sequence:", processAttrName patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag("TriggerResults", "", "HLT"), triggerTag) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag("TriggerResults::HLT"), triggerTag) # update InputTag for PAT trigger tools if hasattr("process", "patTrigger"): process.patTrigger.processName = triggerTag.getProcessName() if hasattr("process", "patTriggerEvent"): process.patTriggerEvent.processName = triggerTag.getProcessName() # update InputTag for all histogram managers, # binner and event-dump plugins of GenericAnalyzer module for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.EDAnalyzer): if processAttr.type_() == "GenericAnalyzer": if hasattr(processAttr, "analyzers"): analyzerPlugins = getattr(processAttr, "analyzers") for analyzerPlugin in analyzerPlugins: _setattr_ifexists(analyzerPlugin, "hltResultsSource", triggerTag) if hasattr(processAttr, "eventDumps"): eventDumps = getattr(processAttr, "eventDumps") for eventDump in eventDumps: _setattr_ifexists(eventDump, "hltResultsSource", triggerTag)
def switchToAOD(process, triggerHistManager = None, eventDumpPlugin = None): # call "standard" PAT function to restrict all InputTags to AOD event content restrictInputToAOD(process, [ "All", ]) # switch collection of ECAL recHits used as input for IsoDeposit computation # from list of all ECAL recHits in the event to "reduced" collections # limited to cones of size dR = 0.6 around electron candidates if hasattr(process, "p"): massSearchReplaceAnyInputTag(process.p, cms.InputTag("ecalRecHit", "EcalRecHitsEB"), cms.InputTag("reducedEcalRecHitsEB")) massSearchReplaceAnyInputTag(process.p, cms.InputTag("ecalRecHit", "EcalRecHitsEE"), cms.InputTag("reducedEcalRecHitsEE")) # disable PAT trigger matching # (not yet implemented for photons and jets) if hasattr(process, "patTriggerSequence"): process.patDefaultSequence.remove(process.patTriggerSequence) process.patElectrons.embedHighLevelSelection = cms.bool(False) #process.patPhotons.embedHighLevelSelection = cms.bool(False) process.patMuons.embedHighLevelSelection = cms.bool(False) process.patTaus.embedHighLevelSelection = cms.bool(False) #process.patJets.embedHighLevelSelection = cms.bool(False) process.patMETs.embedHighLevelSelection = cms.bool(False) if hasattr(process, "patPFMETs"): process.patPFMETs.embedHighLevelSelection = cms.bool(False) if triggerHistManager is not None: triggerHistManager.hltResultsSource = cms.InputTag('') triggerHistManager.l1Bits = cms.vstring() triggerHistManager.hltPaths = cms.vstring() if eventDumpPlugin is not None: eventDumpPlugin.l1GtReadoutRecordSource = cms.InputTag('') eventDumpPlugin.l1GtObjectMapRecordSource = cms.InputTag('') eventDumpPlugin.hltResultsSource = cms.InputTag('')
def cloneTagSequenceForEachSystematic(process, systlabels, phosystlabels, jetsystlabels, jetSystematicsInputTags, ZPlusJetMode=False): for systlabel in systlabels: if systlabel == "": continue from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet, massSearchReplaceAnyInputTag newseq = cloneProcessingSnippet(process, process.flashggTagSequence, systlabel) if systlabel in phosystlabels: massSearchReplaceAnyInputTag( newseq, cms.InputTag("flashggDiPhotonSystematics"), cms.InputTag("flashggDiPhotonSystematics", systlabel)) if systlabel in jetsystlabels: for i in range(len(jetSystematicsInputTags)): massSearchReplaceAnyInputTag( newseq, jetSystematicsInputTags[i], cms.InputTag(jetSystematicsInputTags[i].moduleLabel, systlabel)) for name in newseq.moduleNames(): module = getattr(process, name) if hasattr(module, "SystLabel"): module.SystLabel = systlabel process.systematicsTagSequences += newseq if ZPlusJetMode: process.flashggSystTagMerger.src.append( cms.InputTag("flashggZPlusJetTag" + systlabel)) else: process.flashggSystTagMerger.src.append( cms.InputTag("flashggTagSorter" + systlabel))
def addBoostedTaus(process): from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("RecoTauTag.Configuration.boostedHPSPFTaus_cff") process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.ptau = cms.Path( process.PFTau ) process.PATTauSequence = cms.Sequence(process.PFTau+process.makePatTaus+process.selectedPatTaus) process.PATTauSequenceBoosted = cloneProcessingSnippet(process,process.PATTauSequence, "Boosted") process.recoTauAK4PFJets08RegionBoosted.src = cms.InputTag('boostedTauSeeds') process.recoTauAK4PFJets08RegionBoosted.pfCandSrc = cms.InputTag('particleFlow') process.recoTauAK4PFJets08RegionBoosted.pfCandAssocMapSrc = cms.InputTag('boostedTauSeeds', 'pfCandAssocMapForIsolation') process.ak4PFJetsLegacyHPSPiZerosBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRcone = cms.double(0.3) process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRconeLimitedToJetArea = cms.bool(True) process.combinatoricRecoTausBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.combinatoricRecoTausBoosted.modifiers.remove(process.combinatoricRecoTausBoosted.modifiers[3]) #process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('pfNoPileUpForBoostedTaus') process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('particleFlow') process.hpsPFTauDiscriminationByLooseMuonRejection3Boosted.dRmuonMatchLimitedToJetArea = cms.bool(True) process.hpsPFTauDiscriminationByTightMuonRejection3Boosted.dRmuonMatchLimitedToJetArea = cms.bool(True) massSearchReplaceAnyInputTag(process.PATTauSequenceBoosted,cms.InputTag("ak4PFJets"),cms.InputTag("boostedTauSeeds")) process.slimmedTausBoosted = process.slimmedTaus.clone(src = cms.InputTag("selectedPatTausBoosted")) return process
def configurePrePatMuon(process) : process.selectedPrimaryVertexQuality = cms.EDFilter("VertexSelector", src = cms.InputTag('offlinePrimaryVertices'), cut = cms.string("isValid & ndof >= 4 & chi2 > 0 & tracksSize > 0"), # CV: cut >= 4 if using 'offlinePrimaryVertices', # >= 7 if using 'offlinePrimaryVerticesWithBS' as input filter = cms.bool(False) ) process.selectedPrimaryVertexPosition = cms.EDFilter("VertexSelector", src = cms.InputTag('selectedPrimaryVertexQuality'), cut = cms.string("abs(z) < 24 & abs(position.Rho) < 2."), filter = cms.bool(False) ) process.load("CommonTools.ParticleFlow.pfNoPileUp_cff") process.pfPileUp.Enable = cms.bool(True) process.pfPileUp.checkClosestZVertex = cms.bool(True) process.pfPileUp.Vertices = cms.InputTag('selectedPrimaryVertexPosition') process.load("CommonTools.ParticleFlow.pfParticleSelection_cff") process.pfPileUp.PFCandidates = 'particleFlow' process.pfNoPileUp.bottomCollection = 'particleFlow' process.pfPileUpIso.PFCandidates = 'particleFlow' process.pfNoPileUpIso.bottomCollection='particleFlow' process.load("RecoMuon.MuonIsolation.muonPFIsolation_cff") import PhysicsTools.PatAlgos.tools.helpers as patutils patutils.massSearchReplaceAnyInputTag(process.muonPFIsolationDepositsSequence, cms.InputTag('muons1stStep'), cms.InputTag('muons')) process.produceMuonPFIsoPrePat = cms.Sequence( process.selectedPrimaryVertexQuality * process.selectedPrimaryVertexPosition * process.pfNoPileUpSequence * process.pfParticleSelectionSequence * process.muonPFIsolationDepositsSequence)
def MassReplaceInputTag(process,old="rawDataCollector",new="rawDataRepacker",verbose=False,moduleLabelOnly=False,skipLabelTest=False): # replace InputTag values (adapted from Configuration/Applications/python/ConfigBuilder.py) from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag for s in process.paths_().keys(): massSearchReplaceAnyInputTag(getattr(process,s),old,new,verbose,moduleLabelOnly,skipLabelTest) for s in process.endpaths_().keys(): massSearchReplaceAnyInputTag(getattr(process,s),old,new,verbose,moduleLabelOnly,skipLabelTest) return(process)
def MassReplaceInputTag(process, old="rawDataCollector", new="rawDataRepacker"): # replace InputTag values (adapted from Configuration/Applications/python/ConfigBuilder.py) from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag for s in process.paths_().keys(): massSearchReplaceAnyInputTag(getattr(process, s), old, new) return (process)
def changeRecoMuonInput(process, recoMuonCollectionTag, oldRecoMuonCollectionTag=cms.InputTag("muons")): "Use a different input collection of reco muons" from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.patMuonsWithTriggerSequence, oldRecoMuonCollectionTag, recoMuonCollectionTag)
def rerunParticleFlow(process, inputProcess): # load event-setup definitions necessary to rerun particle-flow sequence loadIfNecessary( process, "TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorAny_cfi", "SteppingHelixPropagatorAny" ) loadIfNecessary( process, "CalibTracker.SiPixelESProducers.SiPixelTemplateDBObjectESProducer_cfi", "siPixelTemplateDBObjectESProducer", ) loadIfNecessary(process, "RecoTracker.MeasurementDet.MeasurementTrackerESProducer_cfi", "MeasurementTracker") loadIfNecessary(process, "RecoLocalCalo.EcalRecAlgos.EcalSeverityLevelESProducer_cfi", "ecalSeverityLevel") loadIfNecessary( process, "RecoEcal.EgammaCoreTools.EcalNextToDeadChannelESProducer_cff", "ecalNextToDeadChannelESProducer" ) loadIfNecessary(process, "RecoLocalCalo.HcalRecAlgos.hcalRecAlgoESProd_cfi", "hcalRecAlgos") if not hasattr(process, "UpdaterService"): process.UpdaterService = cms.Service("UpdaterService") # load module definitions necessary to rerun particle-flow sequence loadIfNecessary(process, "RecoParticleFlow.PFClusterProducer.particleFlowCluster_cff", "particleFlowCluster") loadIfNecessary( process, "RecoEgamma.EgammaElectronProducers.gsfElectronSequence_cff", "gsfEcalDrivenElectronSequence" ) loadIfNecessary(process, "RecoParticleFlow.Configuration.RecoParticleFlow_cff", "particleFlowReco") loadIfNecessary(process, "RecoMuon.MuonIsolation.muonPFIsolationValues_cff", "muonPFIsolationSequence") # define complete sequence of all modules necessary to rerun particle-flow algorithm process.rerunParticleFlowSequence = cms.Sequence( process.particleFlowCluster + process.particleFlowTrackWithDisplacedVertex + process.gsfEcalDrivenElectronSequence + process.particleFlowReco + process.particleFlowLinks ) # CV: clone sequence and give it a different name so that particle-flow algorithm # can be run using "official" module labels on embedded event later configtools.cloneProcessingSnippet(process, process.rerunParticleFlowSequence, "ForPFMuonCleaning") # CV: run particle-flow algorithm on final RECO muon collection # (rather than running muon reconstruction sequence in steps) process.pfTrackForPFMuonCleaning.MuColl = cms.InputTag("muons") process.particleFlowBlockForPFMuonCleaning.RecMuons = cms.InputTag("muons") process.particleFlowTmpForPFMuonCleaning.muons = cms.InputTag("muons") process.particleFlowForPFMuonCleaning.FillMuonRefs = False # CV: make sure that all particle-flow based isolation is computed wrt. 'particleFlowTmp' collection # (PAT may overwrite configuration parameters to refer to 'particleFlow' instead) configtools.massSearchReplaceAnyInputTag( process.rerunParticleFlowSequenceForPFMuonCleaning, cms.InputTag("particleFlow"), cms.InputTag("particleFlowTmp"), ) return process.rerunParticleFlowSequenceForPFMuonCleaning
def addLowPtTaus(process): from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("RecoTauTag.Configuration.LowPtHPSPFTaus_cff") patAlgosToolsTask = configtools.getPatAlgosToolsTask(process) patAlgosToolsTask.add(process.LowPtHPSPFTausTask) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.ptau = cms.Path(process.PFTau) process.PATTauSequence = cms.Sequence(process.PFTau + process.makePatTaus + process.selectedPatTaus) process.PATTauSequenceLowPt = cloneProcessingSnippet( process, process.PATTauSequence, "LowPt", addToTask=True) process.recoTauAK4PFJets08RegionLowPt.src = cms.InputTag('LowPtTauSeeds') process.recoTauAK4PFJets08RegionLowPt.pfCandSrc = cms.InputTag( 'particleFlow') process.recoTauAK4PFJets08RegionLowPt.pfCandAssocMapSrc = cms.InputTag( 'LowPtTauSeeds', 'pfCandAssocMapForIsolation') process.selectedPatTausLowPt.cut = cms.string( "pt > 1. && tauID(\'decayModeFindingNewDMs\')> 0.5" ) #tau pt> 1 GeV of threshold output process.ak4PFJetsLegacyHPSPiZerosLowPt.jetSrc = cms.InputTag( 'LowPtTauSeeds') process.ak4PFJetsLegacyHPSPiZerosLowPt.minJetPt = cms.double( 1) #jet pt> 1 GeV of threshold in input process.ak4PFJetsRecoTauChargedHadronsLowPt.jetSrc = cms.InputTag( 'LowPtTauSeeds') process.ak4PFJetsRecoTauChargedHadronsLowPt.builders[ 1].dRcone = cms.double(0.3) process.ak4PFJetsRecoTauChargedHadronsLowPt.builders[ 1].dRconeLimitedToJetArea = cms.bool(True) process.combinatoricRecoTausLowPt.jetSrc = cms.InputTag('LowPtTauSeeds') _allModifiers = cms.VPSet() for modifier in process.combinatoricRecoTausLowPt.modifiers: _allModifiers.append(modifier) process.combinatoricRecoTausLowPt.modifiers.remove( process.combinatoricRecoTausLowPt.modifiers[3]) from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17 for era in [run2_miniAOD_80XLegacy, run2_miniAOD_94XFall17]: era.toModify(process.combinatoricRecoTausLowPt, modifiers=_allModifiers) process.combinatoricRecoTausLowPt.builders[0].pfCandSrc = cms.InputTag( 'particleFlow') ## Note JetArea is not defined for subjets (-> do not switch to True in hpsPFTauDiscriminationByLooseMuonRejection3LowPt, False is default) ## The restiction to jetArea is turned to dRMatch=0.1 (-> use explicitly this modified value) #process.hpsPFTauDiscriminationByLooseMuonRejection3LowPt.dRmuonMatch = 0.1 #process.hpsPFTauDiscriminationByTightMuonRejection3LowPt.dRmuonMatch = 0.1 massSearchReplaceAnyInputTag(process.PATTauSequenceLowPt, cms.InputTag("ak4PFJets"), cms.InputTag("LowPtTauSeeds")) process.slimmedTausLowPt = process.slimmedTaus.clone( src=cms.InputTag("selectedPatTausLowPt")) patAlgosToolsTask.add(process.slimmedTausLowPt) return process
def useExistingPATMuons(process, newPatMuonTag, addL1Info=False): "Start from existing pat Muons instead of producing them" process.patMuonsWithTriggerSequence.remove(process.patMuonsWithoutTrigger) process.patMuonsWithTriggerSequence.remove(process.muonL1Info) process.patMuonsWithTrigger.src = newPatMuonTag from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.patMuonsWithTriggerSequence, cms.InputTag('patMuonsWithoutTrigger'), newPatMuonTag) if addL1Info: process.muonL1Info.src = newPatMuonTag.muonSource addL1UserData(getattr(process,newPatMuonTag.moduleLabel), 'muonL1Info')
def replaceInputTagInAllSequences(process, oldName, newName, exceptions=[], pathExceptions=[], verbose=False): if verbose: print "Replacing %s -> %s" % (oldName, newName) for seqName, seq in process.sequences_().iteritems(): if seqName not in exceptions: if verbose: print " in sequence %s" % seqName helpers.massSearchReplaceAnyInputTag(seq, cms.InputTag(oldName), cms.InputTag(newName), verbose=verbose) for pathName, path in process.paths_().iteritems(): if pathName not in pathExceptions: if verbose: print " in path %s" % pathName helpers.massSearchReplaceAnyInputTag(path, cms.InputTag(oldName), cms.InputTag(newName), verbose=verbose)
def backupJetsSecondStep(process, sequences, badMuons, verbose=False): """Deploy the snapshots after the change of PFCandidates""" # put back the old input tags for sequence in sequences.itervalues(): massSearchReplaceAnyInputTag(sequence, "pfCandidatesBadMuonsCleaned", "particleFlow") massSearchReplaceAnyInputTag(sequence, "muonsCleaned", "muons") # gate the input collections to avoid re-running most of PAT on good events reduceInputJetCollection(process, process.ak4PFJetsCHSBackup, badMuons) reduceInputJetCollection(process, process.ak4PFJetsPuppiBackup, badMuons) # fix names in the valuemaps process.patJetsBackup.userData.userInts.labelPostfixesToStrip = cms.vstring("Backup",) process.patJetsBackup.userData.userFloats.labelPostfixesToStrip = cms.vstring("Backup",) process.patJetsAK8Backup.userData.userFloats.labelPostfixesToStrip = cms.vstring("Backup",) process.patJetsAK8PuppiBackup.userData.userFloats.labelPostfixesToStrip = cms.vstring("Backup",) # # now deal with daughter links # for these we can keep the daughters process.slimmedJetsBackup.mixedDaughters = True process.slimmedJetsBackup.packedPFCandidates = cms.InputTag("oldPFCandToPackedOrDiscarded") process.slimmedJetsAK8PFCHSSoftDropSubjetsBackup.mixedDaughters = True process.slimmedJetsAK8PFCHSSoftDropSubjetsBackup.packedPFCandidates = cms.InputTag("oldPFCandToPackedOrDiscarded") # for these we can't process.slimmedJetsPuppiBackup.dropDaughters = '1' process.slimmedJetsAK8PFPuppiSoftDropSubjetsBackup.dropDaughters = '1' # for these we do even if we wouldn't have done in the standard case, since we couldn't for the subjets process.packedPatJetsAK8Backup.fixDaughters = False process.slimmedJetsAK8Backup.rekeyDaughters = '1' process.slimmedJetsAK8Backup.mixedDaughters = True process.slimmedJetsAK8Backup.packedPFCandidates = cms.InputTag("oldPFCandToPackedOrDiscarded") # reduceFinalJetCollection(process, process.slimmedJetsBackup, badMuons) reduceFinalJetCollection(process, process.slimmedJetsPuppiBackup, badMuons) reduceFinalJetCollection(process, process.slimmedJetsAK8Backup, badMuons) # addKeepStatement(process, "keep *_slimmedJets_*_*", ["keep *_slimmedJetsBackup_*_*"], verbose=verbose) addKeepStatement(process, "keep *_slimmedJetsPuppi_*_*", ["keep *_slimmedJetsPuppiBackup_*_*"], verbose=verbose) addKeepStatement(process, "keep *_slimmedJetsAK8_*_*", ["keep *_slimmedJetsAK8Backup_*_*"], verbose=verbose) addKeepStatement(process,"keep *_slimmedJetsAK8PFCHSSoftDropPacked_SubJets_*", ["keep *_slimmedJetsAK8PFCHSSoftDropPackedBackup_SubJets_*"], verbose=verbose) addKeepStatement(process,"keep *_slimmedJetsAK8PFPuppiSoftDropPacked_SubJets_*", ["keep *_slimmedJetsAK8PFPuppiSoftDropPackedBackup_SubJets_*"], verbose=verbose)
def modifyBTagDiscs(process, algo, newMinDisc, newMaxDisc): getattr(process, algo + "BJets").cut = 'bDiscriminator("' + algo + 'BJetTags") > ' + str(newMinDisc) process.analyseFullHadronicSelection.replace(process.trackCountingHighEffBJets, getattr(process, algo + "BJets")) process.kinFitTtFullHadEventHypothesis.bTagAlgo = algo + 'BJetTags' process.fullHadTopReco_2.analyze.bTagAlgo = algo + 'BJetTags' process.fullHadTopReco_3.analyze.bTagAlgo = algo + 'BJetTags' process.kinFitTtFullHadEventHypothesis.minBTagValueBJet = newMinDisc process.kinFitTtFullHadEventHypothesis.maxBTagValueNonBJet = newMaxDisc from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.analyseFullHadronicSelection, 'trackCountingHighEffBJets', algo + 'BJets')
def modifyTagSequenceForSystematics(process, jetSystematicsInputTags, ZPlusJetMode=False): process.flashggTagSequence.remove( process.flashggUnpackedJets) # to avoid unnecessary cloning process.flashggTagSequence.remove(process.flashggUpdatedIdMVADiPhotons ) # Needs to be run before systematics from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet, massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.flashggTagSequence, cms.InputTag("flashggUpdatedIdMVADiPhotons"), cms.InputTag("flashggDiPhotonSystematics")) massSearchReplaceAnyInputTag(process.flashggTagSequence, cms.InputTag("flashggSelectedElectrons"), cms.InputTag("flashggElectronSystematics")) massSearchReplaceAnyInputTag(process.flashggTagSequence, cms.InputTag("flashggSelectedMuons"), cms.InputTag("flashggMuonSystematics")) from flashgg.Taggers.flashggTags_cff import UnpackedJetCollectionVInputTag for i in range(len(jetSystematicsInputTags)): massSearchReplaceAnyInputTag(process.flashggTagSequence, UnpackedJetCollectionVInputTag[i], jetSystematicsInputTags[i]) if ZPlusJetMode == 2: # VBF process.flashggSystTagMerger = cms.EDProducer( "VBFTagMerger", src=cms.VInputTag("flashggVBFTag")) elif ZPlusJetMode: process.flashggSystTagMerger = cms.EDProducer( "ZPlusJetTagMerger", src=cms.VInputTag("flashggZPlusJetTag")) else: process.flashggSystTagMerger = cms.EDProducer( "TagMerger", src=cms.VInputTag("flashggTagSorter")) process.systematicsTagSequences = cms.Sequence()
def runOnCalo(process): print "++++++++++++++++++++++++++++++++++++++++++++" print "switching all inputs in to run on Calo" print "goodJetsPF -> goodJets" print "patMETsPF -> patMETs" print "++++++++++++++++++++++++++++++++++++++++++++" process.analyseFullHadronicSelection.replace(process.goodJetsPF, process.goodJets) ## exchange PFJetID cuts to JetID process.tight4LeadingJets.cut = tight4JetCut # + tightCaloJetID process.tight5LeadingJets.cut = tight5JetCut # + tightCaloJetID # process.tightLeadingJets.cut = tight6JetCut #+ tightCaloJetID process.tight6LeadingJets.cut = tight6JetCut # + tightCaloJetID process.tightLeadingJets.cut = tightJetCut # + tightCaloJetID # process.tightBottomJets.cut = tight6JetCut #+ tightCaloJetID process.tightBottomJets.cut = tightJetCut # + tightCaloJetID ## exchange resolutions for CaloJets from TopQuarkAnalysis.TopObjectResolutions.stringResolutions_etEtaPhi_cff import udscResolution, bjetResolution process.kinFitTtFullHadEventHypothesis.udscResolutions = udscResolution.functions process.kinFitTtFullHadEventHypothesis.bResolutions = bjetResolution.functions # for suf in listOfMonitoringSuffixes: # if(hasattr(process, 'kinFitQuality'+suf)): # getattr(process, 'kinFitQuality'+suf).analyze.udscResolutions = udscResolution.functions # getattr(process, 'kinFitQuality'+suf).analyze.bResolutions = bjetResolution.functions ## run kinematic fit for CaloJets with L1L2L3(Res)L5 correted jets process.kinFitTtFullHadEventHypothesis.jetCorrectionLevel = "L5Hadron" process.ttFullHadHypGenMatch.jetCorrectionLevel = "L5Hadron" ## replace PFJets and PFMET with CaloJets and CaloMET from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.analyseFullHadronicSelection, "goodJetsPF", "goodJets") massSearchReplaceAnyInputTag(process.analyseFullHadronicSelection, "patMETsPF", "patMETs") ## give correct resolutions for background estimation if done if hasattr(process, "analyzeFullHadQCDEstimation"): process.analyzeFullHadQCDEstimation.analyze.udscResolutions = udscResolution.functions process.analyzeFullHadQCDEstimation.analyze.bResolutions = bjetResolution.functions ## in case of mc, smear the energy resolution additionally if hasattr(process, "scaledJetEnergy"): process.scaledJetEnergy.inputJets = "selectedPatJets" process.scaledJetEnergy.inputMETs = "patMETs" process.scaledJetEnergy.payload = "AK5Calo"
def switch_hlt_process_name(process, name): # JMTBAD better place for this fcn class warn_hlt_visitor(object): def enter(self, visitee): for attr in dir(visitee): if str(getattr(visitee, attr)) == 'HLT': print 'warning: visitee %s, attribute %s has value HLT' % (visitee, attr) def leave(self, visitee): pass from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag for path_name, path in process.paths.iteritems(): # why does values() throw an exception? for label in ['TriggerResults', 'hltL1GtObjectMap', 'hltTriggerSummaryAOD']: old = cms.InputTag(label, '', 'HLT') new = cms.InputTag(label, '', name) massSearchReplaceAnyInputTag(path, old, new, verbose=False) path.visit(warn_hlt_visitor())
def rerunParticleFlow(process, inputProcess): # load event-setup definitions necessary to rerun particle-flow sequence loadIfNecessary(process, "TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorAny_cfi", "SteppingHelixPropagatorAny") loadIfNecessary(process, "CalibTracker.SiPixelESProducers.SiPixelTemplateDBObjectESProducer_cfi", "siPixelTemplateDBObjectESProducer") loadIfNecessary(process, "RecoTracker.MeasurementDet.MeasurementTrackerESProducer_cfi", "MeasurementTracker") loadIfNecessary(process, "RecoLocalCalo.EcalRecAlgos.EcalSeverityLevelESProducer_cfi", "ecalSeverityLevel") loadIfNecessary(process, "RecoEcal.EgammaCoreTools.EcalNextToDeadChannelESProducer_cff", "ecalNextToDeadChannelESProducer") loadIfNecessary(process, "RecoLocalCalo.HcalRecAlgos.hcalRecAlgoESProd_cfi", "hcalRecAlgos") if not hasattr(process, "UpdaterService"): process.UpdaterService = cms.Service("UpdaterService") # load module definitions necessary to rerun particle-flow sequence loadIfNecessary(process, "RecoParticleFlow.PFClusterProducer.particleFlowCluster_cff", "particleFlowCluster") loadIfNecessary(process, "RecoEgamma.EgammaElectronProducers.gsfElectronSequence_cff", "gsfEcalDrivenElectronSequence") loadIfNecessary(process, "RecoParticleFlow.Configuration.RecoParticleFlow_cff", "particleFlowReco") loadIfNecessary(process, "RecoMuon.MuonIsolation.muonPFIsolationValues_cff", "muonPFIsolationSequence") # define complete sequence of all modules necessary to rerun particle-flow algorithm process.rerunParticleFlowSequence = cms.Sequence( process.particleFlowCluster + process.particleFlowTrackWithDisplacedVertex + process.gsfEcalDrivenElectronSequence + process.particleFlowReco + process.particleFlowLinks ) # CV: clone sequence and give it a different name so that particle-flow algorithm # can be run using "official" module labels on embedded event later configtools.cloneProcessingSnippet(process, process.rerunParticleFlowSequence, "ForPFMuonCleaning") # CV: run particle-flow algorithm on final RECO muon collection # (rather than running muon reconstruction sequence in steps) process.pfTrackForPFMuonCleaning.MuColl = cms.InputTag('muons') process.particleFlowBlockForPFMuonCleaning.RecMuons = cms.InputTag('muons') process.particleFlowTmpForPFMuonCleaning.muons = cms.InputTag('muons') process.particleFlowForPFMuonCleaning.FillMuonRefs = False # CV: make sure that all particle-flow based isolation is computed wrt. 'particleFlowTmp' collection # (PAT may overwrite configuration parameters to refer to 'particleFlow' instead) configtools.massSearchReplaceAnyInputTag(process.rerunParticleFlowSequenceForPFMuonCleaning, cms.InputTag('particleFlow'), cms.InputTag('particleFlowTmp')) return process.rerunParticleFlowSequenceForPFMuonCleaning
def switch_reco_process_name(process, name): # JMTBAD better place for this fcn class warn_hlt_visitor(object): def enter(self, visitee): for attr in dir(visitee): if str(getattr(visitee, attr)) == 'HLT': print 'warning: visitee %s, attribute %s has value HLT' % ( visitee, attr) def leave(self, visitee): pass from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag for path_name, path in process.paths.iteritems( ): # why does values() throw an exception? for label in ['TriggerResults']: old = cms.InputTag(label, '', 'RECO') new = cms.InputTag(label, '', name) massSearchReplaceAnyInputTag(path, old, new, verbose=False)
def modifyTagSequenceForSystematics(process,jetSystematicsInputTags,ZPlusJetMode=False): process.flashggTagSequence.remove(process.flashggUnpackedJets) # to avoid unnecessary cloning process.flashggTagSequence.remove(process.flashggUpdatedIdMVADiPhotons) # Needs to be run before systematics from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet,massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("flashggUpdatedIdMVADiPhotons"),cms.InputTag("flashggDiPhotonSystematics")) massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("flashggSelectedElectrons"),cms.InputTag("flashggElectronSystematics")) massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("flashggSelectedMuons"),cms.InputTag("flashggMuonSystematics")) massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("flashggMetsCorr"),cms.InputTag("flashggMetSystematics")) from flashgg.Taggers.flashggTags_cff import UnpackedJetCollectionVInputTag for i in range(len(jetSystematicsInputTags)): massSearchReplaceAnyInputTag(process.flashggTagSequence,UnpackedJetCollectionVInputTag[i],jetSystematicsInputTags[i]) if ZPlusJetMode == 2: # VBF process.flashggSystTagMerger = cms.EDProducer("VBFTagMerger",src=cms.VInputTag("flashggVBFTag")) elif ZPlusJetMode: process.flashggSystTagMerger = cms.EDProducer("ZPlusJetTagMerger",src=cms.VInputTag("flashggZPlusJetTag")) else: process.flashggSystTagMerger = cms.EDProducer("TagMerger",src=cms.VInputTag("flashggTagSorter")) process.systematicsTagSequences = cms.Sequence()
def dummy_beamspot(process, params): params = getattr(DummyBeamSpots, params) process.myBeamSpot = cms.EDProducer('DummyBeamSpotProducer', params) for name, path in process.paths.items(): path.insert(0, process.myBeamSpot) for name, out in process.outputModules.items(): new_cmds = [] for cmd in out.outputCommands: if 'offlineBeamSpot' in cmd: new_cmds.append(cmd.replace('offlineBeamSpot', 'myBeamSpot')) out.outputCommands += new_cmds import itertools from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag for path_name, path in itertools.chain(process.paths.iteritems(), process.endpaths.iteritems()): massSearchReplaceAnyInputTag(path, cms.InputTag('offlineBeamSpot'), cms.InputTag('myBeamSpot'), verbose=True)
def cloneTagSequenceForEachSystematic(process,systlabels,phosystlabels,jetsystlabels,jetSystematicsInputTags,ZPlusJetMode=False): for systlabel in systlabels: if systlabel == "": continue from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet,massSearchReplaceAnyInputTag newseq = cloneProcessingSnippet(process,process.flashggTagSequence,systlabel) if systlabel in phosystlabels: massSearchReplaceAnyInputTag(newseq,cms.InputTag("flashggDiPhotonSystematics"),cms.InputTag("flashggDiPhotonSystematics",systlabel)) if systlabel in jetsystlabels: for i in range(len(jetSystematicsInputTags)): massSearchReplaceAnyInputTag(newseq,jetSystematicsInputTags[i],cms.InputTag(jetSystematicsInputTags[i].moduleLabel,systlabel)) for name in newseq.moduleNames(): module = getattr(process,name) if hasattr(module,"SystLabel"): module.SystLabel = systlabel process.systematicsTagSequences += newseq if ZPlusJetMode: process.flashggSystTagMerger.src.append(cms.InputTag("flashggZPlusJetTag" + systlabel)) else: process.flashggSystTagMerger.src.append(cms.InputTag("flashggTagSorter" + systlabel))
def modifyBTagDiscs(process, algo, newMinDisc, newMaxDisc): getattr(process, algo + "BJets").cut = 'bDiscriminator("' + algo + 'BJetTags") > ' + str(newMinDisc) process.analyseFullHadronicSelection.replace(process.trackCountingHighEffBJets, getattr(process, algo + "BJets")) for suf in listOfMonitoringSuffixes: if hasattr(process, "fullHadTopReco" + suf): getattr(process, "fullHadTopReco" + suf).analyze.bTagAlgo = algo + "BJetTags" process.kinFitTtFullHadEventHypothesis.bTagAlgo = algo + "BJetTags" process.kinFitTtFullHadEventHypothesis.minBTagValueBJet = newMinDisc process.kinFitTtFullHadEventHypothesis.maxBTagValueNonBJet = newMaxDisc if hasattr(process, "analyzeFullHadEventMixer"): process.analyzeFullHadEventMixer.bTagAlgo = algo + "BJetTags" process.analyzeFullHadEventMixer.minBTagValueBJet = newMinDisc process.analyzeFullHadEventMixer.maxBTagValueNonBJet = newMaxDisc from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.analyseFullHadronicSelection, "trackCountingHighEffBJets", algo + "BJets")
def addBoostedTaus(process): from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("RecoTauTag.Configuration.boostedHPSPFTaus_cff") process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.ptau = cms.Path( process.PFTau ) process.PATTauSequence = cms.Sequence(process.PFTau+process.makePatTaus+process.selectedPatTaus) process.PATTauSequenceBoosted = cloneProcessingSnippet(process,process.PATTauSequence, "Boosted") process.recoTauAK4PFJets08RegionBoosted.src = cms.InputTag('boostedTauSeeds') process.recoTauAK4PFJets08RegionBoosted.pfCandSrc = cms.InputTag('particleFlow') process.recoTauAK4PFJets08RegionBoosted.pfCandAssocMapSrc = cms.InputTag('boostedTauSeeds', 'pfCandAssocMapForIsolation') process.ak4PFJetsLegacyHPSPiZerosBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRcone = cms.double(0.3) process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRconeLimitedToJetArea = cms.bool(True) process.combinatoricRecoTausBoosted.jetSrc = cms.InputTag('boostedTauSeeds') process.combinatoricRecoTausBoosted.modifiers.remove(process.combinatoricRecoTausBoosted.modifiers[3]) #process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('pfNoPileUpForBoostedTaus') process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('particleFlow') massSearchReplaceAnyInputTag(process.PATTauSequenceBoosted,cms.InputTag("ak4PFJets"),cms.InputTag("boostedTauSeeds")) process.slimmedTausBoosted = process.slimmedTaus.clone(src = cms.InputTag("selectedPatTausBoosted")) return process
def runOnCalo(process): print '++++++++++++++++++++++++++++++++++++++++++++' print 'switching all inputs in to run on Calo' print 'goodJetsPF -> goodJets' print 'patMETsPF -> patMETs' print '++++++++++++++++++++++++++++++++++++++++++++' process.analyseFullHadronicSelection.replace(process.goodJetsPF, process.goodJets) ## exchange PFJetID cuts to JetID process.tightLeadingJets.cut = tightJetCut + tightCaloJetID process.tightBottomJets.cut = tightJetCut + tightCaloJetID process.monitoredTightBottomJets.cut = tightJetCut + tightCaloJetID ## exchange resolutions for CaloJets process.load("TopQuarkAnalysis.TopObjectResolutions.stringResolutions_etEtaPhi_cff") process.kinFitTtFullHadEventHypothesis.udscResolutions = process.udscResolutionPF.functions process.kinFitTtFullHadEventHypothesis.bResolutions = process.bjetResolutionPF.functions #process.kinFitQuality_2.analyze.udscResolutions = process.udscResolutionPF.functions #process.kinFitQuality_2.analyze.bResolutions = process.bjetResolutionPF.functions #process.kinFitQuality_3.analyze.udscResolutions = process.udscResolutionPF.functions #process.kinFitQuality_3.analyze.bResolutions = process.bjetResolutionPF.functions ## run kinematic fit for CaloJets with L1L2L3L5 correted jets process.kinFitTtFullHadEventHypothesis.jetCorrectionLevel = 'L5Hadron' process.ttFullHadHypGenMatch.jetCorrectionLevel = 'L5Hadron' ## replace PFJets and PFMET with CaloJets and CaloMET from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.analyseFullHadronicSelection, 'goodJetsPF', 'goodJets') massSearchReplaceAnyInputTag(process.analyseFullHadronicSelection, 'patMETsPF' , 'patMETs') # in case of mc, smear the energy resolution additionally if(hasattr(process, 'scaledJetEnergy')): process.scaledJetEnergy.inputJets = "selectedPatJets" process.scaledJetEnergy.inputMETs = "patMETs" process.scaledJetEnergy.payload = "AK5Calo"
def dummy_beamspot(process, tag): params = getattr(DummyBeamSpots, tag) process.myBeamSpot = cms.EDProducer('DummyBeamSpotProducer', params) for name, path in process.paths.items(): if path._seq is not None: path.insert(0, process.myBeamSpot) for name, out in process.outputModules.items(): new_cmds = [] for cmd in out.outputCommands: if 'offlineBeamSpot' in cmd: new_cmds.append(cmd.replace('offlineBeamSpot', 'myBeamSpot')) out.outputCommands += new_cmds import itertools from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag for path_name, path in itertools.chain(process.paths.iteritems(), process.endpaths.iteritems()): massSearchReplaceAnyInputTag(path, cms.InputTag('offlineBeamSpot'), cms.InputTag('myBeamSpot'), verbose=True)
def _setTriggerProcess(process, triggerTag, **kwargs): # Set the input tag for the HLT # update InputTag for all modules in sequence for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.Sequence): #print "--> Resetting HLT input tag for sequence:", processAttrName patutils.massSearchReplaceAnyInputTag( processAttr, cms.InputTag("TriggerResults", "", "HLT"), triggerTag) patutils.massSearchReplaceAnyInputTag( processAttr, cms.InputTag("TriggerResults::HLT"), triggerTag) # update InputTag for PAT trigger tools if hasattr("process", "patTrigger"): process.patTrigger.processName = triggerTag.getProcessName() if hasattr("process", "patTriggerEvent"): process.patTriggerEvent.processName = triggerTag.getProcessName() # update InputTag for all histogram managers, # binner and event-dump plugins of GenericAnalyzer module for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.EDAnalyzer): if processAttr.type_() == "GenericAnalyzer": if hasattr(processAttr, "analyzers"): analyzerPlugins = getattr(processAttr, "analyzers") for analyzerPlugin in analyzerPlugins: _setattr_ifexists(analyzerPlugin, "hltResultsSource", triggerTag) if hasattr(processAttr, "eventDumps"): eventDumps = getattr(processAttr, "eventDumps") for eventDump in eventDumps: _setattr_ifexists(eventDump, "hltResultsSource", triggerTag)
# Add selectors for the different decay modes for decayMode in [0, 1, 2, 10]: selectorName = "selectedHpsTancTrainTausDecayMode%i" % decayMode setattr(process, selectorName, cms.EDFilter( "PFTauViewRefSelector", src = cms.InputTag("hpsTancTausPassingDecayMode"), cut = cms.string("decayMode = %i" % decayMode), filter = cms.bool(False) )) process.recoTauHPSTancSequence += getattr(process, selectorName) # Make copies of the signal and background tau production sequences configtools.cloneProcessingSnippet( process, process.recoTauHPSTancSequence, "Signal") configtools.massSearchReplaceAnyInputTag( process.recoTauHPSTancSequenceSignal, cms.InputTag("ak5PFJets"), cms.InputTag("preselectedSignalJets") ) configtools.cloneProcessingSnippet( process, process.recoTauHPSTancSequence, "Background") configtools.massSearchReplaceAnyInputTag( process.recoTauHPSTancSequenceBackground, cms.InputTag("ak5PFJets"), cms.InputTag("preselectedBackgroundJets") ) process.buildTaus += process.recoTauHPSTancSequenceSignal process.buildTaus += process.recoTauHPSTancSequenceBackground ################################################################################ # Define signal path ################################################################################ process.selectSignal = cms.Path(
# use custum TMVA weights process.flashggVBFMVA.vbfMVAweightfile = cms.FileInPath("flashgg/Taggers/data/Flashgg_VBF_CHS_STD_BDTG.weights.xml") process.flashggVBFMVA.MVAMethod = cms.string("BDTG") # QCD Recovery # process.flashggVBFMVA.merge3rdJet = cms.untracked.bool(False) # process.flashggVBFMVA.thirdJetDRCut = cms.untracked.double(1.5) # combined MVA boundary set process.flashggVBFTag.Boundaries = cms.vdouble(-2,0,2) # use the trigger-diphoton-preselection from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("flashggDiPhotons"),cms.InputTag("flashggPreselectedDiPhotons")) ''' # set the VBF dumper process.vbfTagDumper = createTagDumper("VBFTag") process.vbfTagDumper.dumpTrees = True process.vbfTagDumper.dumpHistos = True process.vbfTagDumper.dumpWorkspace = False # get the variable list import flashgg.Taggers.VBFTagVariables as var all_variables = var.dijet_variables + var.dipho_variables + var.truth_variables cfgTools.addCategories(process.vbfTagDumper, [ ("VBFDiJet","leadingJet.pt>0",0),
selectStableElectrons = genParticlesForJets.clone(src = cms.InputTag("selectElectrons")) #objectTypeSelectedTauValDenominatorModule = copy.deepcopy(iterativeCone5GenJets) #objectTypeSelectedTauValDenominatorModule.src = cms.InputTag("selectElectronsForGenJets") kinematicSelectedTauValDenominatorZEE = cms.EDFilter( "TauValGenPRefSelector", #"GenJetSelector" src = cms.InputTag('selectStableElectrons'), cut = kinematicSelectedTauValDenominatorCut,#cms.string('pt > 5. && abs(eta) < 2.5'), #Defined: Validation.RecoTau.RecoTauValidation_cfi filter = cms.bool(False) ) procAttributes = dir(proc) #Takes a snapshot of what there in the process helpers.cloneProcessingSnippet( proc, proc.TauValNumeratorAndDenominator, 'ZEE') #clones the sequence inside the process with ZEE postfix helpers.cloneProcessingSnippet( proc, proc.TauEfficiencies, 'ZEE') #clones the sequence inside the process with ZEE postfix helpers.massSearchReplaceAnyInputTag(proc.TauValNumeratorAndDenominatorZEE, 'kinematicSelectedTauValDenominator', 'kinematicSelectedTauValDenominatorZEE') #sets the correct input tag #adds to TauValNumeratorAndDenominator modules in the sequence ZEE to the extention name zttLabeler = lambda module : SetValidationExtention(module, 'ZEE') zttModifier = ApplyFunctionToSequence(zttLabeler) proc.TauValNumeratorAndDenominatorZEE.visit(zttModifier) #Sets the correct naming to efficiency histograms proc.efficienciesZEE.streamTag = cms.InputTag("ZEE") #checks what's new in the process (the cloned sequences and modules in them) newProcAttributes = filter( lambda x: (x not in procAttributes) and (x.find('ZEE') != -1), dir(proc) ) #spawns a local variable with the same name as the proc attribute, needed for future process.load for newAttr in newProcAttributes: locals()[newAttr] = getattr(proc,newAttr)
process.CondDBCommon.connect = "sqlite_file:flatparms_PbPb_2011.db" process.PoolDBESSource2 = cms.ESSource( "PoolDBESSource", process.CondDBCommon, toGet=cms.VPSet( cms.PSet(record=cms.string('HeavyIonRPRcd'), tag=cms.string('flatParamtest')))) # add event plane information process.ProdEvtPlane = cms.Path(process.centralityBin * process.hiEvtPlane * process.hiEvtPlaneFlat) process.e = cms.EndPath(process.outOnia2MuMu) #process.patMuonSequence = cms.Sequence( # process.bscOrHfCoinc * # process.hltOniaHI * # process.collisionEventSelection * # process.patMuonsWithTriggerSequence # ) process.schedule = cms.Schedule(process.ProdEvtPlane, process.Onia2MuMuPAT, process.e) # RegIT: replace everywhere the names of the new muon collections from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.Onia2MuMuPAT, 'muons', 'remuons') massSearchReplaceAnyInputTag(process.Onia2MuMuPAT, 'globalMuons', 'reglobalMuons')
) BestZee = cms.EDProducer( "BestMassZArbitrationProducer", # returns the Z with mass closest to 91.18 GeV ZCandidateCollection = cms.InputTag("ZeeCandElectronTrack") ) ElZLegs = cms.EDProducer( "CollectionFromZLegProducer", ZCandidateCollection = cms.InputTag("BestZee"), ) procAttributes = dir(proc) #Takes a snapshot of what there in the process helpers.cloneProcessingSnippet( proc, proc.TauValNumeratorAndDenominator, 'RealElectronsData') #clones the sequence inside the process with RealElectronsData postfix helpers.cloneProcessingSnippet( proc, proc.TauEfficiencies, 'RealElectronsData') #clones the sequence inside the process with RealElectronsData postfix helpers.massSearchReplaceAnyInputTag(proc.TauValNumeratorAndDenominatorRealElectronsData, 'kinematicSelectedTauValDenominator', cms.InputTag("ElZLegs","theProbeLeg")) #sets the correct input tag #adds to TauValNumeratorAndDenominator modules in the sequence RealElectronsData to the extention name zttLabeler = lambda module : SetValidationExtention(module, 'RealElectronsData') zttModifier = ApplyFunctionToSequence(zttLabeler) proc.TauValNumeratorAndDenominatorRealElectronsData.visit(zttModifier) binning = cms.PSet( pt = cms.PSet( nbins = cms.int32(10), min = cms.double(0.), max = cms.double(100.) ), #hinfo(75, 0., 150.) eta = cms.PSet( nbins = cms.int32(4), min = cms.double(-3.), max = cms.double(3.) ), #hinfo(60, -3.0, 3.0); phi = cms.PSet( nbins = cms.int32(4), min = cms.double(-180.), max = cms.double(180.) ), #hinfo(36, -180., 180.); pileup = cms.PSet( nbins = cms.int32(18), min = cms.double(0.), max = cms.double(72.) ),#hinfo(25, 0., 25.0); ) zttModifier = ApplyFunctionToSequence(lambda m: setBinning(m,binning)) proc.TauValNumeratorAndDenominatorRealElectronsData.visit(zttModifier) #-----------------------------------------
import flashgg.Taggers.dumperConfigTools as cfgTools from flashgg.Taggers.tagsDumpers_cfi import createTagDumper if doSystematics: from flashgg.Taggers.flashggTags_cff import UnpackedJetCollectionVInputTag from flashgg.Systematics.flashggJetSystematics_cfi import createJetSystematics process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService") jetSystematicsInputTags = createJetSystematics(process,UnpackedJetCollectionVInputTag) process.load("flashgg.Taggers.flashggTagSequence_cfi") process.load("flashgg.Taggers.flashggTagTester_cfi") if doSystematics: process.flashggTagSequence.remove(process.flashggUnpackedJets) for i in range(len(UnpackedJetCollectionVInputTag)): massSearchReplaceAnyInputTag(process.flashggTagSequence,UnpackedJetCollectionVInputTag[i],jetSystematicsInputTags[i]) process.flashggVBFTagMerger = cms.EDProducer("VBFTagMerger",src=cms.VInputTag("flashggVBFTag")) # Use JetID process.flashggVBFMVA.UseJetID = cms.bool(True) process.flashggVBFMVA.JetIDLevel = cms.string("Loose") # use custum TMVA weights process.flashggVBFMVA.vbfMVAweightfile = cms.FileInPath("flashgg/Taggers/data/Flashgg_VBF_CHS_STD_BDTG.weights.xml") process.flashggVBFMVA.MVAMethod = cms.string("BDTG") # QCD Recovery # process.flashggVBFMVA.merge3rdJet = cms.untracked.bool(False) # process.flashggVBFMVA.thirdJetDRCut = cms.untracked.double(1.5) # combined MVA boundary set
switchToPFTauHPS(process) process.cleanPatTaus.preselection = cms.string( "pt > 15 & abs(eta) < 2.3 & tauID('decayModeFinding') > 0.5 & tauID('byLooseIsolation') > 0.5" \ + " & tauID('againstMuonTight') > 0.5 & tauID('againstElectronLoose') > 0.5" ) #-------------------------------------------------------------------------------- process.p = cms.Path( process.offlinePrimaryVerticesDAwithBS + process.PFTau + process.patDefaultSequence ) # use offlinePrimaryVerticesDAwithBS Vertex collection as input for PFTau reconstruction from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.p, cms.InputTag("offlinePrimaryVerticesDA"), cms.InputTag('offlinePrimaryVerticesDAwithBS')) process.patTupleEventContent = cms.PSet( outputCommands = cms.untracked.vstring( 'drop *', # keep pat::Electrons, Muons and Taus # ( cf. PhysicsTools/PatAlgos/python/patEventContent_cff.py ) #'keep *_cleanPatElectrons*_*_*', 'keep *_cleanPatMuons*_*_*', 'keep *_cleanPatTaus*_*_*', # keep generator level information 'keep *_genParticles*_*_*', # keep all PFCandidates # ( cf. RecoParticleFlow/Configuration/python/RecoParticleFlow_EventContent_cff.py ) 'keep recoPFCandidates_particleFlow_*_*', # keep reco::PFJets reconstructed by anti-kT algorithm with dR = 0.5
process.semiLeptonicSelection * ## muon selection process.muonSelection * ## veto on additional leptons process.secondMuonVeto * process.electronVeto * ## jet selection process.leadingJetSelectionNjets * ## b tag Eff determination on MC process.bTagEff ) ## remove CaloJetCollections as not available anymore in Spring11 from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.p1, 'goodJets' , 'goodJetsPF30' ) process.p1.remove(process.centralJets) process.p1.remove(process.reliableJets) process.p1.remove(process.goodJets) process.p1.remove(process.tightLeadingJets) process.p1.remove(process.tightBottomJets) # switch to PF2PAT if(pfToPAT): from TopAnalysis.TopUtils.usePatTupleWithParticleFlow_cff import prependPF2PATSequence allpaths = process.paths_().keys() recoPaths=['p1'] # define general options PFoptions = { 'runOnMC': True, 'runOnAOD': True,
# Add selectors for the different decay modes for decayMode in [0, 1, 2, 10]: selectorName = "selectedHpsTancTrainTausDecayMode%i" % decayMode setattr( process, selectorName, cms.EDFilter("PFTauViewRefSelector", src=cms.InputTag("hpsTancTausPassingDecayMode"), cut=cms.string("decayMode = %i" % decayMode), filter=cms.bool(False))) process.recoTauHPSTancSequence += getattr(process, selectorName) # Make copies of the signal and background tau production sequences configtools.cloneProcessingSnippet(process, process.recoTauHPSTancSequence, "Signal") configtools.massSearchReplaceAnyInputTag(process.recoTauHPSTancSequenceSignal, cms.InputTag("ak5PFJets"), cms.InputTag("preselectedSignalJets")) configtools.cloneProcessingSnippet(process, process.recoTauHPSTancSequence, "Background") configtools.massSearchReplaceAnyInputTag( process.recoTauHPSTancSequenceBackground, cms.InputTag("ak5PFJets"), cms.InputTag("preselectedBackgroundJets")) process.buildTaus += process.recoTauHPSTancSequenceSignal process.buildTaus += process.recoTauHPSTancSequenceBackground ################################################################################ # Define signal path ################################################################################ process.selectSignal = cms.Path( process.tauGenJets * process.trueCommonHadronicTaus *
#process.MessageLogger.cerr.FwkReport.reportEvery = cms.untracked.int32( 100 ) # Uncomment the following if you notice you have a memory leak # This is a lightweight tool to digg further #process.SimpleMemoryCheck = cms.Service("SimpleMemoryCheck", # ignoreTotal = cms.untracked.int32(1), # monitorPssAndPrivate = cms.untracked.bool(True) # ) #process.source = cms.Source ("PoolSource",fileNames = cms.untracked.vstring("file:myMicroAODOutputFile.root")) process.source = cms.Source("PoolSource",fileNames = cms.untracked.vstring("/store/group/phys_higgs/cmshgg/mdonega/flashgg/RunIISpring15-50ns/Spring15BetaV2/ttHJetToGG_M125_13TeV_amcatnloFXFX_madspin_pythia8/RunIISpring15-50ns-Spring15BetaV2-v0-RunIISpring15DR74-Asympt50ns_MCRUN2_74_V9A-v1/150716_155334/0000/myMicroAODOutputFile_3.root")) process.load("flashgg/Taggers/flashggTagSequence_cfi") process.load("flashgg/Taggers/flashggTagTester_cfi") from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("selectedFlashggJets"),cms.InputTag("flashggJets")) massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("selectedFlashggMuons"),cms.InputTag("flashggMuons")) massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("selectedFlashggElectrons"),cms.InputTag("flashggElectrons")) from flashgg.Taggers.flashggTagOutputCommands_cff import tagDefaultOutputCommand process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('myTagOutputFile.root'), outputCommands = tagDefaultOutputCommand ) process.p = cms.Path(process.flashggTagSequence*process.flashggTagTester) process.e = cms.EndPath(process.out)
def addPF2PAT(process, dataVersion, postfix="PFlow", doTauHLTMatching=True, matchingTauTrigger=None, ): # if hasattr(process, "patDefaultSequence"): # raise Exception("PAT should not exist before calling addPF2PAT at the moment") # Hack to not to crash if something in PAT assumes process.out hasOut = hasattr(process, "out") outputCommands = [] outputCommandsBackup = [] if hasOut: outputCommandsBackup = process.out.outputCommands[:] else: process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('dummy.root'), outputCommands = cms.untracked.vstring() ) outputCommands = [] # Jet modifications # PhysicsTools/PatExamples/test/patTuple_42x_jec_cfg.py jetCorrFactors = patJetCorrLevels(dataVersion, True) jetCorrPayload = "AK5PFchs" process.load("PhysicsTools.PatAlgos.patSequences_cff") pfTools.usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", jetCorrections=(jetCorrPayload, jetCorrFactors), runOnMC=dataVersion.isMC(), postfix=postfix) outputCommands = [ # "keep *_selectedPatPhotons%s_*_*" % postfix, # 'keep *_selectedPatElectrons%s_*_*' % postfix, 'keep *_selectedPatMuons%s_*_*' % postfix, 'keep *_selectedPatJets%s*_*_*' % postfix, 'keep *_selectedPatTaus%s_*_*' % postfix, 'keep *_selectedPatPFParticles%s_*_*' % postfix, 'keep *_selectedPatJets%s_pfCandidates_*' % postfix, 'drop *_*PF_caloTowers_*', 'drop *_*JPT_pfCandidates_*', 'drop *_*Calo_pfCandidates_*', 'keep *_patMETs%s_*_*' % postfix, ] # Enable PFnoPU getattr(process, "pfPileUp"+postfix).Enable = True getattr(process, "pfPileUp"+postfix).checkClosestZVertex = False getattr(process, "pfPileUp"+postfix).Vertices = "offlinePrimaryVertices" # Jet modifications # L1FastJet # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#OffsetJEC # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCor2011 # https://hypernews.cern.ch/HyperNews/CMS/get/jes/184.html kt6name = "kt6PFJets"+postfix process.load('RecoJets.Configuration.RecoPFJets_cff') from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets setattr(process, kt6name, kt4PFJets.clone( rParam = 0.6, src = 'pfNoElectron'+postfix, doRhoFastjet = True, doAreaFastJet = cms.bool(True), )) getattr(process, "patPF2PATSequence"+postfix).replace( getattr(process, "pfNoElectron"+postfix), getattr(process, "pfNoElectron"+postfix) * getattr(process, kt6name)) getattr(process, "patJetCorrFactors"+postfix).rho = cms.InputTag(kt6name, "rho") getattr(process, "patJetCorrFactors"+postfix).useRho = True # ak5PFJets getattr(process, "pfJets"+postfix).doAreaFastjet = cms.bool(True) getattr(process, "pfJets"+postfix).doRhoFastjet = False # getattr(process, "pfJets"+postfix).Vertices = cms.InputTag("goodPrimaryVertices") setPatJetDefaults(getattr(process, "patJets"+postfix)) # Use HPS taus # Add and recalculate the discriminators addHChTauDiscriminators() if not hasattr(process, "hpsPFTauDiscriminationForChargedHiggsByLeadingTrackPtCut"): import RecoTauTag.RecoTau.PFRecoTauDiscriminationForChargedHiggs_cfi as HChPFTauDiscriminators import RecoTauTag.RecoTau.CaloRecoTauDiscriminationForChargedHiggs_cfi as HChCaloTauDiscriminators tauAlgos = ["hpsPFTau"] # tauAlgos = ["pfTaus"+postfix] HChPFTauDiscriminators.addPFTauDiscriminationSequenceForChargedHiggs(process, tauAlgos) HChPFTauDiscriminatorsCont.addPFTauDiscriminationSequenceForChargedHiggsCont(process, tauAlgos) PFTauTestDiscrimination.addPFTauTestDiscriminationSequence(process, tauAlgos) fixFlightPath(process, tauAlgos[0]) fixFlightPath(process, tauAlgos[0], "Cont") patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequence, postfix) patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequenceCont, postfix) patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusTestDiscriminationSequence, postfix) patTauSeq = cms.Sequence( getattr(process, "hpsPFTauHplusDiscriminationSequence"+postfix) * getattr(process, "hpsPFTauHplusDiscriminationSequenceCont"+postfix) * getattr(process, "hpsPFTauHplusTestDiscriminationSequence"+postfix) # getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequence") * # getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequenceCont") * # getattr(process, "pfTaus"+postfix+"HplusTestDiscriminationSequence") ) setattr(process, "hplusPatTauSequence"+postfix, patTauSeq) patHelpers.massSearchReplaceParam(patTauSeq, "PFTauProducer", cms.InputTag("hpsPFTauProducer"), cms.InputTag("pfTaus"+postfix)) patHelpers.massSearchReplaceAnyInputTag(patTauSeq, cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"), cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"+postfix)) pfTools.adaptPFTaus(process, "hpsPFTau", postfix=postfix) setPatTauDefaults(getattr(process, "patTaus"+postfix), False) addPatTauIsolationEmbedding(process, getattr(process, "patDefaultSequence"+postfix), postfix) getattr(process, "selectedPatTaus"+postfix).cut = tauPreSelection # The prediscriminant of pfTausBaseDiscriminationByLooseIsolation # is missing from the default sequence, but since we don't want to # apply any tau selections as a part of PF2PAT anyway, let's just # remove this too getattr(process, "pfTaus"+postfix).discriminators = cms.VPSet() # getattr(process, "pfTauSequence"+postfix).remove(getattr(process, "pfTaus"+postfix)) # delattr(process, "pfTaus"+postfix) # getattr(process, "pfTausBaseSequence"+postfix).remove(getattr(process, "pfTausBaseDiscriminationByLooseIsolation"+postfix)) # Remove the shrinking cone altogether, we don't care about it # getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "patShrinkingConePFTauDiscrimination"+postfix)) # Override the tau source (this is WRONG in the standard PF2PAT, the expers should know it already) # getattr(process, "patTaus"+postfix).tauSource = "hpsPFTauProducer"+postfix # patHelpers.massSearchReplaceAnyInputTag(getattr(process, "patHPSPFTauDiscrimination"+postfix), # cms.InputTag("pfTaus"+postfix), # cms.InputTag("hpsPFTauProducer"+postfix)) # getattr(process, "pfNoTau"+postfix).topCollection = cms.InputTag("hpsPFTauProducer"+postfix) # Disable iso deposits, they take a LOT of space getattr(process, "patTaus"+postfix).isoDeposits = cms.PSet() # Disable tau top projection, the taus are identified and removed # from jets as a part of the analysis getattr(process, "pfNoTau"+postfix).enable = False # Lepton modifications setPatLeptonDefaults(getattr(process, "patMuons"+postfix), False) #setPatLeptonDefaults(getattr(process, "patElectrons"+postfix), False) #addPatElectronID(process, getattr(process, "patElectrons"+postfix), getattr(process, "makePatElectrons"+postfix)) # PATElectronProducer segfaults, and we don't really need them now getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "makePatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "selectedPatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatLeptons"+postfix)) # Disable muon and electron top projections, needs wider # discussion about lepton definitions getattr(process, "pfNoMuon"+postfix).enable = False getattr(process, "pfNoElectron"+postfix).enable = False # Remove photon MC matcher in order to avoid keeping photons in the event content #process.patDefaultSequencePFlow.remove(process.photonMatchPFlow) if hasOut: process.out.outputCommands = outputCommandsBackup process.out.outputCommands.extend(outputCommands) else: del process.out getattr(process, "patDefaultSequence"+postfix).replace( getattr(process, "patTaus"+postfix), patTauSeq * getattr(process, "patTaus"+postfix) ) sequence = cms.Sequence( getattr(process, "patPF2PATSequence"+postfix) ) if doTauHLTMatching: sequence *= HChTriggerMatching.addTauHLTMatching(process, matchingTauTrigger, collections=["selectedPatTaus"+postfix], postfix=postfix) return sequence
def addBoostedTaus(process): from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("RecoTauTag.Configuration.boostedHPSPFTaus_cff") patAlgosToolsTask = configtools.getPatAlgosToolsTask(process) patAlgosToolsTask.add(process.boostedHPSPFTausTask) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # BDT-based tauIDs removed from standard tau sequence, but still used by boosed taus process.PFTauMVAIdSequence = cms.Sequence( process.hpsPFTauDiscriminationByMVA6rawElectronRejection+ process.hpsPFTauDiscriminationByMVA6ElectronRejection+ process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTraw+ process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLT+ process.hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTraw+ process.hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLT ) process.PATTauSequence = cms.Sequence( process.PFTau+process.PFTauMVAIdSequence+ process.makePatTaus+process.selectedPatTaus) process.PATTauSequenceBoosted = cloneProcessingSnippet(process,process.PATTauSequence, "Boosted", addToTask = True) process.recoTauAK4PFJets08RegionBoosted.src = 'boostedTauSeeds' process.recoTauAK4PFJets08RegionBoosted.pfCandSrc = 'particleFlow' process.recoTauAK4PFJets08RegionBoosted.pfCandAssocMapSrc = ('boostedTauSeeds', 'pfCandAssocMapForIsolation') process.ak4PFJetsLegacyHPSPiZerosBoosted.jetSrc = 'boostedTauSeeds' process.ak4PFJetsRecoTauChargedHadronsBoosted.jetSrc = 'boostedTauSeeds' process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRcone = 0.3 process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRconeLimitedToJetArea = True process.combinatoricRecoTausBoosted.jetSrc = 'boostedTauSeeds' process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('particleFlow') ## Note JetArea is not defined for subjets (-> do not switch to True in hpsPFTauDiscriminationByLooseMuonRejection3Boosted, False is default) ## The restiction to jetArea is turned to dRMatch=0.1 (-> use explicitly this modified value) process.hpsPFTauDiscriminationByMuonRejection3Boosted.dRmuonMatch = 0.1 massSearchReplaceAnyInputTag(process.PATTauSequenceBoosted,cms.InputTag("ak4PFJets"),cms.InputTag("boostedTauSeeds")) #Add BDT-based tauIDs still used by boosed taus from PhysicsTools.PatAlgos.producersLayer1.tauProducer_cfi import containerID containerID(process.patTausBoosted.tauIDSources, "hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTBoosted", "rawValues", [ ["byIsolationMVArun2DBoldDMwLTraw", "discriminator"] ]) containerID(process.patTausBoosted.tauIDSources, "hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTBoosted", "workingPoints", [ ["byVVLooseIsolationMVArun2DBoldDMwLT", "_VVLoose"], ["byVLooseIsolationMVArun2DBoldDMwLT", "_VLoose"], ["byLooseIsolationMVArun2DBoldDMwLT", "_Loose"], ["byMediumIsolationMVArun2DBoldDMwLT", "_Medium"], ["byTightIsolationMVArun2DBoldDMwLT", "_Tight"], ["byVTightIsolationMVArun2DBoldDMwLT", "_VTight"], ["byVVTightIsolationMVArun2DBoldDMwLT", "_VVTight"] ]) containerID(process.patTausBoosted.tauIDSources, "hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTBoosted", "rawValues", [ ["byIsolationMVArun2DBnewDMwLTraw", "discriminator"] ]) containerID(process.patTausBoosted.tauIDSources, "hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTBoosted", "workingPoints", [ ["byVVLooseIsolationMVArun2DBnewDMwLT", "_VVLoose"], ["byVLooseIsolationMVArun2DBnewDMwLT", "_VLoose"], ["byLooseIsolationMVArun2DBnewDMwLT", "_Loose"], ["byMediumIsolationMVArun2DBnewDMwLT", "_Medium"], ["byTightIsolationMVArun2DBnewDMwLT", "_Tight"], ["byVTightIsolationMVArun2DBnewDMwLT", "_VTight"], ["byVVTightIsolationMVArun2DBnewDMwLT", "_VVTight"] ]) containerID(process.patTausBoosted.tauIDSources, "hpsPFTauDiscriminationByMVA6ElectronRejectionBoosted", "rawValues", [ ["againstElectronMVA6Raw", "discriminator"], ["againstElectronMVA6category", "category"] ]) containerID(process.patTausBoosted.tauIDSources, "hpsPFTauDiscriminationByMVA6ElectronRejectionBoosted", "workingPoints", [ ["againstElectronVLooseMVA6", "_VLoose"], ["againstElectronLooseMVA6", "_Loose"], ["againstElectronMediumMVA6", "_Medium"], ["againstElectronTightMVA6", "_Tight"], ["againstElectronVTightMVA6", "_VTight"] ]) process.slimmedTausBoosted = process.slimmedTaus.clone(src = "selectedPatTausBoosted") patAlgosToolsTask.add(process.slimmedTausBoosted) return process
#################################################### ######## CLEANED JET COLLECTION FOR MU-TAUH ######## #################################################### process.load('CMGTools.Common.PAT.addFilterPaths_cff') print "Cleaning the jet collection for mu-tauh channel" from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("ExoDiBosonResonances.PATtupleProduction.CleanJets_cff") process.PATCMGSequence += process.primaryVertexFilter process.PATCMGSequence += process.CleanJetsMuTauSequence process.PATTauSequenceMuTau = cloneProcessingSnippet(process, process.PATTauSequence, "MuTau") massSearchReplaceAnyInputTag(process.PATTauSequenceMuTau, cms.InputTag("pfJetsForHPSTauMuTau"), cms.InputTag("ak5PFJetsNoMu")) process.PATTauSequenceMuTau.replace( process.pfJetsForHPSTauMuTau, process.primaryVertexFilter + process.CleanJetsMuTauSequence) process.PATCMGSequence += process.PATTauSequenceMuTau patEventContentCMG += ['keep *_*selectedPatTausMuTau*_*_*'] ##################################################### ######### CLEANED JET COLLECTION FOR EL-TAUH ######## ##################################################### print "Cleaning the jet collection for ele-tauh channel" process.PATCMGSequence += process.CleanJetsETauSequence process.PATTauSequenceEleTau = cloneProcessingSnippet(process, process.PATTauSequence, "EleTau")
process.schedule.append(process.rerunMCMatchPath) fs_daughter_inputs['electrons'] = 'cleanPatElectronsRematched' fs_daughter_inputs['muons'] = 'cleanPatMuonsRematched' fs_daughter_inputs['taus'] = 'cleanPatTausRematched' fs_daughter_inputs['photons'] = 'photonParentage' fs_daughter_inputs['jets'] = 'selectedPatJetsRematched' if options.rerunQGJetID: process.schedule.append( rerun_QGJetID(process, fs_daughter_inputs) ) if options.runNewElectronMVAID: process.load("FinalStateAnalysis.PatTools.electrons.patElectronSummer13MVAID_cfi") helpers.massSearchReplaceAnyInputTag( process.runAndEmbedSummer13Id, 'fixme', fs_daughter_inputs['electrons']) fs_daughter_inputs['electrons'] = 'patElectrons2013MVAID' process.runNewElectronMVAID = cms.Path(process.runAndEmbedSummer13Id) process.schedule.append(process.runNewElectronMVAID) # Eventually, set buildFSAEvent to False, currently working around bug # in pat tuples. produce_final_states(process, fs_daughter_inputs, [], process.buildFSASeq, 'puTagDoesntMatter', buildFSAEvent=True, noTracks=True, noPhotons=options.noPhotons) process.buildFSAPath = cms.Path(process.buildFSASeq) # Don't crash if some products are missing (like tracks) process.patFinalStateEventProducer.forbidMissing = cms.bool(False) process.schedule.append(process.buildFSAPath)
process.fjSequence* process.patDefaultSequence* process.kt6PFJetsNeutral* process.selectedPatMuonsTriggerMatchUserEmbedded* process.selectedPatElectronsTriggerMatchUserEmbedded* process.selectedPatTausTriggerMatchUserEmbedded* process.muSequence+ process.elecSequence+ process.tauSequence+ process.tauNTuplizer+ process.printTree1 ) massSearchReplaceAnyInputTag(process.run, "offlinePrimaryVertices", "selectedPrimaryVertices", verbose=False) process.selectedPrimaryVertices.src = cms.InputTag('offlinePrimaryVertices') if not runOnMC: process.run.remove(process.printTree1) process.p = cms.Path(process.run) ########################## output ############################### from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning process.out.outputCommands = cms.untracked.vstring('drop *', *patEventContentNoCleaning )
ZCandidateCollection=cms.InputTag("ZmmCandMuonTrack")) MuZLegs = cms.EDProducer( "CollectionFromZLegProducer", ZCandidateCollection=cms.InputTag("BestZmm"), ) procAttributes = dir(proc) #Takes a snapshot of what there in the process helpers.cloneProcessingSnippet( proc, proc.TauValNumeratorAndDenominator, 'RealMuonsData' ) #clones the sequence inside the process with RealMuonsData postfix helpers.cloneProcessingSnippet( proc, proc.TauEfficiencies, 'RealMuonsData' ) #clones the sequence inside the process with RealMuonsData postfix helpers.massSearchReplaceAnyInputTag( proc.TauValNumeratorAndDenominatorRealMuonsData, 'kinematicSelectedTauValDenominator', cms.InputTag("MuZLegs", "theProbeLeg")) #sets the correct input tag #adds to TauValNumeratorAndDenominator modules in the sequence RealMuonsData to the extention name zttLabeler = lambda module: SetValidationExtention(module, 'RealMuonsData') zttModifier = ApplyFunctionToSequence(zttLabeler) proc.TauValNumeratorAndDenominatorRealMuonsData.visit(zttModifier) binning = cms.PSet( pt=cms.PSet(nbins=cms.int32(10), min=cms.double(0.), max=cms.double(100.)), #hinfo(75, 0., 150.) eta=cms.PSet(nbins=cms.int32(4), min=cms.double(-3.), max=cms.double(3.)), #hinfo(60, -3.0, 3.0); phi=cms.PSet(nbins=cms.int32(4), min=cms.double(-180.), max=cms.double(180.)), #hinfo(36, -180., 180.);
"TauValPFJetSelector", src = cms.InputTag('kinematicSelectedPFJets'), cut = cms.string("chargedHadronEnergyFraction > 0.0 & neutralHadronEnergyFraction < 0.99 & neutralHadronEnergyFraction < 0.99 & chargedEmEnergyFraction < 0.99 & chargedEmEnergyFraction < 0.99 & neutralEmEnergyFraction < 0.99 & chargedMultiplicity > 0 & nConstituents > 1"), filter = cms.bool(False) ) CleanedPFJets = cms.EDProducer("TauValJetViewCleaner", srcObject = cms.InputTag( "kinematicSelectedPFJets" ), srcObjectsToRemove = cms.VInputTag( cms.InputTag("muons"), cms.InputTag("gedGsfElectrons") ), deltaRMin = cms.double(0.15) ) procAttributes = dir(proc) #Takes a snapshot of what there in the process helpers.cloneProcessingSnippet( proc, proc.TauValNumeratorAndDenominator, 'RealData') #clones the sequence inside the process with RealData postfix helpers.cloneProcessingSnippet( proc, proc.TauEfficiencies, 'RealData') #clones the sequence inside the process with RealData postfix helpers.massSearchReplaceAnyInputTag(proc.TauValNumeratorAndDenominatorRealData, 'kinematicSelectedTauValDenominator', 'CleanedPFJets') #sets the correct input tag #adds to TauValNumeratorAndDenominator modules in the sequence RealData to the extention name zttLabeler = lambda module : SetValidationExtention(module, 'RealData') zttModifier = ApplyFunctionToSequence(zttLabeler) proc.TauValNumeratorAndDenominatorRealData.visit(zttModifier) binning = cms.PSet( pt = cms.PSet( nbins = cms.int32(25), min = cms.double(0.), max = cms.double(250.) ), #hinfo(75, 0., 150.) eta = cms.PSet( nbins = cms.int32(4), min = cms.double(-3.), max = cms.double(3.) ), #hinfo(60, -3.0, 3.0); phi = cms.PSet( nbins = cms.int32(4), min = cms.double(-180.), max = cms.double(180.) ), #hinfo(36, -180., 180.); pileup = cms.PSet( nbins = cms.int32(18), min = cms.double(0.), max = cms.double(72.) ),#hinfo(25, 0., 25.0); ) zttModifier = ApplyFunctionToSequence(lambda m: setBinning(m,binning)) proc.TauValNumeratorAndDenominatorRealData.visit(zttModifier) #-----------------------------------------
def switchToData(process): # remove MC matching from standard PAT sequences if hasattr(process, "patDefaultSequence"): removeMCMatching(process, ["All"], outputModules=[]) process.patDefaultSequence.remove(process.patJetPartonMatch) #------------------------------------------------------------------------ # CV: temporary work-around for W --> tau nu channel modulesToRemove = [ "patJetPartonMatchAK5PF", "patJetGenJetMatchAK5PF", "patJetPartons", "patJetPartonAssociation", "patJetPartonAssociationAK5PF", "patJetFlavourAssociation", "patJetFlavourAssociationAK5PF" ] for moduleToRemove in modulesToRemove: if hasattr(process, moduleToRemove): process.patDefaultSequence.remove(getattr(process, moduleToRemove)) if hasattr(process, "patJetCorrFactorsAK5PF"): process.patJetCorrFactorsAK5PF.levels.append("L2L3Residual") #------------------------------------------------------------------------ # add data-quality cuts which work on "real" data only if hasattr(process, "dataQualityFilters"): process.dataQualityFilters._seq = process.dataQualityFilters._seq * process.hltPhysicsDeclared process.dataQualityFilters._seq = process.dataQualityFilters._seq * process.dcsstatus # apply L2/L3 residual jet energy corrections # (for improved Data and Monte-Carlo agreement) if hasattr(process, "pfMEtType1and2corrected"): setattr(process.pfMEtType1and2corrected, "corrector", cms.string('ak5PFL2L3Residual')) if hasattr(process, "patPFMETs"): process.patPFMETs.addGenMET = cms.bool(False) if hasattr(process, "patPFtype1METs"): process.patPFtype1METs.addGenMET = cms.bool(False) # remove modules from pre-PAT production running on genParticles if hasattr(process, "producePrePat"): process.producePrePat.remove(process.genParticlesForJets) process.producePrePat.remove(process.ak5GenJets) # remove modules from PAT-tuple production sequence running on genParticles if hasattr(process, "producePatTuple"): if hasattr(process, "genParticlesForJets"): process.producePatTuple.remove(process.genParticlesForJets) if hasattr(process, "ak5GenJets"): process.producePatTuple.remove(process.ak5GenJets) # remove modules from post-PAT production running on genParticles if hasattr(process, "producePostPat"): process.producePostPat.remove(process.produceGenObjects) # iterate over all sequences attached to process object and # recursively disable gen. matching for all modules in sequence for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.Sequence): print "--> Disabling gen. Matching for sequence:", processAttrName # replace all InputTags referring to # o genParticleSource = cms.InputTag('genParticles') --> "" # o genJetSource = cms.InputTag('iterativeCone5GenJets') --> "" # o genJetSource = cms.InputTag('ak5GenJets') --> "" # o genTauJetSource = cms.InputTag('tauGenJets') --> "" # o genMEtSource = cms.InputTag('genMetTrue') --> "" patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('genParticles'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag( processAttr, cms.InputTag('iterativeCone5GenJets'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('ak5GenJets'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('tauGenJets'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('genMetTrue'), cms.InputTag('')) # replace all InputTags referring to gen. Z decay products # in electron + tau-jet Zee (muon + tau-jet Zmumu) hypotheses patutils.massSearchReplaceAnyInputTag( processAttr, cms.InputTag('genElectronsFromZs'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag( processAttr, cms.InputTag('genMuonsFromZs'), cms.InputTag('')) # disable generator level matching for all PATJetProducer modules for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance( processAttr, cms.EDProducer) and processAttr.type_() == "PATJetProducer": print "--> Disabling gen. Matching for module:", processAttrName setattr(processAttr, "addGenJetMatch", cms.bool(False)) setattr(processAttr, "addGenPartonMatch", cms.bool(False)) setattr(processAttr, "addPartonJetMatch", cms.bool(False)) # disable access to generator level information in all # histogram managers, binner and event-dump plugins of GenericAnalyzer module for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance( processAttr, cms.EDAnalyzer) and processAttr.type_() == "GenericAnalyzer": # disable matching between gen. and rec. particles # in all histogram managers and binner plugins by setting # o genParticleSource = cms.InputTag('genParticles') --> "" # o genJetSource = cms.InputTag('iterativeCone5GenJets') --> "" # o genJetSource = cms.InputTag('ak5GenJets') --> "" # o genTauJetSource = cms.InputTag('tauGenJets') --> "" # o genMEtSource = cms.InputTag('genMetTrue') --> "" if hasattr(processAttr, "analyzers"): analyzerPlugins = getattr(processAttr, "analyzers") for analyzerPlugin in analyzerPlugins: _setattr_ifexists(analyzerPlugin, "genParticleSource", cms.InputTag('')) _setattr_ifexists(analyzerPlugin, "genJetSource", cms.InputTag('')) _setattr_ifexists(analyzerPlugin, "genTauJetSource", cms.InputTag('')) _setattr_ifexists(analyzerPlugin, "genMEtSource", cms.InputTag('')) # remove from all analysis sequences the following objects: # o genPhaseSpaceInfoHistManager # o modelBinnerForMuTauGenTauLeptonPairAcc # o modelBinnerForMuTauWrtGenTauLeptonPairAcc # o modelBinnerForMuTauGenTauLeptonPairAcc3mZbins # o modelBinnerForMuTauWrtGenTauLeptonPairAcc3mZbins # o modelBinnerForMuTauCentralJetVetoWrtGenTauLeptonPairAcc # o modelBinnerForMuTauCentralJetBtagWrtGenTauLeptonPairAcc # o sysUncertaintyBinnerForMuTau # o diTauCandidateCollinearApproxHistManagerBinnedForMuTau analyzerPluginsToRemove = [ "genPhaseSpaceEventInfoHistManager", "genTauHistManager", "cutFlowHistManagerGenMultiplicity", "modelBinnerForMuTauGenTauLeptonPairAcc", "modelBinnerForMuTauWrtGenTauLeptonPairAcc", "modelBinnerForMuTauGenTauLeptonPairAcc3mZbins", "modelBinnerForMuTauWrtGenTauLeptonPairAcc3mZbins", "modelBinnerForMuTauCentralJetVetoWrtGenTauLeptonPairAcc", "modelBinnerForMuTauCentralJetBtagWrtGenTauLeptonPairAcc", "sysUncertaintyBinnerForMuTau", "diTauCandidateCollinearApproxHistManagerBinnedForMuTau" ] for analyzerPluginName in analyzerPluginsToRemove: if hasattr(process, analyzerPluginName): analyzerPlugin = getattr(process, analyzerPluginName) if processAttr.analyzers.count(analyzerPlugin) > 0: processAttr.analyzers.remove(analyzerPlugin) removeAnalyzer(processAttr.analysisSequence, analyzerPluginName) # disable matching between gen. and rec. particles in all event-dump plugins by setting # o doGenInfo = cms.bool(True) --> cms.bool(False) # o genParticleSource = cms.InputTag('genParticles') --> "" if hasattr(processAttr, "eventDumps"): eventDumpPlugins = getattr(processAttr, "eventDumps") for eventDumpPlugin in eventDumpPlugins: eventDumpPlugin.doGenInfo = cms.bool(False) eventDumpPlugin.genParticleSource = cms.InputTag('') # disable estimation of systematic uncertainties by setting # o analyzers_systematic = cms.VPSet(..) --> cms.VPSet() processAttr.analyzers.analyzers_systematic = cms.VPSet() for processAttrName in dir(process): processAttr = getattr(process, processAttrName) _setattr_ifexists(processAttr, "isData", cms.bool(True))
def configurePatTupleProduction(process, patSequenceBuilder=buildGenericTauSequence, patPFTauCleanerPrototype=None, patCaloTauCleanerPrototype=None, addSVfitInfo=False, hltProcess="HLT", isMC=False, applyTauVertexMatch=True): # check that patSequenceBuilder and patTauCleanerPrototype are defined and non-null if patSequenceBuilder is None: raise ValueError("Undefined 'patSequenceBuilder' Parameter !!") if patPFTauCleanerPrototype is None or patCaloTauCleanerPrototype is None: raise ValueError("Undefined 'patTauCleanerPrototype' Parameter !!") #-------------------------------------------------------------------------------- # produce PAT objects #-------------------------------------------------------------------------------- process.load("PhysicsTools.PatAlgos.patSequences_cff") process.load("PhysicsTools.PatAlgos.producersLayer1.tauProducer_cff") process.load("PhysicsTools.PatAlgos.producersLayer1.muonProducer_cff") process.load("PhysicsTools.PatAlgos.producersLayer1.metProducer_cff") process.load("TauAnalysis.CandidateTools.muTauPairProduction_cff") # per default, do **not** run SVfit algorithm if not addSVfitInfo: process.allMuTauPairs.doSVreco = cms.bool(False) process.allMuTauPairs.doPFMEtSign = cms.bool(False) process.allMuTauPairsLooseMuonIsolation.doSVreco = cms.bool(False) process.allMuTauPairsLooseMuonIsolation.doPFMEtSign = cms.bool(False) if not isMC: removeMCMatching(process, ["All"], outputModules=[]) else: # match pat::Taus to all genJets # (including to genJets build from electrons/muons produced in tau --> e/mu decays) process.tauGenJetMatch.matched = cms.InputTag("tauGenJets") #-------------------------------------------------------------------------------- # configure PAT trigger matching switchOnTrigger(process, hltProcess=hltProcess, outputModule='') # CV: disable L1Algos in MC for now, to prevent error messages # # %MSG-e L1GlobalTriggerObjectMapRecord: PATTriggerProducer:patTrigger # # ERROR: The requested algorithm name = L1_DoubleEG1 # does not exists in the trigger menu. # Returning zero pointer for getObjectMap # # to be printed for every event (06/05/2011) # # for Data the L1Algos flag needs to be enabled, # in order for the prescale computation/correction for Data # implemented in TauAnalysis/TauIdEfficiency/bin/FWLiteTauIdEffAnalyzer.cc to work if isMC: process.patTrigger.addL1Algos = cms.bool(False) else: process.patTrigger.addL1Algos = cms.bool(True) process.patTauTriggerMatchHLTprotoType = cms.EDProducer( "PATTriggerMatcherDRLessByR", src=cms.InputTag("cleanLayer1Taus"), matched=cms.InputTag("patTrigger"), matchedCuts=cms.string('path("HLT_Jet30_v*")'), maxDPtRel=cms.double(1.e+3), maxDeltaR=cms.double(0.5), resolveAmbiguities=cms.bool(True), resolveByMatchQuality=cms.bool(True)) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # compute Pt sum of charged + neutral hadrons and photons within isolation cones of size dR = 0.4/0.6 process.load("RecoMuon/MuonIsolation/muonPFIsolation_cff") patutils.massSearchReplaceAnyInputTag( process.muonPFIsolationDepositsSequence, cms.InputTag('muons1stStep'), cms.InputTag('muons')) process.patMuons.isoDeposits = cms.PSet( # CV: strings for IsoDeposits defined in PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc pfChargedHadrons=cms.InputTag("muPFIsoDepositCharged"), pfNeutralHadrons=cms.InputTag("muPFIsoDepositNeutral"), pfPhotons=cms.InputTag("muPFIsoDepositGamma"), user=cms.VInputTag(cms.InputTag("muPFIsoDepositChargedAll"), cms.InputTag("muPFIsoDepositPU"))) process.patMuons.userIsolation = cms.PSet( # CV: strings for Isolation values defined in PhysicsTools/PatAlgos/src/MultiIsolator.cc pfChargedHadron=cms.PSet( deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.pfChargedHadrons, vetos=process.muPFIsoValueCharged04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueCharged04.deposits[0]. skipDefaultVeto), pfNeutralHadron=cms.PSet( deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.pfNeutralHadrons, vetos=process.muPFIsoValueNeutral04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueNeutral04.deposits[0]. skipDefaultVeto), pfGamma=cms.PSet(deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.pfPhotons, vetos=process.muPFIsoValueGamma04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueGamma04. deposits[0].skipDefaultVeto), user=cms.VPSet( cms.PSet(deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.user[0], vetos=process.muPFIsoValueChargedAll04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValueChargedAll04. deposits[0].skipDefaultVeto), cms.PSet(deltaR=cms.double(0.4), src=process.patMuons.isoDeposits.user[1], vetos=process.muPFIsoValuePU04.deposits[0].vetos, skipDefaultVeto=process.muPFIsoValuePU04.deposits[0]. skipDefaultVeto))) process.patMuonsWithinAcc = cms.EDFilter( "PATMuonSelector", src=cms.InputTag('patMuons'), cut=cms.string("pt > 15. & abs(eta) < 2.1"), filter=cms.bool(False)) process.selectedPatMuonsVBTFid = cms.EDFilter( "PATMuonIdSelector", src=cms.InputTag('patMuonsWithinAcc'), vertexSource=cms.InputTag('selectedPrimaryVertexPosition'), beamSpotSource=cms.InputTag('offlineBeamSpot'), filter=cms.bool(False)) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collections of pat::Jets for CaloJets and PFJets # # NOTE: needed for evaluating jetId for Calo/TCTaus and PFTaus # jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] if not isMC: jec.extend(['L2L3Residual']) addJetCollection(process, cms.InputTag('ak5PFJets'), 'AK5', 'PF', doJTA=False, doBTagging=False, jetCorrLabel=('AK5PF', cms.vstring(jec)), doType1MET=False, genJetCollection=cms.InputTag("ak5GenJets"), doJetID=True, jetIdLabel="ak5", outputModules=[]) addJetCollection(process, cms.InputTag('ak5CaloJets'), 'AK5', 'Calo', doJTA=False, doBTagging=False, jetCorrLabel=('AK5Calo', cms.vstring(jec)), doType1MET=False, genJetCollection=cms.InputTag("ak5GenJets"), doJetID=True, jetIdLabel="ak5", outputModules=[]) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # configure Jet Energy Corrections # process.load("TauAnalysis.Configuration.jetCorrectionParameters_cfi") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # add pfMET process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff") if isMC: import PhysicsTools.PatAlgos.tools.helpers as configtools configtools.cloneProcessingSnippet(process, process.producePatPFMETCorrections, "NoSmearing") process.selectedPatJetsForMETtype1p2CorrNoSmearing.src = cms.InputTag( 'patJetsNotOverlappingWithLeptonsForMEtUncertainty') process.selectedPatJetsForMETtype2CorrNoSmearing.src = process.selectedPatJetsForMETtype1p2CorrNoSmearing.src process.patMEtProductionSequence = cms.Sequence() process.patMEtProductionSequence += process.patDefaultSequence from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties doSmearJets = None if isMC: doSmearJets = True else: doSmearJets = False runMEtUncertainties( process, electronCollection='', photonCollection='', muonCollection=cms.InputTag('selectedPatMuonsVBTFid'), tauCollection='', jetCollection=cms.InputTag('patJetsAK5PF'), doSmearJets=doSmearJets, doApplyType0corr=True, sysShiftCorrParameter=None, doApplySysShiftCorr=False, # CV: shift Jet energy by 3 standard-deviations, # so that template morphing remains an interpolation and no extrapolation is needed varyByNsigmas=3.0, addToPatDefaultSequence=False) if isMC: process.patPFMet.addGenMET = cms.bool(True) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute") process.patMEtProductionSequence += process.metUncertaintySequence else: process.patPFMet.addGenMET = cms.bool(False) process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string( "L2L3Residual") process.patMEtProductionSequence += process.patJetsAK5PFnotOverlappingWithLeptonsForMEtUncertainty process.patMEtProductionSequence += process.producePatPFMETCorrections #-------------------------------------------------------------------------------- pfJetCollection = 'patJetsAK5PFnotOverlappingWithLeptonsForMEtUncertainty' pfMEtCollection = 'patType1CorrectedPFMet' if isMC: pfJetCollection = 'smearedPatJetsAK5PF' #-------------------------------------------------------------------------------- # # produce combinations of muon + tau-jet pairs # for collection of pat::Tau objects representing CaloTaus # switchToCaloTau(process) process.patCaloTauProducer = copy.deepcopy(process.patTaus) retVal_caloTau = patSequenceBuilder( process, collectionName=["patCaloTaus", ""], jetCollectionName="patJetsAK5Calo", patTauProducerPrototype=process.patCaloTauProducer, patTauCleanerPrototype=patCaloTauCleanerPrototype, triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType, addGenInfo=isMC, applyTauJEC=False, applyTauVertexMatch=applyTauVertexMatch) process.caloTauSequence = retVal_caloTau["sequence"] process.patMuonCaloTauPairs = process.allMuTauPairs.clone( srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'), srcLeg2=cms.InputTag(retVal_caloTau["collection"]), srcMET=cms.InputTag('patMETs'), srcGenParticles=cms.InputTag(''), doSVreco=cms.bool(False), doPFMEtSign=cms.bool(False)) if hasattr(process.patMuonCaloTauPairs, "nSVfit"): delattr(process.patMuonCaloTauPairs, "nSVfit") if hasattr(process.patMuonCaloTauPairs, "pfMEtSign"): delattr(process.patMuonCaloTauPairs, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by fixed signal cone algorithm # (plus combinations of muon + tau-jet pairs) # #switchToPFTauFixedCone(process) #process.patPFTauProducerFixedCone = copy.deepcopy(process.patTaus) # #retVal_pfTauFixedCone = patSequenceBuilder( # process, # collectionName = [ "patPFTaus", "FixedCone" ], # jetCollectionName = pfJetCollection, # patTauProducerPrototype = process.patPFTauProducerFixedCone, # patTauCleanerPrototype = patPFTauCleanerPrototype, # triggerMatcherProtoType = process.patTauTriggerMatchHLTprotoType, # addGenInfo = isMC, # applyTauJEC = False, # applyTauVertexMatch = applyTauVertexMatch #) #process.pfTauSequenceFixedCone = retVal_pfTauFixedCone["sequence"] # #process.patMuonPFTauPairsFixedCone = process.allMuTauPairs.clone( # srcLeg1 = cms.InputTag('selectedPatMuonsVBTFid'), # srcLeg2 = cms.InputTag(retVal_pfTauFixedCone["collection"]), # srcMET = cms.InputTag(pfMEtCollection), # srcGenParticles = cms.InputTag(''), # doSVreco = cms.bool(False) #) #if hasattr(process.patMuonPFTauPairsFixedCone, "nSVfit"): # delattr(process.patMuonPFTauPairsFixedCone, "nSVfit") #if hasattr(process.patMuonPFTauPairsFixedCone, "pfMEtSign"): # delattr(process.patMuonPFTauPairsFixedCone, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by shrinking signal cone algorithm # (plus combinations of muon + tau-jet pairs) # #switchToPFTauShrinkingCone(process) #process.patPFTauProducerShrinkingCone = copy.deepcopy(process.patTaus) # #retVal_pfTauShrinkingCone = patSequenceBuilder( # process, # collectionName = [ "patPFTaus", "ShrinkingCone" ], # jetCollectionName = pfJetCollection, # patTauProducerPrototype = process.patPFTauProducerShrinkingCone, # patTauCleanerPrototype = patPFTauCleanerPrototype, # triggerMatcherProtoType = process.patTauTriggerMatchHLTprotoType, # addGenInfo = isMC, # applyTauJEC = False, # applyTauVertexMatch = applyTauVertexMatch #) #process.pfTauSequenceShrinkingCone = retVal_pfTauShrinkingCone["sequence"] # #process.patMuonPFTauPairsShrinkingCone = process.allMuTauPairs.clone( # srcLeg1 = cms.InputTag('selectedPatMuonsVBTFid'), # srcLeg2 = cms.InputTag(retVal_pfTauShrinkingCone["collection"]), # srcMET = cms.InputTag(pfMEtCollection), # srcGenParticles = cms.InputTag(''), # doSVreco = cms.bool(False) #) #if hasattr(process.patMuonPFTauPairsShrinkingCone, "nSVfit"): # delattr(process.patMuonPFTauPairsShrinkingCone, "nSVfit") #if hasattr(process.patMuonPFTauPairsShrinkingCone, "pfMEtSign"): # delattr(process.patMuonPFTauPairsShrinkingCone, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by hadron + strips (HPS) algorithm # (plus combinations of muon + tau-jet pairs) # # NOTE: switchToPFTauHPS function overwrites process.cleanPatTaus.preselection using HPS specific discriminators; # undo overwriting, in order to prevent run-time errors in case of subsequence _switchToPFTau call, # arising from the fact that HPS specific discriminators are not available for all tau types # switchToPFTauHPS(process) process.cleanPatTaus.preselection = cms.string('') process.patPFTauProducerHPS = copy.deepcopy(process.patTaus) retVal_pfTauHPS = patSequenceBuilder( process, collectionName=["patPFTaus", "HPS"], jetCollectionName=pfJetCollection, patTauProducerPrototype=process.patPFTauProducerHPS, patTauCleanerPrototype=patPFTauCleanerPrototype, triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType, addGenInfo=isMC, applyTauJEC=True, applyTauVertexMatch=applyTauVertexMatch) process.pfTauSequenceHPS = retVal_pfTauHPS["sequence"] process.patMuonPFTauPairsHPS = process.allMuTauPairs.clone( srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'), srcLeg2=cms.InputTag(retVal_pfTauHPS["collection"]), srcMET=cms.InputTag(pfMEtCollection), srcGenParticles=cms.InputTag(''), doSVreco=cms.bool(False)) if hasattr(process.patMuonPFTauPairsHPS, "nSVfit"): delattr(process.patMuonPFTauPairsHPS, "nSVfit") if hasattr(process.patMuonPFTauPairsHPS, "pfMEtSign"): delattr(process.patMuonPFTauPairsHPS, "pfMEtSign") #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # produce collection of pat::Tau objects representing PFTaus # reconstructed by HPS + TaNC combined tau id. algorithm # (plus combinations of muon + tau-jet pairs) # switchToPFTauHPSpTaNC(process) process.cleanPatTaus.preselection = cms.string('') process.patPFTauProducerHPSpTaNC = copy.deepcopy(process.patTaus) retVal_pfTauHPSpTaNC = patSequenceBuilder( process, collectionName=["patPFTaus", "HPSpTaNC"], jetCollectionName=pfJetCollection, patTauProducerPrototype=process.patPFTauProducerHPSpTaNC, patTauCleanerPrototype=patPFTauCleanerPrototype, triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType, addGenInfo=isMC, applyTauJEC=True, applyTauVertexMatch=applyTauVertexMatch) process.pfTauSequenceHPSpTaNC = retVal_pfTauHPSpTaNC["sequence"] process.patMuonPFTauPairsHPSpTaNC = process.allMuTauPairs.clone( srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'), srcLeg2=cms.InputTag(retVal_pfTauHPSpTaNC["collection"]), srcMET=cms.InputTag(pfMEtCollection), srcGenParticles=cms.InputTag(''), doSVreco=cms.bool(False)) if hasattr(process.patMuonPFTauPairsHPSpTaNC, "nSVfit"): delattr(process.patMuonPFTauPairsHPSpTaNC, "nSVfit") if hasattr(process.patMuonPFTauPairsHPSpTaNC, "pfMEtSign"): delattr(process.patMuonPFTauPairsHPSpTaNC, "pfMEtSign") #-------------------------------------------------------------------------------- process.patTupleProductionSequence = cms.Sequence( process.muonPFIsolationSequence + process.patDefaultSequence ##+ process.patTrigger + process.patTriggerEvent + process.patMuonsWithinAcc + process.selectedPatMuonsVBTFid + process.patMEtProductionSequence + process.caloTauSequence # store TaNC inputs as discriminators #+ process.produceTancMVAInputDiscriminators #+ process.pfTauSequenceFixedCone #+ process.pfTauSequenceShrinkingCone + process.pfTauSequenceHPS + process.pfTauSequenceHPSpTaNC + process.patMuonCaloTauPairs #+ process.patMuonPFTauPairsFixedCone #+ process.patMuonPFTauPairsShrinkingCone + process.patMuonPFTauPairsHPS + process.patMuonPFTauPairsHPSpTaNC) # return names of "final" collections of CaloTaus/different types of PFTaus # to be used as InputTag for further processing retVal = {} retVal["caloTauCollection"] = retVal_caloTau["collection"] retVal["muonCaloTauCollection"] = process.patMuonCaloTauPairs.label() #retVal["pfTauCollectionFixedCone"] = retVal_pfTauFixedCone["collection"] #retVal["muonPFTauCollectionFixedCone"] = process.patMuonPFTauPairsFixedCone.label() #retVal["pfTauCollectionShrinkingCone"] = retVal_pfTauShrinkingCone["collection"] #retVal["muonPFTauCollectionShrinkingCone"] = process.patMuonPFTauPairsShrinkingCone.label() retVal["pfTauCollectionHPS"] = retVal_pfTauHPS["collection"] retVal["muonPFTauCollectionHPS"] = process.patMuonPFTauPairsHPS.label() retVal["pfTauCollectionHPSpTaNC"] = retVal_pfTauHPSpTaNC["collection"] retVal[ "muonPFTauCollectionHPSpTaNC"] = process.patMuonPFTauPairsHPSpTaNC.label( ) return retVal
flashggUnpackedJets = cms.EDProducer("FlashggVectorVectorJetUnpacker", JetsTag = cms.InputTag("flashggFinalJets"), NCollections = cms.uint32(maxJetCollections) ) UnpackedJetCollectionVInputTag = cms.VInputTag() for i in range(0,maxJetCollections): UnpackedJetCollectionVInputTag.append(cms.InputTag('flashggUnpackedJets',str(i))) ############################ # Systematics # ############################ process.load("flashgg.Systematics.flashggDiPhotonSystematics_cfi") from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet,massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("flashggDiPhotons"),cms.InputTag("flashggDiPhotonSystematics")) massSearchReplaceAnyInputTag(process.flashggTagSequence,cms.InputTag("flashggPreselectedDiPhotons"),cms.InputTag("flashggDiPhotonSystematics")) process.flashggSystTagMerger = cms.EDProducer("TagMerger",src=cms.VInputTag("flashggTagSorter")) process.systematicsTagSequences = cms.Sequence() systlabels = [""] phosystlabels = [] #if customize.processId.count("h_") or customize.processId.count("vbf_"): # convention: ggh vbf wzh tth if customize.processId == "signal": print "Signal MC, so adding systematics and dZ" #variablesToUse = minimalVariables for direction in ["Up","Down"]: #phosystlabels.append("MvaShift%s01sigma" % direction) #phosystlabels.append("SigmaEOverEShift%s01sigma" % direction) #jetsystlabels.append("JEC%s01sigma" % direction)
fs_daughter_inputs['photons'] = 'photonParentage' fs_daughter_inputs['jets'] = 'selectedPatJetsRematched' if options.rerunQGJetID: process.schedule.append( rerun_QGJetID(process, fs_daughter_inputs) ) if options.rerunJets: process.schedule.append(rerun_jets(process)) if options.runNewElectronMVAID: process.load("FinalStateAnalysis.PatTools." "electrons.patElectronSummer13MVAID_cfi") helpers.massSearchReplaceAnyInputTag( process.runAndEmbedSummer13Id, 'fixme', fs_daughter_inputs['electrons']) fs_daughter_inputs['electrons'] = 'patElectrons2013MVAID' process.runNewElectronMVAID = cms.Path(process.runAndEmbedSummer13Id) process.schedule.append(process.runNewElectronMVAID) # Eventually, set buildFSAEvent to False, currently working around bug # in pat tuples. produce_final_states(process, fs_daughter_inputs, [], process.buildFSASeq, 'puTagDoesntMatter', buildFSAEvent=True, noTracks=True, noPhotons=options.noPhotons, zzMode=options.zzMode, rochCor=options.rochCor, eleCor=options.eleCor) process.buildFSAPath = cms.Path(process.buildFSASeq) # Don't crash if some products are missing (like tracks) process.patFinalStateEventProducer.forbidMissing = cms.bool(False)
kinematicSelectedTauValDenominatorQCD = cms.EDFilter( "GenJetSelector", #"GenJetSelector" src=cms.InputTag('ak4GenJets'), cut= kinematicSelectedTauValDenominatorCut, #cms.string('pt > 5. && abs(eta) < 2.5'), #Defined: Validation.RecoTau.RecoTauValidation_cfi filter=cms.bool(False)) procAttributes = dir(proc) #Takes a snapshot of what there in the process helpers.cloneProcessingSnippet( proc, proc.TauValNumeratorAndDenominator, 'QCD') #clones the sequence inside the process with QCD postfix helpers.cloneProcessingSnippet( proc, proc.TauEfficiencies, 'QCD') #clones the sequence inside the process with QCD postfix helpers.massSearchReplaceAnyInputTag( proc.TauValNumeratorAndDenominatorQCD, 'kinematicSelectedTauValDenominator', 'kinematicSelectedTauValDenominatorQCD') #sets the correct input tag #adds to TauValNumeratorAndDenominator modules in the sequence QCD to the extention name zttLabeler = lambda module: SetValidationExtention(module, 'QCD') zttModifier = ApplyFunctionToSequence(zttLabeler) proc.TauValNumeratorAndDenominatorQCD.visit(zttModifier) #Set discriminators discs_to_retain = [ 'ByDecayModeFinding', 'CombinedIsolationDBSumPtCorr3Hits', 'IsolationMVArun2v1DBoldDMwLT', 'IsolationMVArun2v1DBnewDMwLT' ] proc.RunHPSValidationQCD.discriminators = cms.VPSet([ p for p in proc.RunHPSValidationQCD.discriminators if any(disc in p.discriminator.value() for disc in discs_to_retain)
def addExtraMETCollections(process, unCleanPFCandidateCollection, cleanElectronCollection, cleanPhotonCollection, unCleanElectronCollection, unCleanPhotonCollection ): # Muon/EGamma un/corrected pfMET ============ from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction # uncorrected MET cloneProcessingSnippet(process, getattr(process,"makePatJets"),"BackupAllEvents") massSearchReplaceAnyInputTag(getattr(process,"makePatJetsBackupAllEvents"), "ak4PFJetsCHS", "ak4PFJetsCHSBackupAllEvents") massSearchReplaceAnyInputTag(getattr(process,"makePatJetsBackupAllEvents"), "pfCandidatesBadMuonsCleaned", "particleFlow") del process.patJetsBackupAllEvents.userData process.patJetsBackupAllEvents.addAssociatedTracks = cms.bool(False) process.patJetsBackupAllEvents.addBTagInfo = cms.bool(False) process.patJetsBackupAllEvents.addDiscriminators = cms.bool(False) process.patJetsBackupAllEvents.addGenJetMatch = cms.bool(False) process.patJetsBackupAllEvents.addGenPartonMatch = cms.bool(False) process.patJetsBackupAllEvents.addJetCharge = cms.bool(False) process.patJetsBackupAllEvents.addJetCorrFactors = cms.bool(True) process.patJetsBackupAllEvents.addJetFlavourInfo = cms.bool(False) process.patJetsBackupAllEvents.addJetID = cms.bool(False) process.patJetsBackupAllEvents.addPartonJetMatch = cms.bool(False) process.patJetsBackupAllEvents.addResolutions = cms.bool(False) process.patJetsBackupAllEvents.addTagInfos = cms.bool(False) process.patJetsBackupAllEvents.discriminatorSources = cms.VInputTag() process.patJetsBackupAllEvents.embedGenJetMatch = cms.bool(False) runMetCorAndUncForMiniAODProduction(process, metType="PF", pfCandColl=cms.InputTag(unCleanPFCandidateCollection), recoMetFromPFCs=True, jetCollUnskimmed="patJetsBackupAllEvents", postfix="Uncorrected" ) if not hasattr(process, "slimmedMETs"): process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi') process.slimmedMETsUncorrected = process.slimmedMETs.clone() process.slimmedMETsUncorrected.src = cms.InputTag("patPFMetT1Uncorrected") process.slimmedMETsUncorrected.rawVariation = cms.InputTag("patPFMetUncorrected") process.slimmedMETsUncorrected.t1Uncertainties = cms.InputTag("patPFMetT1%sUncorrected") process.slimmedMETsUncorrected.t01Variation = cms.InputTag("patPFMetT0pcT1Uncorrected") process.slimmedMETsUncorrected.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sUncorrected") process.slimmedMETsUncorrected.tXYUncForRaw = cms.InputTag("patPFMetTxyUncorrected") process.slimmedMETsUncorrected.tXYUncForT1 = cms.InputTag("patPFMetT1TxyUncorrected") process.slimmedMETsUncorrected.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyUncorrected") process.slimmedMETsUncorrected.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyUncorrected") process.slimmedMETsUncorrected.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyUncorrected") del process.slimmedMETsUncorrected.caloMET # EG corrected MET corMETFromMuonAndEG(process, pfCandCollection="", #not needed electronCollection=unCleanElectronCollection, photonCollection=unCleanPhotonCollection, corElectronCollection=cleanElectronCollection, corPhotonCollection=cleanPhotonCollection, allMETEGCorrected=True, muCorrection=False, eGCorrection=True, runOnMiniAOD=False, eGPFix="Uncorrected", postfix="EGOnly" ) process.slimmedMETsEGClean = process.slimmedMETs.clone() process.slimmedMETsEGClean.src = cms.InputTag("patPFMetT1UncorrectedEGOnly") process.slimmedMETsEGClean.rawVariation = cms.InputTag("patPFMetRawUncorrectedEGOnly") process.slimmedMETsEGClean.t1Uncertainties = cms.InputTag("patPFMetT1%sUncorrectedEGOnly") process.slimmedMETsEGClean.t01Variation = cms.InputTag("patPFMetT0pcT1UncorrectedEGOnly") process.slimmedMETsEGClean.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sUncorrectedEGOnly") process.slimmedMETsEGClean.tXYUncForRaw = cms.InputTag("patPFMetTxyUncorrectedEGOnly") process.slimmedMETsEGClean.tXYUncForT1 = cms.InputTag("patPFMetT1TxyUncorrectedEGOnly") process.slimmedMETsEGClean.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyUncorrectedEGOnly") process.slimmedMETsEGClean.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyUncorrectedEGOnly") process.slimmedMETsEGClean.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyUncorrectedEGOnly") del process.slimmedMETsEGClean.caloMET # fully corrected MET corMETFromMuonAndEG(process, pfCandCollection="", #not needed electronCollection=unCleanElectronCollection, photonCollection=unCleanPhotonCollection, corElectronCollection=cleanElectronCollection, corPhotonCollection=cleanPhotonCollection, allMETEGCorrected=True, muCorrection=False, eGCorrection=True, runOnMiniAOD=False, postfix="MuEGClean" ) process.slimmedMETsMuEGClean = process.slimmedMETs.clone() process.slimmedMETsMuEGClean.src = cms.InputTag("patPFMetT1MuEGClean") process.slimmedMETsMuEGClean.rawVariation = cms.InputTag("patPFMetRawMuEGClean") process.slimmedMETsMuEGClean.t1Uncertainties = cms.InputTag("patPFMetT1%sMuEGClean") process.slimmedMETsMuEGClean.t01Variation = cms.InputTag("patPFMetT0pcT1MuEGClean") process.slimmedMETsMuEGClean.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sMuEGClean") process.slimmedMETsMuEGClean.tXYUncForRaw = cms.InputTag("patPFMetTxyMuEGClean") process.slimmedMETsMuEGClean.tXYUncForT1 = cms.InputTag("patPFMetT1TxyMuEGClean") process.slimmedMETsMuEGClean.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyMuEGClean") process.slimmedMETsMuEGClean.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyMuEGClean") process.slimmedMETsMuEGClean.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyMuEGClean") del process.slimmedMETsMuEGClean.caloMET addKeepStatement(process, "keep *_slimmedMETs_*_*", ["keep *_slimmedMETsUncorrected_*_*", "keep *_slimmedMETsEGClean_*_*", "keep *_slimmedMETsMuEGClean_*_*"])
process.load('HeavyIonsAnalysis.JetAnalysis.EventSelection_cff') #process.phltJetHI = cms.Path( process.hltJetHI ) process.pcollisionEventSelection = cms.Path(process.collisionEventSelection) #process.pHBHENoiseFilter = cms.Path( process.HBHENoiseFilter ) process.phfCoincFilter = cms.Path(process.hfCoincFilter ) process.phfCoincFilter3 = cms.Path(process.hfCoincFilter3 ) process.pprimaryVertexFilter = cms.Path(process.primaryVertexFilter ) process.phltPixelClusterShapeFilter = cms.Path(process.siPixelRecHits*process.hltPixelClusterShapeFilter ) process.phiEcalRecHitSpikeFilter = cms.Path(process.hiEcalRecHitSpikeFilter ) process.pAna = cms.EndPath(process.skimanalysis) #process.output_step = cms.EndPath(process.allOutput) # Customization process.HiGenParticleAna.ptMin = 2. process.HiGenParticleAna.genParticleSrc = cms.untracked.InputTag("genParticles") process.HiGenParticleAna.stableOnly = cms.untracked.bool(False) oldGenParticleTag=cms.InputTag("hiGenParticles") newGenParticleTag=cms.InputTag("genParticles") oldProcLabelTag=cms.InputTag("hiSignal") newProcLabelTag=cms.InputTag("generator") from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag for s in process.paths_().keys(): massSearchReplaceAnyInputTag(getattr(process,s),oldGenParticleTag,newGenParticleTag) #massSearchReplaceAnyInputTag(getattr(process,s),newGenParticleTag,oldGenParticleTag) // go back to hiGenParticles massSearchReplaceAnyInputTag(getattr(process,s),oldProcLabelTag,newProcLabelTag)
process.patMetShiftCorrected ) process.PATCMGSequence += process.metphiCorretionSequence patEventContentCMG+=['keep *_patMetShiftCorrected_*_*'] #################################################### ######## CLEANED JET COLLECTION FOR MU-TAUH ######## #################################################### process.load('CMGTools.Common.PAT.addFilterPaths_cff') print "Cleaning the jet collection for mu-tauh channel" from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag process.load("ExoDiBosonResonances.PATtupleProduction.CleanJets_cff") process.PATCMGSequence += process.primaryVertexFilter process.PATCMGSequence += process.CleanJetsMuTauSequence process.PATTauSequenceMuTau = cloneProcessingSnippet(process,process.PATTauSequence, "MuTau") massSearchReplaceAnyInputTag(process.PATTauSequenceMuTau,cms.InputTag("pfJetsForHPSTauMuTau"),cms.InputTag("ak5PFJetsNoMu")) process.PATTauSequenceMuTau.replace( process.pfJetsForHPSTauMuTau, process.primaryVertexFilter+process.CleanJetsMuTauSequence ) process.PATCMGSequence += process.PATTauSequenceMuTau patEventContentCMG+=['keep *_*selectedPatTausMuTau*_*_*'] ##################################################### ######### CLEANED JET COLLECTION FOR EL-TAUH ######## ##################################################### print "Cleaning the jet collection for ele-tauh channel" process.PATCMGSequence += process.CleanJetsETauSequence process.PATTauSequenceEleTau = cloneProcessingSnippet(process,process.PATTauSequence, "EleTau") massSearchReplaceAnyInputTag(process.PATTauSequenceEleTau,cms.InputTag("pfJetsForHPSTauEleTau"),cms.InputTag("ak5PFJetsNoEle")) process.PATTauSequenceEleTau.replace( process.pfJetsForHPSTauEleTau, process.primaryVertexFilter+process.CleanJetsETauSequence ) process.PATCMGSequence += process.PATTauSequenceEleTau patEventContentCMG+=['keep *_*selectedPatTausEleTau*_*_*']
def customiseForPreMixingInput(process): from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag # Replace TrackingParticles and TrackingVertices globally # only apply on validation and dqm: we don't want to apply this in the mixing and digitization sequences for s in process.paths_().keys() + process.endpaths_().keys(): if s.lower().find("validation") >= 0 or s.lower().find("dqm") >= 0: massSearchReplaceAnyInputTag(getattr(process, s), cms.InputTag("mix", "MergedTrackTruth"), cms.InputTag("mixData", "MergedTrackTruth"), skipLabelTest=True) # Replace Pixel/StripDigiSimLinks only for the known modules def replaceInputTag(tag, old, new): if tag.value() == old: tag.setValue(new) def replacePixelDigiSimLink(tag): replaceInputTag(tag, "simSiPixelDigis", "mixData:PixelDigiSimLink") def replaceStripDigiSimLink(tag): replaceInputTag(tag, "simSiStripDigis", "mixData:StripDigiSimLink") for label, producer in process.producers_().iteritems(): if producer.type_() == "ClusterTPAssociationProducer": replacePixelDigiSimLink(producer.pixelSimLinkSrc) replaceStripDigiSimLink(producer.stripSimLinkSrc) if producer.type_() == "QuickTrackAssociatorByHitsProducer": replacePixelDigiSimLink(producer.pixelSimLinkSrc) replaceStripDigiSimLink(producer.stripSimLinkSrc) if producer.type_() == "TrackAssociatorByHitsProducer": replacePixelDigiSimLink(producer.pixelSimLinkSrc) replaceStripDigiSimLink(producer.stripSimLinkSrc) if producer.type_() == "MuonAssociatorEDProducer": producer.DTdigisimlinkTag = cms.InputTag("mixData", "simMuonDTDigis") producer.CSClinksTag = cms.InputTag("mixData", "MuonCSCStripDigiSimLinks") producer.CSCwireLinksTag = cms.InputTag("mixData", "MuonCSCWireDigiSimLinks") producer.RPCdigisimlinkTag = cms.InputTag("mixData", "RPCDigiSimLink") replacePixelDigiSimLink(producer.pixelSimLinkSrc) replaceStripDigiSimLink(producer.stripSimLinkSrc) if producer.type_() == "MuonToTrackingParticleAssociatorEDProducer": producer.DTdigisimlinkTag = cms.InputTag("mixData", "simMuonDTDigis") producer.CSClinksTag = cms.InputTag("mixData", "MuonCSCStripDigiSimLinks") producer.CSCwireLinksTag = cms.InputTag("mixData", "MuonCSCWireDigiSimLinks") producer.RPCdigisimlinkTag = cms.InputTag("mixData", "RPCDigiSimLink") replacePixelDigiSimLink(producer.pixelSimLinkSrc) replaceStripDigiSimLink(producer.stripSimLinkSrc) for label, analyzer in process.analyzers_().iteritems(): if analyzer.type_() == "GlobalRecHitsAnalyzer": replacePixelDigiSimLink(analyzer.pixelSimLinkSrc) replaceStripDigiSimLink(analyzer.stripSimLinkSrc) if analyzer.type_() == "SiPixelTrackingRecHitsValid": replacePixelDigiSimLink(analyzer.pixelSimLinkSrc) replaceStripDigiSimLink(analyzer.stripSimLinkSrc) if analyzer.type_() == "SiStripTrackingRecHitsValid": replacePixelDigiSimLink(analyzer.pixelSimLinkSrc) replaceStripDigiSimLink(analyzer.stripSimLinkSrc) if analyzer.type_() == "SiPixelRecHitsValid": replacePixelDigiSimLink(analyzer.pixelSimLinkSrc) replaceStripDigiSimLink(analyzer.stripSimLinkSrc) if analyzer.type_() == "SiStripRecHitsValid": replacePixelDigiSimLink(analyzer.pixelSimLinkSrc) replaceStripDigiSimLink(analyzer.stripSimLinkSrc) return process
def switchToData(process): # remove MC matching from standard PAT sequences if hasattr(process, "patDefaultSequence"): removeMCMatching(process, ["All"], outputModules = []) process.patDefaultSequence.remove(process.patJetPartonMatch) #------------------------------------------------------------------------ # CV: temporary work-around for W --> tau nu channel modulesToRemove = [ "patJetPartonMatchAK5PF", "patJetGenJetMatchAK5PF", "patJetPartons", "patJetPartonAssociation", "patJetPartonAssociationAK5PF", "patJetFlavourAssociation", "patJetFlavourAssociationAK5PF" ] for moduleToRemove in modulesToRemove: if hasattr(process, moduleToRemove): process.patDefaultSequence.remove(getattr(process, moduleToRemove)) if hasattr(process, "patJetCorrFactorsAK5PF"): process.patJetCorrFactorsAK5PF.levels.append("L2L3Residual") #------------------------------------------------------------------------ # add data-quality cuts which work on "real" data only if hasattr(process, "dataQualityFilters"): process.dataQualityFilters._seq = process.dataQualityFilters._seq * process.hltPhysicsDeclared process.dataQualityFilters._seq = process.dataQualityFilters._seq * process.dcsstatus # apply L2/L3 residual jet energy corrections # (for improved Data and Monte-Carlo agreement) if hasattr(process, "pfMEtType1and2corrected"): setattr(process.pfMEtType1and2corrected, "corrector", cms.string('ak5PFL2L3Residual')) if hasattr(process, "patPFMETs"): process.patPFMETs.addGenMET = cms.bool(False) if hasattr(process, "patPFtype1METs"): process.patPFtype1METs.addGenMET = cms.bool(False) # remove modules from pre-PAT production running on genParticles if hasattr(process, "producePrePat"): process.producePrePat.remove(process.genParticlesForJets) process.producePrePat.remove(process.ak5GenJets) # remove modules from PAT-tuple production sequence running on genParticles if hasattr(process, "producePatTuple"): if hasattr(process, "genParticlesForJets"): process.producePatTuple.remove(process.genParticlesForJets) if hasattr(process, "ak5GenJets"): process.producePatTuple.remove(process.ak5GenJets) # remove modules from post-PAT production running on genParticles if hasattr(process, "producePostPat"): process.producePostPat.remove(process.produceGenObjects) # iterate over all sequences attached to process object and # recursively disable gen. matching for all modules in sequence for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.Sequence): print "--> Disabling gen. Matching for sequence:", processAttrName # replace all InputTags referring to # o genParticleSource = cms.InputTag('genParticles') --> "" # o genJetSource = cms.InputTag('iterativeCone5GenJets') --> "" # o genJetSource = cms.InputTag('ak5GenJets') --> "" # o genTauJetSource = cms.InputTag('tauGenJets') --> "" # o genMEtSource = cms.InputTag('genMetTrue') --> "" patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('genParticles'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('iterativeCone5GenJets'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('ak5GenJets'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('tauGenJets'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('genMetTrue'), cms.InputTag('')) # replace all InputTags referring to gen. Z decay products # in electron + tau-jet Zee (muon + tau-jet Zmumu) hypotheses patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('genElectronsFromZs'), cms.InputTag('')) patutils.massSearchReplaceAnyInputTag(processAttr, cms.InputTag('genMuonsFromZs'), cms.InputTag('')) # disable generator level matching for all PATJetProducer modules for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.EDProducer) and processAttr.type_() == "PATJetProducer": print "--> Disabling gen. Matching for module:", processAttrName setattr(processAttr, "addGenJetMatch", cms.bool(False)) setattr(processAttr, "addGenPartonMatch", cms.bool(False)) setattr(processAttr, "addPartonJetMatch", cms.bool(False)) # disable access to generator level information in all # histogram managers, binner and event-dump plugins of GenericAnalyzer module for processAttrName in dir(process): processAttr = getattr(process, processAttrName) if isinstance(processAttr, cms.EDAnalyzer) and processAttr.type_() == "GenericAnalyzer": # disable matching between gen. and rec. particles # in all histogram managers and binner plugins by setting # o genParticleSource = cms.InputTag('genParticles') --> "" # o genJetSource = cms.InputTag('iterativeCone5GenJets') --> "" # o genJetSource = cms.InputTag('ak5GenJets') --> "" # o genTauJetSource = cms.InputTag('tauGenJets') --> "" # o genMEtSource = cms.InputTag('genMetTrue') --> "" if hasattr(processAttr, "analyzers"): analyzerPlugins = getattr(processAttr, "analyzers") for analyzerPlugin in analyzerPlugins: _setattr_ifexists(analyzerPlugin, "genParticleSource", cms.InputTag('')) _setattr_ifexists(analyzerPlugin, "genJetSource", cms.InputTag('')) _setattr_ifexists(analyzerPlugin, "genTauJetSource", cms.InputTag('')) _setattr_ifexists(analyzerPlugin, "genMEtSource", cms.InputTag('')) # remove from all analysis sequences the following objects: # o genPhaseSpaceInfoHistManager # o modelBinnerForMuTauGenTauLeptonPairAcc # o modelBinnerForMuTauWrtGenTauLeptonPairAcc # o modelBinnerForMuTauGenTauLeptonPairAcc3mZbins # o modelBinnerForMuTauWrtGenTauLeptonPairAcc3mZbins # o modelBinnerForMuTauCentralJetVetoWrtGenTauLeptonPairAcc # o modelBinnerForMuTauCentralJetBtagWrtGenTauLeptonPairAcc # o sysUncertaintyBinnerForMuTau # o diTauCandidateCollinearApproxHistManagerBinnedForMuTau analyzerPluginsToRemove = [ "genPhaseSpaceEventInfoHistManager", "genTauHistManager", "cutFlowHistManagerGenMultiplicity", "modelBinnerForMuTauGenTauLeptonPairAcc", "modelBinnerForMuTauWrtGenTauLeptonPairAcc", "modelBinnerForMuTauGenTauLeptonPairAcc3mZbins", "modelBinnerForMuTauWrtGenTauLeptonPairAcc3mZbins", "modelBinnerForMuTauCentralJetVetoWrtGenTauLeptonPairAcc", "modelBinnerForMuTauCentralJetBtagWrtGenTauLeptonPairAcc", "sysUncertaintyBinnerForMuTau", "diTauCandidateCollinearApproxHistManagerBinnedForMuTau" ] for analyzerPluginName in analyzerPluginsToRemove: if hasattr(process, analyzerPluginName): analyzerPlugin = getattr(process, analyzerPluginName) if processAttr.analyzers.count(analyzerPlugin) > 0: processAttr.analyzers.remove(analyzerPlugin) removeAnalyzer(processAttr.analysisSequence, analyzerPluginName) # disable matching between gen. and rec. particles in all event-dump plugins by setting # o doGenInfo = cms.bool(True) --> cms.bool(False) # o genParticleSource = cms.InputTag('genParticles') --> "" if hasattr(processAttr, "eventDumps"): eventDumpPlugins = getattr(processAttr, "eventDumps") for eventDumpPlugin in eventDumpPlugins: eventDumpPlugin.doGenInfo = cms.bool(False) eventDumpPlugin.genParticleSource = cms.InputTag('') # disable estimation of systematic uncertainties by setting # o analyzers_systematic = cms.VPSet(..) --> cms.VPSet() processAttr.analyzers.analyzers_systematic = cms.VPSet() for processAttrName in dir(process): processAttr = getattr(process, processAttrName) _setattr_ifexists(processAttr, "isData", cms.bool(True) )
process.neuralMtautauNtupleProductionSequence += process.kt6PFJets process.neuralMtautauNtupleProductionSequence += process.ak5PFJets process.patDefaultSequence.remove(process.patMETs) process.patDefaultSequence.remove(process.patMETCorrections) process.neuralMtautauNtupleProductionSequence += process.patDefaultSequence process.neuralMtautauNtupleProductionSequence += process.producePatPFMETCorrections # switch to HPS PFTaus (and disable all "cleaning" cuts) from PhysicsTools.PatAlgos.tools.tauTools import * switchToPFTauHPS(process) process.cleanPatTaus.preselection = cms.string('') # switch to generator level matched collections of electrons, muons and tau-jets from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag massSearchReplaceAnyInputTag(process.patDefaultSequence, cms.InputTag('gsfElectrons'), cms.InputTag('genMatchedElectrons')) massSearchReplaceAnyInputTag(process.patDefaultSequence, cms.InputTag('muons'), cms.InputTag('genMatchedMuons')) massSearchReplaceAnyInputTag(process.patDefaultSequence, cms.InputTag('hpsPFTauProducer'), cms.InputTag('genMatchedTaus')) # disable matching pat::Electrons, pat::Muons and pat::Taus to generator level quantities import PhysicsTools.PatAlgos.tools.helpers as patutils removeMCMatching(process, ["All"], outputInProcess=False) process.patDefaultSequence.remove(process.patJetPartonMatch) # disable all pat::Electron embedding for objSelAttrName in dir(process.patElectrons): objSelAttr = getattr(process.patElectrons, objSelAttrName)