def addMuonJetSelection(process, sequence, prefix="muonSelectionJetSelection"): selector = prefix+"GoodJets" filter = prefix+"Filter" counter = prefix import muonSelectionPF_cff as muonSelection from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets m1 = cleanPatJets.clone( # src = "selectedPatJets", src = "goodJets", # we should use the pat::Jets constructed in the preselection = cms.string(jetSelection), checkOverlaps = cms.PSet( muons = cms.PSet( src = cms.InputTag(tauEmbeddingMuons), algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True), ) ) ) m2 = muonSelection.goodJetFilter.clone(src=selector, minNumber=3) m3 = cms.EDProducer("EventCountProducer") setattr(process, selector, m1) setattr(process, filter, m2) setattr(process, counter, m3) sequence *= (m1 * m2 * m3) return [counter]
def __init__(self, process, prefix="", beginSequence=None, afterOtherCuts=False, muonPtCut=30, muonIsolationCut=0.05, metCut=20, njets=3, jets=jets, doJetId=False): self.process = process self.prefix = prefix self.afterOtherCuts = afterOtherCuts self.doJetId = doJetId self._ptCut = ptCutString % muonPtCut self._metCut = metCutString % metCut self._njets = njets self._jets = jets self._isolationCut = "%s < %f" % (relIso, muonIsolationCut) counters = [] if dataVersion.isData(): counters = dataSelectionCounters self.analysis = Analysis(self.process, "analysis", options, prefix, additionalCounters=counters) #self.analysis.getCountAnalyzer().printMainCounter = cms.untracked.bool(True) #self.analysis.getCountAnalyzer().printSubCounters = cms.untracked.bool(True) #self.analysis.getCountAnalyzer().printAvailableCounters = cms.untracked.bool(True) if beginSequence != None: self.analysis.appendToSequence(beginSequence) self.multipName = "Multiplicity" self.pileupName = "VertexCount" self.selectedMuons = muons self.selectedJets = self._jets # Setup the analyzers if not self.afterOtherCuts: self.histoAnalyzer = self.analysis.addMultiHistoAnalyzer( "AllMuons", [("muon_", muons, histosBeginning), ("calomet_", cms.InputTag(caloMET), [histoMet]), ("pfmet_", cms.InputTag(pfMET), [histoMet]), ("tcmet_", cms.InputTag(tcMET), [histoMet])]) self.multipAnalyzer = self.analysis.addAnalyzer( self.multipName, cms.EDAnalyzer( "HPlusCandViewMultiplicityAnalyzer", allMuons=cms.untracked.PSet(src=muons, min=cms.untracked.int32(0), max=cms.untracked.int32(10), nbins=cms.untracked.int32(10)), selMuons=cms.untracked.PSet(src=muons, min=cms.untracked.int32(0), max=cms.untracked.int32(10), nbins=cms.untracked.int32(10)), jets=cms.untracked.PSet(src=self._jets, min=cms.untracked.int32(0), max=cms.untracked.int32(20), nbins=cms.untracked.int32(20)))) self.pileupAnalyzer = None if beginSequence == None: self.pileupAnalyzer = self.analysis.addAnalyzer( self.pileupName, cms.EDAnalyzer( "HPlusVertexCountAnalyzer", src=cms.untracked.VInputTag([ cms.untracked.InputTag(x) for x in vertexCollections ]), min=cms.untracked.double(0), max=cms.untracked.double(20), nbins=cms.untracked.int32(20), )) # Create the prototype for muon cleaner from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons self.muonJetCleanerPrototype = cleanPatMuons.clone( src=cms.InputTag("dummy"), checkOverlaps=cms.PSet( jets=cms.PSet(src=cms.InputTag("dummy"), algorithm=cms.string("byDeltaR"), preselection=cms.string(""), deltaR=cms.double(0.3), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True)))) # Create the prototype for jet cleaner from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets self.jetMuonCleanerPrototype = cleanPatJets.clone( src=cms.InputTag("dummy"), checkOverlaps=cms.PSet( muons=cms.PSet(src=cms.InputTag("dummy"), algorithm=cms.string("byDeltaR"), preselection=cms.string(""), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True)))) # Create the prototype for candidate combiner self.candCombinerPrototype = cms.EDProducer( "CandViewShallowCloneCombiner", checkCharge=cms.bool(False), cut=cms.string(""), decay=cms.string("dummy")) # Setup the afterOtherCuts prototypes if self.afterOtherCuts: self.afterOtherCutsModule = cms.EDAnalyzer( "HPlusCandViewHistoAfterOtherCutsAnalyzer", src=cms.InputTag("dummy"), histograms=cms.VPSet( histoPt.pset().clone( cut=cms.untracked.string(self._ptCut)), histoEta.pset().clone(cut=cms.untracked.string(etaCut)), histoDB.pset().clone(cut=cms.untracked.string(dbCut)), )) self.afterOtherCutsModuleIso = self.afterOtherCutsModule.clone() self.afterOtherCutsModuleIso.histograms.append( histoIso.pset().clone( cut=cms.untracked.string(self._isolationCut)))
cut='userInt("isGoodNonIso")', ) process.goodJets = cleanPatJets.clone( src=cms.InputTag("jetUserData"), preselection='userInt("passesPt") && userInt("isGood")', checkOverlaps=cms.PSet( electrons=cms.PSet( src=cms.InputTag("goodElectrons"), algorithm=cms.string("byDeltaR"), preselection=cms.string(""), deltaR=cms.double(cleaningDeltaR), # don't check if they share some AOD object ref checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), muons=cms.PSet( src=cms.InputTag("goodMuons"), algorithm=cms.string("byDeltaR"), preselection=cms.string(""), deltaR=cms.double(cleaningDeltaR), # don't check if they share some AOD object ref checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), ) ) process.goodJetsEConversionRegion = process.goodJets.clone() process.goodJetsEConversionRegion.checkOverlaps.electrons.src = 'goodConversionElectrons'
def addEmbeddingLikePreselection(process, sequence, param, prefix="embeddingLikePreselection", disableTrigger=True): counters = [] # Create PU weight producer for the counters pileupWeight = cms.EDProducer("HPlusVertexWeightProducer", alias = cms.string("pileupWeight"), ) HChTools.insertPSetContentsTo(param.vertexWeight.clone(), pileupWeight) setattr(process, prefix+"PileupWeight", pileupWeight) counterPrototype = cms.EDProducer("HPlusEventCountProducer", weightSrc = cms.InputTag(prefix+"PileupWeight") ) # Disable trigger if disableTrigger: param.trigger.selectionType = "disabled" param.triggerEfficiencyScaleFactor.mode = "disabled" allCount = counterPrototype.clone() setattr(process, prefix+"AllCount", allCount) counters.append(prefix+"AllCount") # Primary vertex pvFilter = cms.EDFilter("VertexCountFilter", src = cms.InputTag("selectedPrimaryVertex"), minNumber = cms.uint32(1), maxNumber = cms.uint32(999) ) pvFilterCount = counterPrototype.clone() setattr(process, prefix+"PrimaryVertex", pvFilter) setattr(process, prefix+"PrimaryVertexCount", pvFilterCount) counters.append(prefix+"PrimaryVertexCount") # Generator taus (if you modify this, remember to modify similar in above) genTaus = cms.EDFilter("GenParticleSelector", src = cms.InputTag("genParticles"), cut = cms.string("abs(pdgId()) == 15 && pt() > 40 && abs(eta()) < 2.1") ) genTausName = prefix+"GenTau" setattr(process, genTausName, genTaus) genTausFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag(genTausName), minNumber = cms.uint32(1), ) setattr(process, prefix+"GenTauFilter", genTausFilter) genTausCount = counterPrototype.clone() setattr(process, prefix+"GenTauCount", genTausCount) counters.append(prefix+"GenTauCount") # Select first generator tau for the jet cleaning and tau selection genTauFirst = cms.EDProducer("HPlusFirstCandidateSelector", src = cms.InputTag(genTausName) ) genTauFirstName = prefix+"First" setattr(process, genTauFirstName, genTauFirst) # Tau selection genTauReco = cms.EDProducer("HPlusPATTauCandViewDeltaRSelector", src = cms.InputTag("selectedPatTausHpsPFTau"), # not trigger matched refSrc = cms.InputTag(genTauFirstName), deltaR = cms.double(0.5), ) if not disableTrigger: genTauReco.src = param.tauSelection.src.value() genTauRecoName = prefix+"Reco" setattr(process, genTauRecoName, genTauReco) param.tauSelection.src = genTauRecoName genTauCleanPSet = cms.PSet( src = cms.InputTag(genTauFirstName), algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.5), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True), ) # Clean the selected generator tau from the electrons and muons # for the e/mu veto. We don't want to reject events where the e/mu # comes from the tau decay. from PhysicsTools.PatAlgos.cleaningLayer1.electronCleaner_cfi import cleanPatElectrons from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons cleanedElectrons = cleanPatElectrons.clone( src = cms.InputTag(param.GlobalElectronVeto.ElectronCollectionName.value()), checkOverlaps = cms.PSet( genTaus = genTauCleanPSet.clone() ) ) cleanedElectronsName = prefix+"CleanedElectrons" param.GlobalElectronVeto.ElectronCollectionName = cleanedElectronsName setattr(process, cleanedElectronsName, cleanedElectrons) cleanedMuons = cleanPatMuons.clone( src = cms.InputTag(param.GlobalMuonVeto.MuonCollectionName.value()), checkOverlaps = cms.PSet( genTaus = genTauCleanPSet.clone() ) ) cleanedMuonsName = prefix+"CleanedMuons" param.GlobalMuonVeto.MuonCollectionName = cleanedMuonsName setattr(process, cleanedMuonsName, cleanedMuons) # Electron and muon veto eveto = ElectronVeto.hPlusGlobalElectronVetoFilter.clone() evetoCount = counterPrototype.clone() muveto = MuonVeto.hPlusGlobalMuonVetoFilter.clone() muvetoCount = counterPrototype.clone() setattr(process, prefix+"ElectronVeto", eveto) setattr(process, prefix+"ElectronVetoCount", evetoCount) setattr(process, prefix+"MuonVeto", muveto) setattr(process, prefix+"MuonVetoCount", muvetoCount) counters.extend([prefix+"ElectronVetoCount", prefix+"MuonVetoCount"]) # 3 jets from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets cleanedJets = cleanPatJets.clone( src = cms.InputTag(param.jetSelection.src.value()), preselection = cms.string(jetSelection), checkOverlaps = cms.PSet( genTaus = genTauCleanPSet.clone() ) ) cleanedJetsName = prefix+"CleanedJets" setattr(process, cleanedJetsName, cleanedJets) cleanedJetsFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag(cleanedJetsName), minNumber = cms.uint32(3) ) setattr(process, cleanedJetsName+"Filter", cleanedJetsFilter) cleanedJetsCount = counterPrototype.clone() setattr(process, cleanedJetsName+"Count", cleanedJetsCount) counters.append(cleanedJetsName+"Count") genTauSequence = cms.Sequence( pileupWeight * allCount * pvFilter * pvFilterCount * genTaus * genTausFilter * genTausCount * genTauFirst * genTauReco * cleanedElectrons * cleanedMuons * eveto * evetoCount * muveto * muvetoCount * cleanedJets * cleanedJetsFilter * cleanedJetsCount ) setattr(process, prefix+"Sequence", genTauSequence) sequence *= genTauSequence return counters
def __init__(self, process, prefix="", beginSequence=None, afterOtherCuts=False, muonPtCut=30, muonIsolationCut=0.05, metCut=20, njets=3, jets=jets, doJetId=False): self.process = process self.prefix = prefix self.afterOtherCuts = afterOtherCuts self.doJetId = doJetId self._ptCut = ptCutString % muonPtCut self._metCut = metCutString % metCut self._njets = njets self._jets = jets self._isolationCut = "%s < %f" % (relIso, muonIsolationCut) counters = [] if dataVersion.isData(): counters = dataSelectionCounters self.analysis = Analysis(self.process, "analysis", options, prefix, additionalCounters=counters) #self.analysis.getCountAnalyzer().printMainCounter = cms.untracked.bool(True) #self.analysis.getCountAnalyzer().printSubCounters = cms.untracked.bool(True) #self.analysis.getCountAnalyzer().printAvailableCounters = cms.untracked.bool(True) if beginSequence != None: self.analysis.appendToSequence(beginSequence) self.multipName = "Multiplicity" self.pileupName = "VertexCount" self.selectedMuons = muons self.selectedJets = self._jets # Setup the analyzers if not self.afterOtherCuts: self.histoAnalyzer = self.analysis.addMultiHistoAnalyzer("AllMuons", [ ("muon_", muons, histosBeginning), ("calomet_", cms.InputTag(caloMET), [histoMet]), ("pfmet_", cms.InputTag(pfMET), [histoMet]), ("tcmet_", cms.InputTag(tcMET), [histoMet])]) self.multipAnalyzer = self.analysis.addAnalyzer(self.multipName, cms.EDAnalyzer("HPlusCandViewMultiplicityAnalyzer", allMuons = cms.untracked.PSet( src = muons, min = cms.untracked.int32(0), max = cms.untracked.int32(10), nbins = cms.untracked.int32(10) ), selMuons = cms.untracked.PSet( src = muons, min = cms.untracked.int32(0), max = cms.untracked.int32(10), nbins = cms.untracked.int32(10) ), jets = cms.untracked.PSet( src = self._jets, min = cms.untracked.int32(0), max = cms.untracked.int32(20), nbins = cms.untracked.int32(20) ) )) self.pileupAnalyzer = None if beginSequence == None: self.pileupAnalyzer = self.analysis.addAnalyzer(self.pileupName, cms.EDAnalyzer("HPlusVertexCountAnalyzer", src = cms.untracked.VInputTag([cms.untracked.InputTag(x) for x in vertexCollections]), min = cms.untracked.double(0), max = cms.untracked.double(20), nbins = cms.untracked.int32(20), )) # Create the prototype for muon cleaner from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons self.muonJetCleanerPrototype = cleanPatMuons.clone( src = cms.InputTag("dummy"), checkOverlaps = cms.PSet( jets = cms.PSet( src = cms.InputTag("dummy"), algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.3), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True) ) ) ) # Create the prototype for jet cleaner from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets self.jetMuonCleanerPrototype = cleanPatJets.clone( src = cms.InputTag("dummy"), checkOverlaps = cms.PSet( muons = cms.PSet( src = cms.InputTag("dummy"), algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True) ) ) ) # Create the prototype for candidate combiner self.candCombinerPrototype = cms.EDProducer("CandViewShallowCloneCombiner", checkCharge = cms.bool(False), cut = cms.string(""), decay = cms.string("dummy") ) # Setup the afterOtherCuts prototypes if self.afterOtherCuts: self.afterOtherCutsModule = cms.EDAnalyzer("HPlusCandViewHistoAfterOtherCutsAnalyzer", src = cms.InputTag("dummy"), histograms = cms.VPSet( histoPt.pset().clone(cut=cms.untracked.string(self._ptCut)), histoEta.pset().clone(cut=cms.untracked.string(etaCut)), histoDB.pset().clone(cut=cms.untracked.string(dbCut)), ) ) self.afterOtherCutsModuleIso = self.afterOtherCutsModule.clone() self.afterOtherCutsModuleIso.histograms.append(histoIso.pset().clone(cut=cms.untracked.string(self._isolationCut)))
def __init__(self, process, dataVersion, additionalCounters, prefix="", beginSequence=None, afterOtherCuts=False, trigger=None, muons="selectedPatMuons", allMuons="selectedPatMuons", muonPtCut=30, doIsolationWithTau=False, isolationWithTauDiscriminator="byTightIsolation", doMuonIsolation=False, muonIsolation="sumIsoRel", muonIsolationCut=0.05, electrons="selectedPatElectrons", met="patMETsPF", metCut=20, jets="selectedPatJetsAK5PF", njets=3, vertexCollections=["offlinePrimaryVertices", "goodPrimaryVertices", "goodPrimaryVertices10"], weightSrc=None): self.process = process self.dataVersion = dataVersion self.prefix = prefix self.afterOtherCuts = afterOtherCuts self.doIsolationWithTau = doIsolationWithTau self.doMuonIsolation = doMuonIsolation self._trigger = trigger self._muons = cms.InputTag(muons) self._allMuons = cms.InputTag(allMuons) self._ptCut = "pt() > %d" % muonPtCut self._etaCut = "abs(eta()) < 2.1" self._electrons = electrons self._met = met self._metCut = "et() > %d" % metCut self._njets = njets self._jets = cms.InputTag(jets) self._muonIsolation = muonIsolation self._isolationCut = "%s < %f" % (isolations[muonIsolation], muonIsolationCut) self._isolationWithTauDiscriminator = isolationWithTauDiscriminator if self._trigger == None: raise Exception("Must specify trigger!") self.analysis = HChTools.Analysis(self.process, "analysis", prefix, additionalCounters=additionalCounters, weightSrc=weightSrc) #self.analysis.getCountAnalyzer().printMainCounter = cms.untracked.bool(True) #self.analysis.getCountAnalyzer().printSubCounters = cms.untracked.bool(True) #self.analysis.getCountAnalyzer().printAvailableCounters = cms.untracked.bool(True) if beginSequence != None: self.analysis.appendToSequence(beginSequence) self.multipName = "Multiplicity" self.pileupName = "VertexCount" self.selectedMuons = cms.InputTag(muons) self.selectedJets = self._jets # Setup the analyzers if not self.afterOtherCuts: self.histoAnalyzer = self.analysis.addMultiHistoAnalyzer("AllMuons", [ ("muon_", self.selectedMuons, histosBeginning), ("jet_", self.selectedJets, histosJet), ("met_", cms.InputTag(met), histosMet)]) self.multipAnalyzer = self.analysis.addAnalyzer(self.multipName, cms.EDAnalyzer("HPlusCandViewMultiplicityAnalyzer", allMuons = cms.untracked.PSet( src = self.selectedMuons, min = cms.untracked.int32(0), max = cms.untracked.int32(10), nbins = cms.untracked.int32(10) ), selMuons = cms.untracked.PSet( src = self.selectedMuons, min = cms.untracked.int32(0), max = cms.untracked.int32(10), nbins = cms.untracked.int32(10) ), jets = cms.untracked.PSet( src = self.selectedJets, min = cms.untracked.int32(0), max = cms.untracked.int32(20), nbins = cms.untracked.int32(20) ), )) if weightSrc != None: self.histoAnalyzer.weights = cms.untracked.InputTag(weightSrc) self.multipAnalyzer.weights = cms.untracked.InputTag(weightSrc) self.pileupAnalyzer = None if beginSequence == None: self.pileupAnalyzer = self.analysis.addAnalyzer(self.pileupName, cms.EDAnalyzer("HPlusVertexCountAnalyzer", src = cms.untracked.VInputTag([cms.untracked.InputTag(x) for x in vertexCollections]), min = cms.untracked.double(0), max = cms.untracked.double(20), nbins = cms.untracked.int32(20), )) if weightSrc != None: self.pileupAnalyzer.weights = cms.untracked.InputTag(weightSrc) # Create the prototype for muon cleaner from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons self.muonJetCleanerPrototype = cleanPatMuons.clone( src = cms.InputTag("dummy"), checkOverlaps = cms.PSet( jets = cms.PSet( src = cms.InputTag("dummy"), algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.3), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True) ) ) ) # Create the prototype for jet cleaner from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets self.jetMuonCleanerPrototype = cleanPatJets.clone( src = cms.InputTag("dummy"), checkOverlaps = cms.PSet( muons = cms.PSet( src = cms.InputTag("dummy"), algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True) ) ) ) # Create the prototype for candidate combiner self.candCombinerPrototype = cms.EDProducer("CandViewShallowCloneCombiner", checkCharge = cms.bool(False), cut = cms.string(""), decay = cms.string("dummy") ) # Setup the afterOtherCuts prototypes if self.afterOtherCuts: self.afterOtherCutsModule = cms.EDAnalyzer("HPlusCandViewHistoAfterOtherCutsAnalyzer", src = cms.InputTag("dummy"), histograms = cms.VPSet( histoPt.pset().clone(cut=cms.untracked.string(self._ptCut)), histoEta.pset().clone(cut=cms.untracked.string(self._etaCut)), ) ) if weightSrc != None: self.afterOtherCutsModule.weights = cms.untracked.InputTag(weightSrc) self.afterOtherCutsModuleIso = self.afterOtherCutsModule.clone() self.afterOtherCutsModuleIso.histograms.append(histoIsos[muonIsolation].pset().clone( cut=cms.untracked.string(self._isolationCut) ))
process.goodNonIsoElectrons = process.goodElectrons.clone( cut='userInt("isGoodNonIso")', ) process.goodJets = cleanPatJets.clone( src=cms.InputTag("jetUserData"), preselection='userInt("passesPt") && userInt("isGood")', checkOverlaps=cms.PSet( electrons=cms.PSet( src=cms.InputTag("goodElectrons"), algorithm=cms.string("byDeltaR"), preselection=cms.string(""), deltaR=cms.double(cleaningDeltaR), # don't check if they share some AOD object ref checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), muons=cms.PSet( src=cms.InputTag("goodMuons"), algorithm=cms.string("byDeltaR"), preselection=cms.string(""), deltaR=cms.double(cleaningDeltaR), # don't check if they share some AOD object ref checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), )) process.goodJetsEConversionRegion = process.goodJets.clone() process.goodJetsEConversionRegion.checkOverlaps.electrons.src = 'goodConversionElectrons'
def makeMET(process, isData, pfCandidates, jetSource, jetFlavor, postfix=''): """ @jetFlavor: e.g. 'ak4PFchs' Additional information (such as gen and calo mets) are added only if postfix is empty. """ sequence = cms.Sequence() # postfix is automatically added to the module names addattr = AddAttr(process, sequence, postfix) if postfix == '': # default MET - extract from input slimmedMETs pfMet = addattr( 'pfMet', cms.EDProducer("RecoMETExtractor", metSource=cms.InputTag( "slimmedMETs", processName=cms.InputTag.skipCurrentProcess()), correctionLevel=cms.string('raw'))) else: pfMet = addattr( 'pfMet', PFMET_cfi.pfMet.clone( src=pfCandidates, calculateSignificance=False # done in PAT )) cleanedJets = addattr( 'cleanedJetsForMET', cms.EDProducer( "PATJetCleanerForType1MET", src=cms.InputTag(jetSource), jetCorrEtaMax=cms.double(9.9), jetCorrLabel=cms.InputTag("L3Absolute"), jetCorrLabelRes=cms.InputTag("L2L3Residual"), offsetCorrLabel=cms.InputTag("L1FastJet"), skipEM=cms.bool(True), skipEMfractionThreshold=cms.double(0.9), skipMuonSelection=cms.string('isGlobalMuon | isStandAloneMuon'), skipMuons=cms.bool(True), type1JetPtThreshold=cms.double(15.0))) selectedJets = addattr( 'selectedJetsForMET', selectedPatJets.clone(src=cleanedJets, cut='pt > 15 && abs(eta) < 9.9')) crossCleanedJets = addattr('crossCleanedJetsForMET', cleanPatJets.clone(src=selectedJets)) ccJetsMod = addattr.last ccJetsMod.checkOverlaps.muons.src = muons ccJetsMod.checkOverlaps.electrons.src = electrons del ccJetsMod.checkOverlaps.photons del ccJetsMod.checkOverlaps.taus # not used at all and electrons are already cleaned del ccJetsMod.checkOverlaps.tkIsoElectrons patPFMet = addattr( 'patPFMet', patMET_cff.patPFMet.clone( metSource=pfMet, genMETSource='genMetTrue', srcPFCands=pfCandidates, computeMETSignificance=True, parameters=(METSignificanceParams_Data if isData else METSignificanceParams), srcJets=crossCleanedJets, srcLeptons=[electrons, muons, photons], addGenMET=(not isData and postfix == ''))) patPFMetT1Corr = addattr( 'patPFMetT1Corr', patMET_cff.patPFMetT1T2Corr.clone(src=crossCleanedJets)) patPFMetT1 = addattr( 'patPFMetT1', patMET_cff.patPFMetT1.clone(src=patPFMet, srcCorrections=[ cms.InputTag( patPFMetT1Corr.getModuleLabel(), 'type1') ])) pfCandsNoEle = addattr( 'pfCandsNoEle', cms.EDProducer("CandPtrProjector", src=cms.InputTag(pfCandidates), veto=electrons)) pfCandsNoEleMu = addattr( 'pfCandsNoEleMu', cms.EDProducer("CandPtrProjector", src=pfCandsNoEle, veto=muons)) pfCandsNoEleMuTau = addattr( 'pfCandsNoEleMuTau', cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMu, veto=taus)) pfCandsNoEleMuTauGamma = addattr( 'pfCandsNoEleMuTauGamma', cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMuTau, veto=photons)) pfCandsForUnclusteredUnc = addattr( 'pfCandsForUnclusteredUnc', cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMuTauGamma, veto=crossCleanedJets)) for vsign, vname in [(1, 'Up'), (-1, 'Down')]: shiftConf = [('MuonEn', muons.value(), '((x<100)?(0.002+0*y):(0.05+0*y))'), ('ElectronEn', electrons.value(), '((abs(y)<1.479)?(0.006+0*x):(0.015+0*x))'), ('PhotonEn', photons.value(), '((abs(y)<1.479)?(0.01+0*x):(0.025+0*x))'), ('TauEn', taus.value(), '0.03+0*x*y'), ('UnclusteredEn', pfCandsForUnclusteredUnc.value(), ''), ('JetEn', crossCleanedJets.value(), '')] for part, coll, formula in shiftConf: if part == 'UnclusteredEn': shifted = addattr( 'shifted' + part + vname, cms.EDProducer( "ShiftedParticleProducer", src=pfCandsForUnclusteredUnc, binning=cms.VPSet( # charged PF hadrons - tracker resolution cms.PSet( binSelection=cms.string('charge!=0'), binUncertainty=cms.string( 'sqrt(pow(0.00009*x,2)+pow(0.0085/sqrt(sin(2*atan(exp(-y)))),2))' )), # neutral PF hadrons - HCAL resolution cms.PSet( binSelection=cms.string('pdgId==130'), energyDependency=cms.bool(True), binUncertainty=cms.string( '((abs(y)<1.3)?(min(0.25,sqrt(0.64/x+0.0025))):(min(0.30,sqrt(1.0/x+0.0016))))' )), # photon - ECAL resolution cms.PSet(binSelection=cms.string('pdgId==22'), energyDependency=cms.bool(True), binUncertainty=cms.string( 'sqrt(0.0009/x+0.000001)+0*y')), # HF particules - HF resolution cms.PSet(binSelection=cms.string( 'pdgId==1 || pdgId==2'), energyDependency=cms.bool(True), binUncertainty=cms.string( 'sqrt(1./x+0.0025)+0*y')), ), shiftBy=cms.double(float(vsign)))) elif part == 'JetEn': shifted = addattr( 'shifted' + part + vname, cms.EDProducer( 'SUEPShiftedPATJetProducer', src=crossCleanedJets, jetCorrPayloadName=cms.string(jetFlavor), jetCorrUncertaintyTag=cms.string('Uncertainty'), addResidualJES=cms.bool(isData), jetCorrLabelUpToL3=cms.InputTag( 'L3Absolute'), # use embedded correction factors jetCorrLabelUpToL3Res=cms.InputTag('L2L3Residual'), shiftBy=cms.double(float(vsign)))) else: shifted = addattr( 'shifted' + part + vname, cms.EDProducer("ShiftedParticleProducer", src=cms.InputTag(coll), uncertainty=cms.string(formula), shiftBy=cms.double(float(vsign)))) metCorrShifted = addattr( 'metCorrShifted' + part + vname, cms.EDProducer("ShiftedParticleMETcorrInputProducer", srcOriginal=cms.InputTag(coll), srcShifted=shifted)) addattr( 'patPFMetT1' + part + vname, patMET_cff.patPFMetT1.clone(src=patPFMetT1, srcCorrections=[metCorrShifted])) # Dummy JetResUp and JetResDown modules because PATJetSlimmer requires them # Jet smearing should be propagated to MET simply by using ptSmear(|Up|Down) branches at the ntuples level addattr('patPFMetT1JetResUp', getattr(process, 'patPFMetT1JetEnUp' + postfix).clone()) addattr('patPFMetT1JetResDown', getattr(process, 'patPFMetT1JetEnDown' + postfix).clone()) addattr( 'slimmedMETs', slimmedMETs.clone(src=patPFMetT1, rawVariation=patPFMet, t1Uncertainties="patPFMetT1%s" + postfix, runningOnMiniAOD=True)) slimmed = addattr.last if postfix == '': # default MET slimmed.caloMET = 'patCaloMet' else: del slimmed.caloMET del slimmed.t01Variation del slimmed.t1SmearedVarsAndUncs del slimmed.tXYUncForT1 del slimmed.tXYUncForRaw del slimmed.tXYUncForT01 del slimmed.tXYUncForT1Smear del slimmed.tXYUncForT01Smear return sequence