def produce_final_states(process, collections, output_commands, sequence, puTag, buildFSAEvent=True, noTracks=False, noPhotons=False): muonsrc = collections['muons'] esrc = collections['electrons'] tausrc = collections['taus'] jetsrc = collections['jets'] pfmetsrc = collections['pfmet'] mvametsrc = collections['mvamet'] phosrc = collections['photons'] # Build the PATFinalStateEventObject if buildFSAEvent: process.load("FinalStateAnalysis.PatTools." "finalStates.patFinalStateEventProducer_cfi") process.patFinalStateEventProducer.electronSrc = cms.InputTag(esrc) process.patFinalStateEventProducer.muonSrc = cms.InputTag(muonsrc) process.patFinalStateEventProducer.tauSrc = cms.InputTag(tausrc) process.patFinalStateEventProducer.jetSrc = cms.InputTag(jetsrc) process.patFinalStateEventProducer.phoSrc = cms.InputTag(phosrc) process.patFinalStateEventProducer.metSrc = pfmetsrc process.patFinalStateEventProducer.puTag = cms.string(puTag) process.patFinalStateEventProducer.mets.pfmet = pfmetsrc process.patFinalStateEventProducer.mets.mvamet = mvametsrc sequence += process.patFinalStateEventProducer # Always keep output_commands.append('*_patFinalStateEventProducer_*_*') # Apply some loose PT cuts on the objects we use to create the final states # so the combinatorics don't blow up process.muonsForFinalStates = cms.EDFilter( "PATMuonRefSelector", src=cms.InputTag(muonsrc), cut=cms.string('max(pt, userFloat("maxCorPt")) > 4 ' '& (isGlobalMuon | isTrackerMuon)'), filter=cms.bool(False), ) process.electronsForFinalStates = cms.EDFilter( "PATElectronRefSelector", src=cms.InputTag(esrc), cut=cms.string('abs(superCluster().eta) < 3.0 ' '& max(pt, userFloat("maxCorPt")) > 7'), filter=cms.bool(False), ) process.photonsForFinalStates = cms.EDFilter( "PATPhotonRefSelector", src=cms.InputTag(phosrc), cut=cms.string('abs(superCluster().eta()) < 3.0 & pt > 10'), filter=cms.bool(False), ) # Require that the PT of the jet (either corrected jet or tau) # to be greater than 17 process.tausForFinalStates = cms.EDFilter( "PATTauRefSelector", src=cms.InputTag(tausrc), cut=cms.string('abs(eta) < 2.5 & pt > 17 & tauID("decayModeFinding")'), filter=cms.bool(False), ) process.jetsForFinalStates = cms.EDProducer("PATJetCleaner", src = cms.InputTag(jetsrc), # preselection (any string-based cut on pat::Jet) preselection = cms.string("pt>20 & abs(eta) < 2.5 & userFloat('idLoose') & userFloat('fullDiscriminant')"), # overlap checking configurables checkOverlaps = cms.PSet( muons = cms.PSet( src = cms.InputTag("muonsForFinalStates"), algorithm = cms.string("byDeltaR"), preselection = cms.string("pt>10&&isGlobalMuon&&isTrackerMuon&&(chargedHadronIso()+max(photonIso+neutralHadronIso(),0.0))/pt()<0.3"), deltaR = cms.double(0.3), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True), ), electrons = cms.PSet( src = cms.InputTag("electronsForFinalStates"), algorithm = cms.string("byDeltaR"), preselection = cms.string("pt>10&&(chargedHadronIso()+max(photonIso()+neutralHadronIso(),0.0))/pt()<0.3"), deltaR = cms.double(0.3), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True), ), ), # finalCut (any string-based cut on pat::Jet) finalCut = cms.string('') ) process.selectObjectsForFinalStates = cms.Sequence( process.muonsForFinalStates + process.electronsForFinalStates + process.tausForFinalStates + process.jetsForFinalStates ) if not noPhotons: process.selectObjectsForFinalStates += process.photonsForFinalStates sequence += process.selectObjectsForFinalStates # Now build all combinatorics for E/Mu/Tau/Photon object_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates")), ('Tau', cms.InputTag("tausForFinalStates")), ('Jet', cms.InputTag("jetsForFinalStates"))] if not noPhotons: object_types.append(('Pho', cms.InputTag("photonsForFinalStates"))) process.buildDiObjects = cms.Sequence() process.load("FinalStateAnalysis.PatTools." "finalStates.patFinalStatesEmbedExtraCollections_cfi") # If we don't have tracks, don't fit the FS vertices if noTracks: process.patFinalStateVertexFitter.enable = False # Build di-object pairs for diobject in _combinatorics(object_types, 2): # Don't build two jet states if (diobject[0][0], diobject[1][0]) == ('Tau', 'Tau'): continue if (diobject[0][0], diobject[1][0]) == ('Tau', 'Pho'): continue if (diobject[0][0], diobject[1][0]) == ('Tau', 'Jet'): continue if (diobject[0][0], diobject[1][0]) == ('Jet', 'Pho'): continue if (diobject[0][0], diobject[1][0]) == ('Jet', 'Jet'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%sFinalStateProducer" % (diobject[0][0], diobject[1][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=diobject[0][1], leg2Src=diobject[1][1], # X-cleaning cut=cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s" % (diobject[0][0], diobject[1][0]) setattr(process, producer_name + "Raw", producer) process.buildDiObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildDiObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildDiObjects += final_module setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildDiObjects # Build tri-lepton pairs process.buildTriObjects = cms.Sequence() for triobject in _combinatorics(object_types, 3): # Don't build three jet states if (triobject[0][0], triobject[1][0], triobject[2][0]) == \ ('Tau', 'Tau', 'Tau'): continue n_taus = [x[0] for x in triobject].count('Tau') n_phos = [x[0] for x in triobject].count('Pho') n_muons = [x[0] for x in triobject].count('Mu') n_jets = [x[0] for x in triobject].count('Jet') if n_taus > 2: continue if n_phos > 2: continue if n_taus and n_phos: continue if n_jets > 0 and not (n_jets == 2 and n_muons == 1): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%sFinalStateProducer" % (triobject[0][0], triobject[1][0], triobject[2][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=triobject[0][1], leg2Src=triobject[1][1], leg3Src=triobject[2][1], # X-cleaning cut=cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s" % ( triobject[0][0], triobject[1][0], triobject[2][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildTriObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildTriObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildTriObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildTriObjects # Build 4 lepton final states process.buildQuadObjects = cms.Sequence() for quadobject in _combinatorics(object_types, 4): # Don't build states with more than 2 hadronic taus or phos n_taus = [x[0] for x in quadobject].count('Tau') n_phos = [x[0] for x in quadobject].count('Pho') n_jets = [x[0] for x in quadobject].count('Jet') if n_taus > 2: continue if n_phos > 2: continue if n_taus and n_phos: continue if n_jets> 0: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateProducer" % (quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=quadobject[0][1], leg2Src=quadobject[1][1], leg3Src=quadobject[2][1], leg4Src=quadobject[3][1], # X-cleaning cut=cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s%s" % ( quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0] ) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildQuadObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildQuadObjects
def produce_final_states(process, collections, output_commands, sequence, puTag, buildFSAEvent=True, noTracks=False, noPhotons=False, zzMode=False, rochCor="", eleCor=""): muonsrc = collections['muons'] esrc = collections['electrons'] tausrc = collections['taus'] jetsrc = collections['jets'] pfmetsrc = collections['pfmet'] mvametsrc = collections['mvamet'] phosrc = collections['photons'] try: fsrsrc = collections['fsr'] except KeyError: fsrsrc = 'boostedFsrPhotons' # Build the PATFinalStateEventObject if buildFSAEvent: process.load("FinalStateAnalysis.PatTools." "finalStates.patFinalStateEventProducer_cfi") process.patFinalStateEventProducer.electronSrc = cms.InputTag(esrc) process.patFinalStateEventProducer.muonSrc = cms.InputTag(muonsrc) process.patFinalStateEventProducer.tauSrc = cms.InputTag(tausrc) process.patFinalStateEventProducer.jetSrc = cms.InputTag(jetsrc) process.patFinalStateEventProducer.phoSrc = cms.InputTag(phosrc) process.patFinalStateEventProducer.metSrc = pfmetsrc process.patFinalStateEventProducer.puTag = cms.string(puTag) process.patFinalStateEventProducer.mets.pfmet = pfmetsrc process.patFinalStateEventProducer.mets.mvamet = mvametsrc sequence += process.patFinalStateEventProducer # Always keep output_commands.append('*_patFinalStateEventProducer_*_*') # Apply some loose PT cuts on the objects we use to create the final states # so the combinatorics don't blow up if zzMode: import hzzPreselection muon_string, elec_string = hzzPreselection.getStrings() else: muon_string = ('max(pt, userFloat("maxCorPt")) > 4 &' '& (isGlobalMuon | isTrackerMuon)') elec_string = ('abs(superCluster().eta) < 3.0 ' '& max(pt, userFloat("maxCorPt")) > 7') # Initialize final-state object sequence process.selectObjectsForFinalStates = cms.Sequence() # Are we applying Rochester Corrections to the muons? if rochCor != "": if rochCor not in ["RochCor2012", "RochCor2011A", "RochCor2011B"]: raise RuntimeError(rochCor + ": not a valid option") print "-- Applying Muon Rochester Corrections --" process.rochCorMuons = cms.EDProducer("PATMuonRochesterCorrector", src=cms.InputTag(muonsrc), corr_type=cms.string("p4_" + rochCor)) muonsrc = "rochCorMuons" process.selectObjectsForFinalStates += process.rochCorMuons # Are we applying electron energy corrections? if eleCor != "": if eleCor not in [ "Summer12_DR53X_HCP2012", "2012Jul13ReReco", "Fall11" ]: raise RuntimeError(eleCor + ": not a valid option") print "-- Applying Electron Energy Corrections --" process.corrElectrons = cms.EDProducer( "PATElectronEnergyCorrector", src=cms.InputTag(esrc), corr_type=cms.string("EGCorr_" + eleCor + "SmearedRegression")) esrc = "corrElectrons" process.selectObjectsForFinalStates += process.corrElectrons process.muonsRank = cms.EDProducer("PATMuonRanker", src=cms.InputTag(muonsrc)) process.muonsForFinalStates = cms.EDFilter( "PATMuonRefSelector", src=cms.InputTag("muonsRank"), cut=cms.string(muon_string), filter=cms.bool(False), ) process.electronsRank = cms.EDProducer("PATElectronRanker", src=cms.InputTag(esrc)) process.electronsForFinalStates = cms.EDFilter( "PATElectronRefSelector", src=cms.InputTag("electronsRank"), cut=cms.string(elec_string), filter=cms.bool(False), ) process.photonsForFinalStates = cms.EDFilter( "PATPhotonRefSelector", src=cms.InputTag(phosrc), cut=cms.string('abs(superCluster().eta()) < 3.0 & pt > 10'), filter=cms.bool(False), ) process.tausES = cms.EDProducer("ESTauProducer", src=cms.InputTag(tausrc)) process.tausRank = cms.EDProducer("PATTauRanker", src=cms.InputTag("tausES")) # Require that the PT of the jet (either corrected jet or tau) # to be greater than 17 process.tausForFinalStates = cms.EDFilter( "PATTauRefSelector", src=cms.InputTag("tausRank"), cut=cms.string('abs(eta) < 2.5 & pt > 17 & tauID("decayModeFinding")'), filter=cms.bool(False), ) process.jetsFiltered = cms.EDProducer( "PATJetCleaner", src=cms.InputTag(jetsrc), # I leave it loose here, can be tightened at the last step preselection=cms.string( "pt>20 & abs(eta) < 2.5 & " "userFloat('idLoose') & userInt('fullIdLoose')"), # overlap checking configurables checkOverlaps=cms.PSet( muons=cms.PSet( src=cms.InputTag("muonsForFinalStates"), algorithm=cms.string("byDeltaR"), preselection=cms.string( "pt>10&&isGlobalMuon&&isTrackerMuon&&" "(userIso(0)+max(photonIso()+neutralHadronIso()" "-0.5*puChargedHadronIso(),0))/pt()<0.3"), deltaR=cms.double(0.3), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), electrons=cms.PSet( src=cms.InputTag("electronsForFinalStates"), algorithm=cms.string("byDeltaR"), preselection=cms.string( "pt>10&&userFloat('wp95')>0" "&&(userIso(0)+max(userIso(1)+neutralHadronIso()" "-0.5*userIso(2),0.0))/pt()<0.3"), deltaR=cms.double(0.3), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), ), # finalCut (any string-based cut on pat::Jet) finalCut=cms.string('')) process.jetsForFinalStates = cms.EDProducer( "PATJetRanker", src=cms.InputTag("jetsFiltered")) process.selectObjectsForFinalStates = cms.Sequence( process.muonsRank + process.muonsForFinalStates + process.electronsRank + process.electronsForFinalStates + process.tausES + process.tausRank + process.tausForFinalStates + process.jetsFiltered + process.jetsForFinalStates) if not noPhotons: process.selectObjectsForFinalStates += process.photonsForFinalStates sequence += process.selectObjectsForFinalStates # Now build all combinatorics for E/Mu/Tau/Photon object_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates")), ('Tau', cms.InputTag("tausForFinalStates")), ('Jet', cms.InputTag("jetsForFinalStates"))] if not noPhotons: object_types.append(('Pho', cms.InputTag("photonsForFinalStates"))) process.buildDiObjects = cms.Sequence() process.load("FinalStateAnalysis.PatTools." "finalStates.patFinalStatesEmbedExtraCollections_cfi") # If we don't have tracks, don't fit the FS vertices if noTracks: process.patFinalStateVertexFitter.enable = False # Build di-object pairs for diobject in _combinatorics(object_types, 2): # Don't build two jet states if (diobject[0][0], diobject[1][0]) == ('Tau', 'Tau'): continue if (diobject[0][0], diobject[1][0]) == ('Tau', 'Pho'): continue if (diobject[0][0], diobject[1][0]) == ('Tau', 'Jet'): continue if (diobject[0][0], diobject[1][0]) == ('Jet', 'Pho'): continue if (diobject[0][0], diobject[1][0]) == ('Jet', 'Jet'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%sFinalStateProducer" % (diobject[0][0], diobject[1][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=diobject[0][1], leg2Src=diobject[1][1], # X-cleaning cut=cms.string(' & '.join(cuts))) producer_name = "finalState%s%s" % (diobject[0][0], diobject[1][0]) setattr(process, producer_name + "Raw", producer) process.buildDiObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildDiObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer("PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildDiObjects += final_module setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildDiObjects # Build tri-lepton pairs process.buildTriObjects = cms.Sequence() for triobject in _combinatorics(object_types, 3): # Don't build three jet states if (triobject[0][0], triobject[1][0], triobject[2][0]) == \ ('Tau', 'Tau', 'Tau'): continue n_taus = [x[0] for x in triobject].count('Tau') n_phos = [x[0] for x in triobject].count('Pho') n_muons = [x[0] for x in triobject].count('Mu') n_jets = [x[0] for x in triobject].count('Jet') if n_taus > 2: continue if n_phos > 2: continue if n_taus and n_phos: continue if n_jets > 0 and not (n_jets == 2 and n_muons == 1): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%sFinalStateProducer" % (triobject[0][0], triobject[1][0], triobject[2][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=triobject[0][1], leg2Src=triobject[1][1], leg3Src=triobject[2][1], # X-cleaning cut=cms.string(' & '.join(cuts))) producer_name = "finalState%s%s%s" % (triobject[0][0], triobject[1][0], triobject[2][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildTriObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildTriObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer("PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildTriObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildTriObjects # Build 4 lepton final states process.buildQuadObjects = cms.Sequence() for quadobject in _combinatorics(object_types, 4): # Don't build states with more than 2 hadronic taus or phos n_taus = [x[0] for x in quadobject].count('Tau') n_phos = [x[0] for x in quadobject].count('Pho') n_jets = [x[0] for x in quadobject].count('Jet') if n_taus > 2: continue if n_phos > 2: continue if n_taus and n_phos: continue if n_jets > 0: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateProducer" % (quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=quadobject[0][1], leg2Src=quadobject[1][1], leg3Src=quadobject[2][1], leg4Src=quadobject[3][1], # X-cleaning cut=cms.string(' & '.join(cuts))) producer_name = "finalState%s%s%s%s" % ( quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer("PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildQuadObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildQuadObjects # Build 4 lepton final states w/ FSR if zzMode: zz_object_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates"))] process.buildQuadHzzObjects = cms.Sequence() for quadobject in _combinatorics(zz_object_types, 4): n_elec = [x[0] for x in quadobject].count('Elec') n_muon = [x[0] for x in quadobject].count('Mu') if n_elec % 2 == 1: continue if n_muon % 2 == 1: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateHzzProducer" % (quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=quadobject[0][1], leg2Src=quadobject[1][1], leg3Src=quadobject[2][1], leg4Src=quadobject[3][1], photonSrc=cms.InputTag(fsrsrc), # X-cleaning cut=cms.string('')) producer_name = "finalState%s%s%s%sHzz" % ( quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadHzzObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadHzzObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer("PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildQuadHzzObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildQuadHzzObjects
def produce_final_states(process, collections, output_commands, sequence, puTag, buildFSAEvent=True, noTracks=False, noPhotons=False, zzMode=False, rochCor="", eleCor=""): muonsrc = collections['muons'] esrc = collections['electrons'] tausrc = collections['taus'] jetsrc = collections['jets'] pfmetsrc = collections['pfmet'] mvametsrc = collections['mvamet'] phosrc = collections['photons'] try: fsrsrc = collections['fsr'] except KeyError: fsrsrc = 'boostedFsrPhotons' # Build the PATFinalStateEventObject if buildFSAEvent: process.load("FinalStateAnalysis.PatTools." "finalStates.patFinalStateEventProducer_cfi") process.patFinalStateEventProducer.electronSrc = cms.InputTag(esrc) process.patFinalStateEventProducer.muonSrc = cms.InputTag(muonsrc) process.patFinalStateEventProducer.tauSrc = cms.InputTag(tausrc) process.patFinalStateEventProducer.jetSrc = cms.InputTag(jetsrc) process.patFinalStateEventProducer.phoSrc = cms.InputTag(phosrc) process.patFinalStateEventProducer.metSrc = pfmetsrc process.patFinalStateEventProducer.puTag = cms.string(puTag) process.patFinalStateEventProducer.mets.pfmet = pfmetsrc process.patFinalStateEventProducer.mets.mvamet = mvametsrc if 'extraWeights' in collections: process.patFinalStateEventProducer.extraWeights = collections['extraWeights'] sequence += process.patFinalStateEventProducer # Always keep output_commands.append('*_patFinalStateEventProducer_*_*') # Apply some loose PT cuts on the objects we use to create the final states # so the combinatorics don't blow up if zzMode: import hzzPreselection muon_string, elec_string = hzzPreselection.getStrings() else: muon_string = ( 'max(pt, userFloat("maxCorPt")) > 4 &' '& (isGlobalMuon | isTrackerMuon)' ) elec_string = ( 'abs(superCluster().eta) < 3.0 ' '& max(pt, userFloat("maxCorPt")) > 7' ) # Initialize final-state object sequence process.selectObjectsForFinalStates = cms.Sequence() # Are we applying Rochester Corrections to the muons? if rochCor != "": if rochCor not in ["RochCor2012", "RochCor2011A", "RochCor2011B"]: raise RuntimeError(rochCor + ": not a valid option") print "-- Applying Muon Rochester Corrections --" process.rochCorMuons = cms.EDProducer( "PATMuonRochesterCorrector", src=cms.InputTag(muonsrc), corr_type=cms.string("p4_" + rochCor) ) muonsrc = "rochCorMuons" process.selectObjectsForFinalStates += process.rochCorMuons # Are we applying electron energy corrections? if eleCor != "": if eleCor not in ["Summer12_DR53X_HCP2012", "2012Jul13ReReco", "Fall11"]: raise RuntimeError(eleCor + ": not a valid option") print "-- Applying Electron Energy Corrections --" process.corrElectrons = cms.EDProducer( "PATElectronEnergyCorrector", src=cms.InputTag(esrc), corr_type=cms.string("EGCorr_" + eleCor + "SmearedRegression") ) esrc = "corrElectrons" process.selectObjectsForFinalStates += process.corrElectrons process.muonsRank = cms.EDProducer( "PATMuonRanker", src=cms.InputTag(muonsrc)) process.muonsForFinalStates = cms.EDFilter( "PATMuonRefSelector", src=cms.InputTag("muonsRank"), cut=cms.string(muon_string), filter=cms.bool(False), ) process.electronsRank = cms.EDProducer( "PATElectronRanker", src=cms.InputTag(esrc)) process.electronsForFinalStates = cms.EDFilter( "PATElectronRefSelector", src=cms.InputTag("electronsRank"), cut=cms.string(elec_string), filter=cms.bool(False), ) process.photonsForFinalStates = cms.EDFilter( "PATPhotonRefSelector", src=cms.InputTag(phosrc), cut=cms.string('abs(superCluster().eta()) < 3.0 & pt > 10'), filter=cms.bool(False), ) process.tausRank = cms.EDProducer( "PATTauRanker", src=cms.InputTag(tausrc)) # Require that the PT of the jet (either corrected jet or tau) # to be greater than 17 process.tausForFinalStates = cms.EDFilter( "PATTauRefSelector", src=cms.InputTag("tausRank"), cut=cms.string('abs(eta) < 2.5 & pt > 17 & tauID("decayModeFinding")'), filter=cms.bool(False), ) process.jetsFiltered = cms.EDProducer( "PATJetCleaner", src=cms.InputTag(jetsrc), # I leave it loose here, can be tightened at the last step preselection=cms.string( "pt>20 & abs(eta) < 2.5 & " "userFloat('idLoose')"), # & userInt('fullIdLoose')"), # overlap checking configurables checkOverlaps=cms.PSet( muons=cms.PSet( src=cms.InputTag("muonsForFinalStates"), algorithm=cms.string("byDeltaR"), preselection=cms.string( "pt>10&&isGlobalMuon&&isTrackerMuon&&" "(userIso(0)+max(photonIso()+neutralHadronIso()" "-0.5*puChargedHadronIso(),0))/pt()<0.3"), deltaR=cms.double(0.3), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), electrons=cms.PSet( src=cms.InputTag("electronsForFinalStates"), algorithm=cms.string("byDeltaR"), preselection=cms.string( "pt>10&&userFloat('wp95')>0" "&&(userIso(0)+max(userIso(1)+neutralHadronIso()" "-0.5*userIso(2),0.0))/pt()<0.3"), deltaR=cms.double(0.3), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(True), ), ), # finalCut (any string-based cut on pat::Jet) finalCut=cms.string('') ) process.jetsForFinalStates = cms.EDProducer( "PATJetRanker", src=cms.InputTag("jetsFiltered")) process.selectObjectsForFinalStates = cms.Sequence( process.muonsRank + process.muonsForFinalStates + process.electronsRank + process.electronsForFinalStates + process.tausRank + process.tausForFinalStates + process.jetsFiltered + process.jetsForFinalStates ) if not noPhotons: process.selectObjectsForFinalStates += process.photonsForFinalStates sequence += process.selectObjectsForFinalStates # Now build all combinatorics for E/Mu/Tau/Photon object_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates")), ('Tau', cms.InputTag("tausForFinalStates")), ('Jet', cms.InputTag("jetsForFinalStates"))] if not noPhotons: object_types.append(('Pho', cms.InputTag("photonsForFinalStates"))) process.buildDiObjects = cms.Sequence() process.load("FinalStateAnalysis.PatTools." "finalStates.patFinalStatesEmbedExtraCollections_cfi") # If we don't have tracks, don't fit the FS vertices if noTracks: process.patFinalStateVertexFitter.enable = False # Build di-object pairs for diobject in _combinatorics(object_types, 2): # Don't build two jet states if (diobject[0][0], diobject[1][0]) == ('Tau', 'Tau'): continue if (diobject[0][0], diobject[1][0]) == ('Tau', 'Pho'): continue if (diobject[0][0], diobject[1][0]) == ('Tau', 'Jet'): continue if (diobject[0][0], diobject[1][0]) == ('Jet', 'Pho'): continue if (diobject[0][0], diobject[1][0]) == ('Jet', 'Jet'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%sFinalStateProducer" % (diobject[0][0], diobject[1][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=diobject[0][1], leg2Src=diobject[1][1], # X-cleaning cut=cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s" % (diobject[0][0], diobject[1][0]) setattr(process, producer_name + "Raw", producer) process.buildDiObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildDiObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildDiObjects += final_module setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildDiObjects # Build tri-lepton pairs process.buildTriObjects = cms.Sequence() for triobject in _combinatorics(object_types, 3): # Don't build three jet states if (triobject[0][0], triobject[1][0], triobject[2][0]) == \ ('Tau', 'Tau', 'Tau'): continue n_taus = [x[0] for x in triobject].count('Tau') n_phos = [x[0] for x in triobject].count('Pho') n_muons = [x[0] for x in triobject].count('Mu') n_jets = [x[0] for x in triobject].count('Jet') if n_taus > 2: continue if n_phos > 2: continue if n_taus and n_phos: continue if n_jets > 0 and not (n_jets == 2 and n_muons == 1): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%sFinalStateProducer" % (triobject[0][0], triobject[1][0], triobject[2][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=triobject[0][1], leg2Src=triobject[1][1], leg3Src=triobject[2][1], # X-cleaning cut=cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s" % ( triobject[0][0], triobject[1][0], triobject[2][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildTriObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildTriObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildTriObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildTriObjects # Build 4 lepton final states process.buildQuadObjects = cms.Sequence() for quadobject in _combinatorics(object_types, 4): # Don't build states with more than 2 hadronic taus or phos n_taus = [x[0] for x in quadobject].count('Tau') n_phos = [x[0] for x in quadobject].count('Pho') n_jets = [x[0] for x in quadobject].count('Jet') if n_taus > 2: continue if n_phos > 2: continue if n_taus and n_phos: continue if n_jets > 0: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateProducer" % (quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0]), evtSrc=cms.InputTag("patFinalStateEventProducer"), leg1Src=quadobject[0][1], leg2Src=quadobject[1][1], leg3Src=quadobject[2][1], leg4Src=quadobject[3][1], # X-cleaning cut=cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s%s" % ( quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0] ) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildQuadObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildQuadObjects # Build 4 lepton final states w/ FSR if zzMode: zz_object_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates"))] process.buildQuadHzzObjects = cms.Sequence() for quadobject in _combinatorics(zz_object_types, 4): n_elec = [x[0] for x in quadobject].count('Elec') n_muon = [x[0] for x in quadobject].count('Mu') if n_elec%2 == 1: continue if n_muon%2 == 1: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateHzzProducer" % (quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = quadobject[0][1], leg2Src = quadobject[1][1], leg3Src = quadobject[2][1], leg4Src = quadobject[3][1], photonSrc = cms.InputTag(fsrsrc), # X-cleaning cut = cms.string('') ) producer_name = "finalState%s%s%s%sHzz" % ( quadobject[0][0], quadobject[1][0], quadobject[2][0], quadobject[3][0] ) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadHzzObjects += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet( process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadHzzObjects += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src=final_module_name) setattr(process, producer_name, final_module) process.buildQuadHzzObjects += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildQuadHzzObjects
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_trackCandidates_*_*', '*_gsfTrackCandidates_*_*', #'*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5PFJets_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex_*_*') output_commands.append('*_selectPrimaryVerticesQuality_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Rho_EtaMax = cms.double(2.5), Ghost_EtaMax = cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Rerun tau-ID process.load('Configuration/StandardSequences/Services_cff') process.load('Configuration/StandardSequences/GeometryIdeal_cff') process.load('Configuration/StandardSequences/MagneticField_cff') process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff') process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove(process.pfRecoTauTagInfoProducer) assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] process.tuplize += process.recoTauClassicHPSSequence ## Run rho computation #from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets #kt6PFJets.Rho_EtaMax = cms.double(2.5) #kt6PFJets.doRhoFastjet = True #process.kt6PFJets = kt6PFJets #process.tuplize += process.kt6PFJets # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Custom veto cones process.elPFIsoValuePU04PFIdPFIso.deposits.vetos = cms.vstring() process.elPFIsoValueChargedAll04PFIdPFIso.deposits.vetos = cms.vstring( 'EcalBarrel:ConeVeto(0.01)','EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") process.tuplize += process.recoElectronID process.patElectrons.electronIDSources = process.electronIDSources process.patElectrons.embedTrack = True # Run EGamma electron energy calibration process.load("EgammaCalibratedGsfElectrons.CalibratedElectronProducers.calibratedGsfElectrons_cfi") process.RandomNumberGeneratorService.calibratedGsfElectrons = cms.PSet( initialSeed = cms.untracked.uint32(1), # A frickin billion engineName = cms.untracked.string('TRandom3') ) process.calibratedGsfElectrons.inputDataset = kwargs['dataset'] process.calibratedGsfElectrons.isMC = bool(isMC) process.calibratedGsfElectrons.isAOD = True process.calibratedGsfElectrons.updateEnergyError = cms.bool(True) # Run a sanity check on the calibration configuration. from FinalStateAnalysis.PatTools.electrons.patElectronEmbedCalibratedGsf_cfi \ import validate_egamma_calib_config validate_egamma_calib_config(process) process.tuplize += process.calibratedGsfElectrons # Keep the calibratedGsfElectrons - we embed refs to this into the # pat::Electrons output_commands.append('*_calibratedGsfElectrons_*_*') # Now run PAT process.tuplize += process.patDefaultSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False # Use PFJets and turn on JEC jec = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ] if not isMC: jec.extend([ 'L2L3Residual' ]) # Use AK5 PFJets jettools.switchJetCollection(process, cms.InputTag('ak5PFJets'), doJTA = False, doBTagging = True, jetCorrLabel = ('AK5PF', jec), #jetCorrLabel = None, doType1MET = False, doJetID = True, genJetCollection = cms.InputTag("ak5GenJets")) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False process.patJetCorrFactors.useRho = True # Let's use the same rho as in the TauID, so we don't need to do it twice. process.patJetCorrFactors.rho = cms.InputTag( "kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('patJets_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") # We have to keep all jets (for the MVA MET...) process.patJetGarbageRemoval.cut = 'pt > 0' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons") process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) process.cleanPatElectrons.src = final_electron_collection # The "effective area" calculation needs to know if it is data/mc, etc. process.patElectronMVAIsoEmbedding.target = kwargs['target'] process.patElectronEffectiveAreaEmbedder.target = kwargs['target'] process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection # The "effective area" calculation needs to know if it is data/mc, etc. process.patMuonMVAIdIsoEmbedding.target = kwargs['target'] process.patMuonEffectiveAreaEmbedder.target = kwargs['target'] process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Don't apply any prselections process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & (pt > 18 | userFloat("jetPt") > 18)' # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src = final_tau_collection, algorithm = cms.string("byDeltaR"), preselection = cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_%s_*_*' % final_met_collection.value()) #process.load("PhysicsTools.PatAlgos.triggerLayer1.triggerMatcher_cfi") #trigtools.switchOnTriggerMatchEmbedding(process) trigtools.switchOnTrigger(process) # Build the PATFinalStateEventObject process.load("FinalStateAnalysis.PatTools.finalStates.patFinalStateEventProducer_cfi") process.patFinalStateEventProducer.electronSrc = final_electron_collection process.patFinalStateEventProducer.muonSrc = cms.InputTag("cleanPatMuons") process.patFinalStateEventProducer.tauSrc = cms.InputTag("cleanPatTaus") process.patFinalStateEventProducer.jetSrc = cms.InputTag("selectedPatJets") process.patFinalStateEventProducer.metSrc = final_met_collection process.tuplize += process.patFinalStateEventProducer output_commands.append('*_patFinalStateEventProducer_*_*') process.patFinalStateEventProducer.puTag = cms.string(kwargs['puTag']) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Apply some loose PT cuts on the objects we use to create the final states # so the combinatorics don't blow up process.muonsForFinalStates = cms.EDFilter( "PATMuonRefSelector", src = cms.InputTag("cleanPatMuons"), cut = cms.string('pt > 4'), filter = cms.bool(False), ) process.electronsForFinalStates = cms.EDFilter( "PATElectronRefSelector", src = cms.InputTag("cleanPatElectrons"), cut = cms.string('abs(eta) < 2.5 & pt > 4'), filter = cms.bool(False), ) # Require that the PT of the jet (either corrected jet or tau) # to be greater than 17 process.tausForFinalStates = cms.EDFilter( "PATTauRefSelector", src = cms.InputTag("cleanPatTaus"), cut = cms.string('abs(eta) < 2.5 & pt > 17 & tauID("decayModeFinding")'), filter = cms.bool(False), ) process.selectObjectsForFinalStates = cms.Sequence( process.muonsForFinalStates + process.electronsForFinalStates + process.tausForFinalStates ) process.tuplize += process.selectObjectsForFinalStates # Now build all of our DiLeptons and TriLepton final states lepton_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates")), ('Tau', cms.InputTag("tausForFinalStates"))] #lepton_types = [('Elec', cms.InputTag("cleanPatElectrons")), #('Mu', cms.InputTag("cleanPatMuons")), #('Tau', cms.InputTag("cleanPatTaus"))] process.buildDiLeptons = cms.Sequence() process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStatesEmbedExtraCollections_cfi") # Build di-lepton pairs for dilepton in _combinatorics(lepton_types, 2): # Don't build two jet states if (dilepton[0][0], dilepton[1][0]) == ('Tau', 'Tau'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%sFinalStateProducer" % (dilepton[0][0], dilepton[1][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = dilepton[0][1], leg2Src = dilepton[1][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s" % (dilepton[0][0], dilepton[1][0]) setattr(process, producer_name + "Raw", producer) process.buildDiLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildDiLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = getattr(process, final_module_name.value()) final_module.setLabel(producer_name) setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) process.tuplize += process.buildDiLeptons # Build tri-lepton pairs process.buildTriLeptons = cms.Sequence() for trilepton in _combinatorics(lepton_types, 3): # Don't build three jet states if (trilepton[0][0], trilepton[1][0], trilepton[2][0]) == \ ('Tau', 'Tau', 'Tau'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%sFinalStateProducer" % (trilepton[0][0], trilepton[1][0], trilepton[2][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = trilepton[0][1], leg2Src = trilepton[1][1], leg3Src = trilepton[2][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s" % ( trilepton[0][0], trilepton[1][0], trilepton[2][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildTriLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildTriLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = getattr(process, final_module_name.value()) final_module.setLabel(producer_name) setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) process.tuplize += process.buildTriLeptons # Build 4 lepton final states process.buildQuadLeptons = cms.Sequence() for quadlepton in _combinatorics(lepton_types, 4): # Don't build states with more than 2 hadronic taus if [x[0] for x in quadlepton].count('Tau') > 2: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateProducer" % (quadlepton[0][0], quadlepton[1][0], quadlepton[2][0], quadlepton[3][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = quadlepton[0][1], leg2Src = quadlepton[1][1], leg3Src = quadlepton[2][1], leg4Src = quadlepton[3][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s%s" % ( quadlepton[0][0], quadlepton[1][0], quadlepton[2][0], quadlepton[3][0] ) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = getattr(process, final_module_name.value()) final_module.setLabel(producer_name) setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) process.tuplize += process.buildQuadLeptons # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): ''' Core function for PATTuple production ''' #fix argparser output isMC = bool(isMC) ######################## ## ## ## PATTuple content ## ## ## ######################## # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_gsfElectrons_*_*', '*_gsfElectronCores_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', # for zz muons '*_photonCore_*_*', '*_boostedFsrPhotons_*_*', # for Zmumu -> embedded samples # https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit '*_generalTracksORG_*_EmbeddedRECO', '*_electronGsfTracksORG_*_EmbeddedRECO', 'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN', 'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO', 'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO', 'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') ######################## ## ## ## PAT ## ## ## ######################## # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence ######################## ## GEN ## ######################## # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False process.patPhotons.embedGenMatch = False if not isMC: coreTools.runOnData(process) ######################## ## MUONS ## ######################## # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) ######################## ## TAUS ## ######################## # Use HPS taus tautools.switchToPFTauHPS(process) #this NEEDS a sequence called patDefaultSequence # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") # Require all taus to pass decay mode finding and have high PT process.patTauGarbageRemoval.cut = cms.string( "pt > 17 && abs(eta) < 2.5 && tauID('decayModeFindingNewDMs')") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Cuts already applied by the garbage removal process.cleanPatTaus.preselection = '' process.cleanPatTaus.finalCut = '' ######################## ## ELECTRONS ## ######################## # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") if cmssw_major_version() == 4: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID42X + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources42X else: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID5YX + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources5YX process.electronMatch.checkCharge = cms.bool(False) process.patElectrons.embedTrack = False process.patElectrons.embedPFCandidate = False process.patElectrons.embedGsfElectronCore = False process.patElectrons.embedSuperCluster = True # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") # Electron Energy Regression and Calibrations process.load( "EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi") process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi") #setup the energy regression for the specific dataset if kwargs['eleReg']: print "-- Applying Electron Regression and Calibration --" process.customizeElectronSequence += process.eleRegressionEnergy process.customizeElectronSequence += process.calibratedPatElectrons process.eleRegressionEnergy.energyRegressionType = cms.uint32(2) process.calibratedPatElectrons.correctionsType = cms.int32(2) if isMC: process.calibratedPatElectrons.inputDataset = cms.string( "Summer12_LegacyPaper") else: process.calibratedPatElectrons.inputDataset = cms.string( "22Jan2013ReReco") process.calibratedPatElectrons.combinationType = cms.int32(3) process.calibratedPatElectrons.lumiRatio = cms.double(1.0) process.calibratedPatElectrons.synchronization = cms.bool(True) process.calibratedPatElectrons.isMC = cms.bool(isMC == 1) process.calibratedPatElectrons.verbose = cms.bool(False) final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons", # Some of the EGamma modules have non-standard src InputTags, # specify them here. ("src", "inputPatElectronsTag", "inputElectronsTag") ) #process.tuplize += process.customizeElectronSequence #why do we need this? process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) # Define cleanPatElectrons input collection process.cleanPatElectrons.src = final_electron_collection # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string( 'pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) ######################## ## JETS ## ######################## # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # tmp # define the b-tag squences for offline reconstruction process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff") process.load("RecoBTau.JetTagComputer.combinedMVA_cff") process.load('RecoVertex/AdaptiveVertexFinder/inclusiveVertexing_cff') process.load('RecoBTag/SecondaryVertex/bToCharmDecayVertexMerger_cfi') #process.load("PhysicsTools.PatAlgos.patSequences_cff") # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos', 'inclusiveSecondaryVertexFinderFilteredTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'trackCountingHighPurBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'simpleSecondaryVertexHighPurBJetTags', 'simpleInclusiveSecondaryVertexHighEffBJetTags', 'simpleInclusiveSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', 'jetBProbabilityBJetTags', 'jetProbabilityBJetTags', ] #Avoid embedding process.patJets.embedPFCandidates = True process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = True process.patJets.addAssociatedTracks = True process.patJets.embedGenPartonMatch = True # Add AK5chs PFJets jettools.addJetCollection( process, cms.InputTag('ak5PFchsJets'), algoLabel = "AK5", typeLabel = "PFchs", doJTA = True, jetCorrLabel = ('AK5PFchs', jec), doType1MET = False, doL1Cleaning = False, doL1Counters = False, genJetCollection = cms.InputTag('ak5GenJets'), doJetID = True, **btag_options ) # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=True, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options ) # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'AK5PFchs' ) process.patJetGarbageRemoval.cut = 'pt > 12' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # process.customizeJetSequence += process.btagging # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) process.customizeJetSequenceAK5PFchs.remove( process.patJetsPUIDAK5PFchs ) process.customizeJetSequenceAK5PFchs.remove( process.pileupJetIdProducerAK5PFchs ) process.patJetGarbageRemovalAK5PFchs.cut = 'pt > 20' process.patJetCorrFactorsAK5PFchs.payload = cms.string('AK5PFchs') final_jetchs_collection = chain_sequence( process.customizeJetSequenceAK5PFchs, "patJetsAK5PFchs") process.customizeJetSequenceAK5PFchs.insert(0, process.patJetsAK5PFchs) # Make it a "complete" sequence process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5PFchs # We can't mess up the selected pat jets because the taus use them. process.selectedPatJetsAK5PFchs.src = final_jetchs_collection process.selectedPatJetsAK5chsPF = process.selectedPatJetsAK5PFchs.clone() #that's what we keep process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5chsPF process.patDefaultSequence.replace(process.patJetsAK5PFchs, process.customizeJetSequenceAK5PFchs) output_commands.append('*_selectedPatJets_*_*') output_commands.append('*_selectedPatJetsAK5chsPF_*_*') output_commands.append('*SecondaryVertexTagInfo*_*_*_*') output_commands.append('*TrackIPTagInfo*_*_*_*') output_commands.append('*SoftLeptonTagInfo*_*_*_*') output_commands.append('*_ak5PFJets_*_*') output_commands.append('*_ak5PFchsJets_*_*') ######################## ## MET ## ######################## # Use PFMEt mettools.addPfMET(process) # We cut out a lot of the junky taus and jets - but we need these # to correctly apply the MET uncertainties. So, let's make a # non-cleaned version of the jet and tau sequence. process.jetsForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'ForMETSyst') process.tausForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeTauSequence, 'ForMETSyst') # Don't apply any cut for these process.patTauGarbageRemovalForMETSyst.cut = '' process.patJetGarbageRemovalForMETSyst.cut = '' process.tuplize += process.jetsForMetSyst process.tuplize += process.tausForMetSyst # We have to make our clone of cleanPatTaus separately, since e/mu # cleaning is applied - therefore it isn't in the customizeTausSequence. process.cleanPatTausForMETSyst = process.cleanPatTaus.clone( src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst")) process.cleanPatTausForMETSyst.preselection = '' process.cleanPatTausForMETSyst.finalCut = '' process.patTausEmbedJetInfoForMETSyst.jetSrc = \ final_jet_collection.value() + "ForMETSyst" process.tuplize += process.cleanPatTausForMETSyst # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence process.patMETsPF.addGenMET = bool(isMC) output_commands.append('*_%s_*_*' % final_met_collection.value()) # Make a version with the MVA MET reconstruction method process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff") process.tuplize += process.pfMEtMVAsequence mva_met_sequence = helpers.cloneProcessingSnippet( process, process.customizeMETSequence, "MVA") final_mvamet_collection = chain_sequence( mva_met_sequence, "patMEtMVA") process.tuplize += mva_met_sequence output_commands.append('*_%s_*_*' % final_mvamet_collection.value()) # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # We can drop to jet and tau MET specific products. They were only used for # computation of the MET numbers. output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s' % process.name_()) ######################## ## PHOTONS ## ######################## #alter the photon matching to accept various fakes # and sort matches by d-pt-rel if isMC: process.photonMatch = cms.EDProducer( "MCMatcherByPt", src=cms.InputTag("photons"), maxDPtRel=cms.double(100.0), mcPdgId=cms.vint32(), mcStatus=cms.vint32(1), resolveByMatchQuality=cms.bool(False), maxDeltaR=cms.double(0.3), checkCharge=cms.bool(False), resolveAmbiguities=cms.bool(True), matched=cms.InputTag("genParticles") ) # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #setup PHOSPHOR for a specific dataset if cmssw_major_version() == 4: # for now 2011 = CMSSW42X process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011) else: # 2012 is 5YX process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012) process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC)) #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection ######################## ## TRIGGER ## ######################## trigtools.switchOnTrigger(process) #configure the PAT trigger if kwargs['HLTprocess']: process.patTrigger.processName = cms.string(kwargs['HLTprocess']) process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess']) ######################## ## -------------- ## ######################## output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') ######################## ## ## ## FSA ## ## ## ######################## # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'pfmet': final_met_collection, 'mvamet': final_mvamet_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag'], zzMode=kwargs.get('zzMode', False)) return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ # '*', '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsCentralHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', #for zz muons '*_photonCore_*_*', # for Zmumu -> embedded samples '*_generator_weight_*', # 2k11 "GenFilterInfo_generator_minVisPtFilter_*", #2k12 '*_genDaughters_*_*', '*_boosted*_*_*', '*_tmfTracks_*_*', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex_*_*') output_commands.append('*_selectPrimaryVerticesQuality_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Rho_EtaMax = cms.double(2.5), Ghost_EtaMax = cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Standard services process.load('Configuration.StandardSequences.Services_cff') # tack on seeds for FSA PATTuple modules add_fsa_random_seeds(process) if cmssw_major_version() == 5 and cmssw_minor_version() >= 3: process.load('Configuration.Geometry.GeometryIdeal_cff') else: process.load('Configuration.StandardSequences.GeometryIdeal_cff') process.load('Configuration.StandardSequences.MagneticField_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') # Rerun tau ID if cmssw_major_version() == 4: process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove(process.pfRecoTauTagInfoProducer) process.recoTauClassicHPSSequence.remove(process.ak5PFJetTracksAssociatorAtVertex) assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] # Don't build junky taus below 19 GeV process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17) process.tuplize += process.recoTauClassicHPSSequence else: # We can run less tau stuff in 52, since HPS taus already built. process.load("RecoTauTag.Configuration.updateHPSPFTaus_cff") process.tuplize += process.updateHPSPFTaus ## Run rho computation. Only necessary in 42X if cmssw_major_version() == 4: from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets kt6PFJets.Rho_EtaMax = cms.double(4.4) kt6PFJets.doRhoFastjet = True process.kt6PFJets = kt6PFJets process.tuplize += process.kt6PFJets # In 4_X we have to rerun ak5PFJets with area computation enabled. if cmssw_major_version() == 4: process.load("RecoJets.Configuration.RecoPFJets_cff") process.ak5PFJets.doAreaFastjet = True process.tuplize += process.ak5PFJets # Only keep the new ak5PFJets output_commands.append('*_ak5PFJets_*_%s' % process.name_()) else: # Just keep the normal ones output_commands.append('*_ak5PFJets_*_*') # In the embedded samples, we need to re-run the b-tagging if kwargs['embedded']: process.load('RecoBTag/Configuration/RecoBTag_cff') process.load('RecoJets/JetAssociationProducers/ak5JTA_cff') process.ak5JetTracksAssociatorAtVertex.jets = cms.InputTag("ak5PFJets") process.ak5JetTracksAssociatorAtVertex.tracks = cms.InputTag("tmfTracks") process.tuplize += process.ak5JetTracksAssociatorAtVertex process.tuplize += process.btagging # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") process.tuplize += process.recoElectronID process.patElectrons.electronIDSources = process.electronIDSources process.patElectrons.embedTrack = True # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False # Use PFJets and turn on JEC jec = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend([ 'L2L3Residual' ]) # Define options for BTagging - these are release dependent. btag_options = {'doBTagging' : True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', ] # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA = False, jetCorrLabel = ('AK5PF', jec), #jetCorrLabel = None, doType1MET = False, doJetID = True, genJetCollection = cms.InputTag("ak5GenJets"), **btag_options ) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False #process.patJetCorrFactors.useRho = True ## Let's use the same rho as in the TauID, so we don't need to do it twice. #process.patJetCorrFactors.rho = cms.InputTag( #"kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('*_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") # We have to keep all jets (for the MVA MET...) process.patJetGarbageRemoval.cut = 'pt > 0' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons") process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) process.cleanPatElectrons.src = final_electron_collection #setup the energy regression for the specific dataset process.patElectronEnergyCorrections.isMC = cms.bool(bool(isMC)) process.patElectronEnergyCorrections.isAOD = \ cms.bool(bool(kwargs['isAOD'])) process.patElectronEnergyCorrections.dataSet = \ cms.string(kwargs['calibrationTarget']) process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Apply a loose preselection process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & pt > 17' # Don't apply any "final" cut process.cleanPatTaus.finalCut = '' # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #inject photons into pat sequence process.customizePhotonSequence.insert(0,process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src = final_tau_collection, algorithm = cms.string("byDeltaR"), preselection = cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') output_commands.append('*_%s_*_*' % final_met_collection.value()) trigtools.switchOnTrigger(process) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons' : 'cleanPatElectrons', 'muons' : 'cleanPatMuons', 'taus' : 'cleanPatTaus', 'photons' : 'cleanPatPhotons', 'jets' : 'selectedPatJets', 'met' : final_met_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag']) return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_gsfElectrons_*_*', '*_gsfElectronCores_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', # for zz muons '*_photonCore_*_*', '*_boostedFsrPhotons_*_*', # for Zmumu -> embedded samples # https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit '*_generalTracksORG_*_EmbeddedRECO', '*_electronGsfTracksORG_*_EmbeddedRECO', 'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN', 'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO', 'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO', 'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex*_*_*') output_commands.append('*_selectPrimaryVerticesQuality*_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), Rho_EtaMax=cms.double(2.5), Ghost_EtaMax=cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Standard services process.load('Configuration.StandardSequences.Services_cff') # tack on seeds for FSA PATTuple modules add_fsa_random_seeds(process) if cmssw_major_version() == 5 and cmssw_minor_version() >= 3: process.load('Configuration.Geometry.GeometryDB_cff') else: process.load('Configuration.StandardSequences.GeometryDB_cff') process.load('Configuration.StandardSequences.MagneticField_cff') process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') # Rerun tau ID process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove( process.pfRecoTauTagInfoProducer) process.recoTauClassicHPSSequence.remove( process.ak5PFJetTracksAssociatorAtVertex) assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] # Don't build junky taus below 19 GeV process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17) process.tuplize += process.recoTauClassicHPSSequence ## Run rho computation. Only necessary in 42X if cmssw_major_version() == 4: # This function call can klobber everything if it isn't done # before the other things are attached to the process, so do it now. # The klobbering would occur through usePFIso->setupPFIso->_loadPFBRECO from CommonTools.ParticleFlow.Tools.pfIsolation import _loadPFBRECO _loadPFBRECO(process) process.load("RecoJets.Configuration.RecoPFJets_cff") process.kt6PFJets.Rho_EtaMax = cms.double(4.4) process.kt6PFJets.doRhoFastjet = True process.tuplize += process.kt6PFJets # In 4_X we have to rerun ak5PFJets with area computation enabled. if cmssw_major_version() == 4: process.load("RecoJets.Configuration.RecoPFJets_cff") process.ak5PFJets.doAreaFastjet = True process.tuplize += process.ak5PFJets # Only keep the new ak5PFJets output_commands.append('*_ak5PFJets_*_%s' % process.name_()) else: # Just keep the normal ones output_commands.append('*_ak5PFJets_*_*') # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) #alter the photon matching to accept various fakes # and sort matches by d-pt-rel if isMC: process.photonMatch = cms.EDProducer( "MCMatcherByPt", src=cms.InputTag("photons"), maxDPtRel=cms.double(100.0), mcPdgId=cms.vint32(), mcStatus=cms.vint32(1), resolveByMatchQuality=cms.bool(False), maxDeltaR=cms.double(0.3), checkCharge=cms.bool(False), resolveAmbiguities=cms.bool(True), matched=cms.InputTag("genParticles") ) # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") if cmssw_major_version() == 4: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID42X + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources42X else: process.patDefaultSequence.replace(process.patElectrons, process.recoElectronID5YX + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources5YX process.electronMatch.checkCharge = cms.bool(False) process.patElectrons.embedTrack = False process.patElectrons.embedPFCandidate = False process.patElectrons.embedGsfElectronCore = False process.patElectrons.embedSuperCluster = True # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False process.patPhotons.embedGenMatch = False # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', ] # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=False, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options ) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False #process.patJetCorrFactors.useRho = True ## Let's use the same rho as in the TauID, so we don't need to do it twice. #process.patJetCorrFactors.rho = cms.InputTag( #"kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('*_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") process.patJetGarbageRemoval.cut = 'pt > 12' final_jet_collection = chain_sequence( process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") # Electron Energy Regression and Calibrations process.load( "EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi") process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi") #setup the energy regression for the specific dataset if kwargs['eleReg']: print "-- Applying Electron Regression and Calibration --" process.customizeElectronSequence += process.eleRegressionEnergy process.customizeElectronSequence += process.calibratedPatElectrons process.eleRegressionEnergy.energyRegressionType = cms.uint32(2) process.calibratedPatElectrons.correctionsType = cms.int32(2) if isMC: process.calibratedPatElectrons.inputDataset = cms.string( "Summer12_LegacyPaper") else: process.calibratedPatElectrons.inputDataset = cms.string( "22Jan2013ReReco") process.calibratedPatElectrons.combinationType = cms.int32(3) process.calibratedPatElectrons.lumiRatio = cms.double(1.0) process.calibratedPatElectrons.synchronization = cms.bool(True) process.calibratedPatElectrons.isMC = cms.bool(isMC == 1) process.calibratedPatElectrons.verbose = cms.bool(False) final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons", # Some of the EGamma modules have non-standard src InputTags, # specify them here. ("src", "inputPatElectronsTag", "inputElectronsTag") ) process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) # Define cleanPatElectrons input collection process.cleanPatElectrons.src = final_electron_collection process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence( process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") # Require all taus to pass decay mode finding and have high PT process.patTauGarbageRemoval.cut = cms.string( "pt > 17 && abs(eta) < 2.5 && tauID('decayModeFinding')") final_tau_collection = chain_sequence( process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Cuts already applied by the garbage removal process.cleanPatTaus.preselection = '' process.cleanPatTaus.finalCut = '' # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #setup PHOSPHOR for a specific dataset if cmssw_major_version() == 4: # for now 2011 = CMSSW42X process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011) else: # 2012 is 5YX process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012) process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC)) #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection # We cut out a lot of the junky taus and jets - but we need these # to correctly apply the MET uncertainties. So, let's make a # non-cleaned version of the jet and tau sequence. process.jetsForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'ForMETSyst') process.tausForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeTauSequence, 'ForMETSyst') # Don't apply any cut for these process.patTauGarbageRemovalForMETSyst.cut = '' process.patJetGarbageRemovalForMETSyst.cut = '' process.tuplize += process.jetsForMetSyst process.tuplize += process.tausForMetSyst # We have to make our clone of cleanPatTaus separately, since e/mu # cleaning is applied - therefore it isn't in the customizeTausSequence. process.cleanPatTausForMETSyst = process.cleanPatTaus.clone( src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst")) process.cleanPatTausForMETSyst.preselection = '' process.cleanPatTausForMETSyst.finalCut = '' process.patTausEmbedJetInfoForMETSyst.jetSrc = \ final_jet_collection.value() + "ForMETSyst" process.tuplize += process.cleanPatTausForMETSyst # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") final_met_collection = chain_sequence( process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence output_commands.append('*_%s_*_*' % final_met_collection.value()) # Make a version with the MVA MET reconstruction method process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff") process.tuplize += process.pfMEtMVAsequence mva_met_sequence = helpers.cloneProcessingSnippet( process, process.customizeMETSequence, "MVA") final_mvamet_collection = chain_sequence( mva_met_sequence, "patMEtMVA") process.tuplize += mva_met_sequence output_commands.append('*_%s_*_*' % final_mvamet_collection.value()) # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # We can drop to jet and tau MET specific products. They were only used for # computation of the MET numbers. output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string( 'pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10" ), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') trigtools.switchOnTrigger(process) #configure the PAT trigger if kwargs['HLTprocess']: process.patTrigger.processName = cms.string(kwargs['HLTprocess']) process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess']) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'pfmet': final_met_collection, 'mvamet': final_mvamet_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag'], zzMode=kwargs.get('zzMode', False)) return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): ''' Core function for PATTuple production ''' #fix argparser output isMC = bool(isMC) ######################## ## ## ## PATTuple content ## ## ## ######################## # Stuff we always keep output_commands = [ '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_gsfElectrons_*_*', '*_gsfElectronCores_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', # for zz muons '*_photonCore_*_*', '*_boostedFsrPhotons_*_*', # for Zmumu -> embedded samples # https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit '*_generalTracksORG_*_EmbeddedRECO', '*_electronGsfTracksORG_*_EmbeddedRECO', 'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN', 'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO', 'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO', 'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') ######################## ## ## ## PAT ## ## ## ######################## # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence ######################## ## GEN ## ######################## # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False process.patPhotons.embedGenMatch = False if not isMC: coreTools.runOnData(process) ######################## ## MUONS ## ######################## # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence(process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) ######################## ## TAUS ## ######################## # Use HPS taus tautools.switchToPFTauHPS( process) #this NEEDS a sequence called patDefaultSequence # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") # Require all taus to pass decay mode finding and have high PT process.patTauGarbageRemoval.cut = cms.string( "pt > 17 && abs(eta) < 2.5 && tauID('decayModeFindingNewDMs')") final_tau_collection = chain_sequence(process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Cuts already applied by the garbage removal process.cleanPatTaus.preselection = '' process.cleanPatTaus.finalCut = '' ######################## ## ELECTRONS ## ######################## # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") if cmssw_major_version() == 4: process.patDefaultSequence.replace( process.patElectrons, process.recoElectronID42X + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources42X else: process.patDefaultSequence.replace( process.patElectrons, process.recoElectronID5YX + process.patElectrons) process.patElectrons.electronIDSources = process.electronIDSources5YX process.electronMatch.checkCharge = cms.bool(False) process.patElectrons.embedTrack = False process.patElectrons.embedPFCandidate = False process.patElectrons.embedGsfElectronCore = False process.patElectrons.embedSuperCluster = True # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") # Electron Energy Regression and Calibrations process.load( "EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi") process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi") #setup the energy regression for the specific dataset if kwargs['eleReg']: print "-- Applying Electron Regression and Calibration --" process.customizeElectronSequence += process.eleRegressionEnergy process.customizeElectronSequence += process.calibratedPatElectrons process.eleRegressionEnergy.energyRegressionType = cms.uint32(2) process.calibratedPatElectrons.correctionsType = cms.int32(2) if isMC: process.calibratedPatElectrons.inputDataset = cms.string( "Summer12_LegacyPaper") else: process.calibratedPatElectrons.inputDataset = cms.string( "22Jan2013ReReco") process.calibratedPatElectrons.combinationType = cms.int32(3) process.calibratedPatElectrons.lumiRatio = cms.double(1.0) process.calibratedPatElectrons.synchronization = cms.bool(True) process.calibratedPatElectrons.isMC = cms.bool(isMC == 1) process.calibratedPatElectrons.verbose = cms.bool(False) final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons", # Some of the EGamma modules have non-standard src InputTags, # specify them here. ("src", "inputPatElectronsTag", "inputElectronsTag")) #process.tuplize += process.customizeElectronSequence #why do we need this? process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) # Define cleanPatElectrons input collection process.cleanPatElectrons.src = final_electron_collection # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10"), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) ######################## ## JETS ## ######################## # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # tmp # define the b-tag squences for offline reconstruction process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff") process.load("RecoBTau.JetTagComputer.combinedMVA_cff") process.load('RecoVertex/AdaptiveVertexFinder/inclusiveVertexing_cff') process.load('RecoBTag/SecondaryVertex/bToCharmDecayVertexMerger_cfi') #process.load("PhysicsTools.PatAlgos.patSequences_cff") # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos', 'inclusiveSecondaryVertexFinderFilteredTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'trackCountingHighPurBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'simpleSecondaryVertexHighPurBJetTags', 'simpleInclusiveSecondaryVertexHighEffBJetTags', 'simpleInclusiveSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', 'jetBProbabilityBJetTags', 'jetProbabilityBJetTags', ] #Avoid embedding process.patJets.embedPFCandidates = True process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = True process.patJets.addAssociatedTracks = True process.patJets.embedGenPartonMatch = True # Add AK5chs PFJets jettools.addJetCollection(process, cms.InputTag('ak5PFchsJets'), algoLabel="AK5", typeLabel="PFchs", doJTA=True, jetCorrLabel=('AK5PFchs', jec), doType1MET=False, doL1Cleaning=False, doL1Counters=False, genJetCollection=cms.InputTag('ak5GenJets'), doJetID=True, **btag_options) # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=True, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options) # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") helpers.cloneProcessingSnippet(process, process.customizeJetSequence, 'AK5PFchs') process.patJetGarbageRemoval.cut = 'pt > 12' final_jet_collection = chain_sequence(process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # process.customizeJetSequence += process.btagging # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) process.customizeJetSequenceAK5PFchs.remove(process.patJetsPUIDAK5PFchs) process.customizeJetSequenceAK5PFchs.remove( process.pileupJetIdProducerAK5PFchs) process.patJetGarbageRemovalAK5PFchs.cut = 'pt > 20' process.patJetCorrFactorsAK5PFchs.payload = cms.string('AK5PFchs') final_jetchs_collection = chain_sequence( process.customizeJetSequenceAK5PFchs, "patJetsAK5PFchs") process.customizeJetSequenceAK5PFchs.insert(0, process.patJetsAK5PFchs) # Make it a "complete" sequence process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5PFchs # We can't mess up the selected pat jets because the taus use them. process.selectedPatJetsAK5PFchs.src = final_jetchs_collection process.selectedPatJetsAK5chsPF = process.selectedPatJetsAK5PFchs.clone( ) #that's what we keep process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5chsPF process.patDefaultSequence.replace(process.patJetsAK5PFchs, process.customizeJetSequenceAK5PFchs) output_commands.append('*_selectedPatJets_*_*') output_commands.append('*_selectedPatJetsAK5chsPF_*_*') output_commands.append('*SecondaryVertexTagInfo*_*_*_*') output_commands.append('*TrackIPTagInfo*_*_*_*') output_commands.append('*SoftLeptonTagInfo*_*_*_*') output_commands.append('*_ak5PFJets_*_*') output_commands.append('*_ak5PFchsJets_*_*') ######################## ## MET ## ######################## # Use PFMEt mettools.addPfMET(process) # We cut out a lot of the junky taus and jets - but we need these # to correctly apply the MET uncertainties. So, let's make a # non-cleaned version of the jet and tau sequence. process.jetsForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'ForMETSyst') process.tausForMetSyst = helpers.cloneProcessingSnippet( process, process.customizeTauSequence, 'ForMETSyst') # Don't apply any cut for these process.patTauGarbageRemovalForMETSyst.cut = '' process.patJetGarbageRemovalForMETSyst.cut = '' process.tuplize += process.jetsForMetSyst process.tuplize += process.tausForMetSyst # We have to make our clone of cleanPatTaus separately, since e/mu # cleaning is applied - therefore it isn't in the customizeTausSequence. process.cleanPatTausForMETSyst = process.cleanPatTaus.clone( src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst")) process.cleanPatTausForMETSyst.preselection = '' process.cleanPatTausForMETSyst.finalCut = '' process.patTausEmbedJetInfoForMETSyst.jetSrc = \ final_jet_collection.value() + "ForMETSyst" process.tuplize += process.cleanPatTausForMETSyst # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") final_met_collection = chain_sequence(process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence process.patMETsPF.addGenMET = bool(isMC) output_commands.append('*_%s_*_*' % final_met_collection.value()) # Make a version with the MVA MET reconstruction method process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff") process.tuplize += process.pfMEtMVAsequence mva_met_sequence = helpers.cloneProcessingSnippet( process, process.customizeMETSequence, "MVA") final_mvamet_collection = chain_sequence(mva_met_sequence, "patMEtMVA") process.tuplize += mva_met_sequence output_commands.append('*_%s_*_*' % final_mvamet_collection.value()) # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # We can drop to jet and tau MET specific products. They were only used for # computation of the MET numbers. output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s' % process.name_()) ######################## ## PHOTONS ## ######################## #alter the photon matching to accept various fakes # and sort matches by d-pt-rel if isMC: process.photonMatch = cms.EDProducer( "MCMatcherByPt", src=cms.InputTag("photons"), maxDPtRel=cms.double(100.0), mcPdgId=cms.vint32(), mcStatus=cms.vint32(1), resolveByMatchQuality=cms.bool(False), maxDeltaR=cms.double(0.3), checkCharge=cms.bool(False), resolveAmbiguities=cms.bool(True), matched=cms.InputTag("genParticles")) # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #setup PHOSPHOR for a specific dataset if cmssw_major_version() == 4: # for now 2011 = CMSSW42X process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011) else: # 2012 is 5YX process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012) process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC)) #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection ######################## ## TRIGGER ## ######################## trigtools.switchOnTrigger(process) #configure the PAT trigger if kwargs['HLTprocess']: process.patTrigger.processName = cms.string(kwargs['HLTprocess']) process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess']) ######################## ## -------------- ## ######################## output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') ######################## ## ## ## FSA ## ## ## ######################## # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'pfmet': final_met_collection, 'mvamet': final_mvamet_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag'], zzMode=kwargs.get('zzMode', False)) return process.tuplize, output_commands
def configurePatTuple(process, isMC=True, **kwargs): # Stuff we always keep output_commands = [ # '*', '*_addPileupInfo_*_*', 'edmMergeableCounter_*_*_*', '*_lumiProducer_*_*', '*_particleFlow_*_*', '*_offlineBeamSpot_*_*', '*_generalTracks_*_*', '*_electronGsfTracks_*_*', '*_offlinePrimaryVertices*_*_*', '*_ak5GenJets_*_*', '*_hltTriggerSummaryAOD_*_*', 'edmTriggerResults_TriggerResults_*_%s' % process.name_(), '*_MEtoEDMConverter*_*_%s' % process.name_(), 'LHEEventProduct_*_*_*', 'GenEventInfoProduct_generator_*_*', '*_kt6PFJetsForRhoComputationVoronoi_rho_*', '*_kt6PFJetsForIso_rho_*', '*_kt6PFJets_rho_*', '*_kt6PFJetsCentralHZGPho_rho_*', '*_kt6PFJetsCentralHZGEle_rho_*', '*_kt6PFJetsCentralHZGMu_rho_*', '*_kt6PFJetsCentralNeutralHZGMu_rho_*', '*_kt6PFJetsCentral_rho_*', '*_kt6PFJetsCentralNeutral_rho_*', #for zz muons '*_photonCore_*_*', # for Zmumu -> embedded samples '*_generator_weight_*', # 2k11 "GenFilterInfo_generator_minVisPtFilter_*", #2k12 '*_genDaughters_*_*', '*_boosted*_*_*', '*_tmfTracks_*_*', ] # Define our patTuple production sequence process.tuplize = cms.Sequence() # Only keep interesting genParticles process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi") process.genParticles = process.prunedGenParticles.clone() if isMC: #process.tuplize += process.genParticles #output_commands.append('*_genParticles_*_%s' % process.name_()) output_commands.append('*_genParticles_*_*') output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*') output_commands.append('*_tauGenJets_*_*') output_commands.append('*_ak5GenJets_*_*') # Select vertices process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff") output_commands.append('*_selectedPrimaryVertex_*_*') output_commands.append('*_selectPrimaryVerticesQuality_*_*') process.tuplize += process.selectPrimaryVertices # Run the ZZ recipe for rho from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \ as zzCantDoAnythingRight process.kt6PFJetsForIso = zzCantDoAnythingRight.clone( rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), Rho_EtaMax=cms.double(2.5), Ghost_EtaMax=cms.double(2.5), ) process.tuplize += process.kt6PFJetsForIso # Standard services process.load('Configuration.StandardSequences.Services_cff') # tack on seeds for FSA PATTuple modules add_fsa_random_seeds(process) if cmssw_major_version() == 5 and cmssw_minor_version() >= 3: process.load('Configuration.Geometry.GeometryIdeal_cff') else: process.load('Configuration.StandardSequences.GeometryIdeal_cff') process.load('Configuration.StandardSequences.MagneticField_cff') process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') # Rerun tau ID if cmssw_major_version() == 4: process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") # Optimization - remove PFTauTagInfo compatibility layer process.recoTauClassicHPSSequence.remove( process.pfRecoTauTagInfoProducer) process.recoTauClassicHPSSequence.remove( process.ak5PFJetTracksAssociatorAtVertex) assert (process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround') del process.combinatoricRecoTaus.modifiers[3] # Don't build junky taus below 19 GeV process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17) process.tuplize += process.recoTauClassicHPSSequence else: # We can run less tau stuff in 52, since HPS taus already built. process.load("RecoTauTag.Configuration.updateHPSPFTaus_cff") process.tuplize += process.updateHPSPFTaus ## Run rho computation. Only necessary in 42X if cmssw_major_version() == 4: from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets kt6PFJets.Rho_EtaMax = cms.double(4.4) kt6PFJets.doRhoFastjet = True process.kt6PFJets = kt6PFJets process.tuplize += process.kt6PFJets # In 4_X we have to rerun ak5PFJets with area computation enabled. if cmssw_major_version() == 4: process.load("RecoJets.Configuration.RecoPFJets_cff") process.ak5PFJets.doAreaFastjet = True process.tuplize += process.ak5PFJets # Only keep the new ak5PFJets output_commands.append('*_ak5PFJets_*_%s' % process.name_()) else: # Just keep the normal ones output_commands.append('*_ak5PFJets_*_*') # In the embedded samples, we need to re-run the b-tagging if kwargs['embedded']: process.load('RecoBTag/Configuration/RecoBTag_cff') process.load('RecoJets/JetAssociationProducers/ak5JTA_cff') process.ak5JetTracksAssociatorAtVertex.jets = cms.InputTag("ak5PFJets") process.ak5JetTracksAssociatorAtVertex.tracks = cms.InputTag( "tmfTracks") process.tuplize += process.ak5JetTracksAssociatorAtVertex process.tuplize += process.btagging # Run pat default sequence process.load("PhysicsTools.PatAlgos.patSequences_cff") # Embed PF Isolation in electrons & muons pfTools.usePFIso(process) # Setup H2Tau custom iso definitions setup_h2tau_iso(process) # Setup hZg custom iso definitions add_hZg_iso_needs(process) # Use POG recommendations for (these) electron Isos process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)') process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') # Unembed junk process.patMuons.embedCaloMETMuonCorrs = False process.patMuons.embedTcMETMuonCorrs = False process.patMuons.embedTrack = True process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex") # Do extra electron ID process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff") process.tuplize += process.recoElectronID process.patElectrons.electronIDSources = process.electronIDSources process.patElectrons.embedTrack = True # Now run PAT process.tuplize += process.patDefaultSequence # Add FSR photons for ZZ analysis process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff") process.tuplize += process.fsrPhotonSequence # Use HPS taus tautools.switchToPFTauHPS(process) # Disable tau IsoDeposits process.patDefaultSequence.remove(process.patPFTauIsolation) process.patTaus.isoDeposits = cms.PSet() process.patTaus.userIsolation = cms.PSet() # Disable gen match embedding - we keep it in the ntuple process.patMuons.embedGenMatch = False process.patElectrons.embedGenMatch = False process.patTaus.embedGenMatch = False process.patTaus.embedGenJetMatch = False # Use PFJets and turn on JEC jec = ['L1FastJet', 'L2Relative', 'L3Absolute'] # If we are running on data (not MC), or embedded sample, # apply the MC-DATA residual correction. if not isMC or kwargs['embedded']: jec.extend(['L2L3Residual']) # Define options for BTagging - these are release dependent. btag_options = {'doBTagging': True} if cmssw_major_version() == 5: btag_options['btagInfo'] = [ 'impactParameterTagInfos', 'secondaryVertexTagInfos', 'softMuonTagInfos', 'secondaryVertexNegativeTagInfos' ] btag_options['btagdiscriminators'] = [ 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags', 'combinedSecondaryVertexMVABJetTags', 'combinedSecondaryVertexBJetTags', ] # Use AK5 PFJets jettools.switchJetCollection( process, cms.InputTag('ak5PFJets'), doJTA=False, jetCorrLabel=('AK5PF', jec), #jetCorrLabel = None, doType1MET=False, doJetID=True, genJetCollection=cms.InputTag("ak5GenJets"), **btag_options) process.patJets.embedPFCandidates = False process.patJets.embedCaloTowers = False process.patJets.embedGenJetMatch = False process.patJets.addAssociatedTracks = False process.patJets.embedGenPartonMatch = False #process.patJetCorrFactors.useRho = True ## Let's use the same rho as in the TauID, so we don't need to do it twice. #process.patJetCorrFactors.rho = cms.InputTag( #"kt6PFJetsForRhoComputationVoronoi", "rho") # Use PFMEt mettools.addPfMET(process) if not isMC: coreTools.runOnData(process) process.patMETsPF.addGenMET = False output_commands.append('*_selectedPatJets_*_*') # Customize/embed all our sequences process.load("FinalStateAnalysis.PatTools.patJetProduction_cff") # We have to keep all jets (for the MVA MET...) process.patJetGarbageRemoval.cut = 'pt > 0' final_jet_collection = chain_sequence(process.customizeJetSequence, "patJets") process.customizeJetSequence.insert(0, process.patJets) # Make it a "complete" sequence process.customizeJetSequence += process.selectedPatJets # We can't mess up the selected pat jets because the taus use them. process.selectedPatJets.src = final_jet_collection process.patDefaultSequence.replace(process.patJets, process.customizeJetSequence) # Produce the electron collections process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff") final_electron_collection = chain_sequence( process.customizeElectronSequence, "selectedPatElectrons") process.tuplize += process.customizeElectronSequence process.customizeElectronSequence.insert(0, process.selectedPatElectrons) process.patDefaultSequence.replace(process.selectedPatElectrons, process.customizeElectronSequence) # We have to do the pat Jets before the pat electrons since we embed them process.customizeElectronSequence.insert(0, process.selectedPatJets) process.cleanPatElectrons.src = final_electron_collection #setup the energy regression for the specific dataset process.patElectronEnergyCorrections.isMC = cms.bool(bool(isMC)) process.patElectronEnergyCorrections.isAOD = \ cms.bool(bool(kwargs['isAOD'])) process.patElectronEnergyCorrections.dataSet = \ cms.string(kwargs['calibrationTarget']) process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff") final_muon_collection = chain_sequence(process.customizeMuonSequence, "selectedPatMuons") process.customizeMuonSequence.insert(0, process.selectedPatMuons) process.patDefaultSequence.replace(process.selectedPatMuons, process.customizeMuonSequence) process.cleanPatMuons.src = final_muon_collection process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC)) process.load("FinalStateAnalysis.PatTools.patTauProduction_cff") final_tau_collection = chain_sequence(process.customizeTauSequence, "selectedPatTaus") # Inject into the pat sequence process.customizeTauSequence.insert(0, process.selectedPatTaus) process.patDefaultSequence.replace(process.selectedPatTaus, process.customizeTauSequence) process.cleanPatTaus.src = final_tau_collection # Remove muons and electrons process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False # Apply a loose preselection process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & pt > 17' # Don't apply any "final" cut process.cleanPatTaus.finalCut = '' # Setup pat::Photon Production process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff") final_photon_collection = chain_sequence(process.customizePhotonSequence, "selectedPatPhotons") #inject photons into pat sequence process.customizePhotonSequence.insert(0, process.selectedPatPhotons) process.patDefaultSequence.replace(process.selectedPatPhotons, process.customizePhotonSequence) process.cleanPatPhotons.src = final_photon_collection # Setup MET production process.load("FinalStateAnalysis.PatTools.patMETProduction_cff") final_met_collection = chain_sequence(process.customizeMETSequence, "patMETsPF") process.tuplize += process.customizeMETSequence # The MET systematics depend on all other systematics process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus") process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons") process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons") # Keep all the data formats needed for the systematics output_commands.append('recoLeafCandidates_*_*_%s' % process.name_()) # Define the default lepton cleaning process.cleanPatElectrons.preselection = cms.string('pt > 5') process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False # Make sure we don't kill any good taus by calling them electrons # Note that we don't actually remove these overlaps. process.cleanPatElectrons.checkOverlaps.taus = cms.PSet( src=final_tau_collection, algorithm=cms.string("byDeltaR"), preselection=cms.string( "tauID('decayModeFinding') > 0.5 &&" "tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&" "tauID('againstElectronLoose') > 0.5 && " "pt > 10"), deltaR=cms.double(0.1), checkRecoComponents=cms.bool(False), pairCut=cms.string(""), requireNoOverlaps=cms.bool(False), ) output_commands.append('*_cleanPatTaus_*_*') output_commands.append('*_cleanPatElectrons_*_*') output_commands.append('*_cleanPatMuons_*_*') output_commands.append('*_cleanPatPhotons_*_*') output_commands.append('*_%s_*_*' % final_met_collection.value()) trigtools.switchOnTrigger(process) # Now build the PATFinalStateLS object, which holds LumiSection info. process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi") process.tuplize += process.finalStateLS output_commands.append('*_finalStateLS_*_*') if isMC: process.finalStateLS.xSec = kwargs['xSec'] # Tell the framework to shut up! process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Which collections are used to build the final states fs_daughter_inputs = { 'electrons': 'cleanPatElectrons', 'muons': 'cleanPatMuons', 'taus': 'cleanPatTaus', 'photons': 'cleanPatPhotons', 'jets': 'selectedPatJets', 'met': final_met_collection, } # Setup all the PATFinalState objects produce_final_states(process, fs_daughter_inputs, output_commands, process.tuplize, kwargs['puTag']) return process.tuplize, output_commands
def produce_final_states(process, collections, output_commands, sequence, puTag, buildFSAEvent=True, noTracks=False): muonsrc = collections['muons'] esrc = collections['electrons'] tausrc = collections['taus'] jetsrc = collections['jets'] metsrc = collections['met'] # Build the PATFinalStateEventObject if buildFSAEvent == True: process.load("FinalStateAnalysis.PatTools.finalStates.patFinalStateEventProducer_cfi") process.patFinalStateEventProducer.electronSrc = cms.InputTag(esrc) process.patFinalStateEventProducer.muonSrc = cms.InputTag(muonsrc) process.patFinalStateEventProducer.tauSrc = cms.InputTag(tausrc) process.patFinalStateEventProducer.jetSrc = cms.InputTag(jetsrc) process.patFinalStateEventProducer.metSrc = metsrc process.patFinalStateEventProducer.puTag = cms.string(puTag) sequence += process.patFinalStateEventProducer elif buildFSAEvent == 'eFix': # Temporary workaround for the 2012-05-28 PAT tuples # Copy the existing FS Event, but update the electron collection ref. process.patFinalStateEventProducer = cms.EDProducer( "PATFinalStateElectronFixer", fseSrc = cms.InputTag("patFinalStateEventProducer"), electronSrc = cms.InputTag(esrc) ) sequence += process.patFinalStateEventProducer # Always keep output_commands.append('*_patFinalStateEventProducer_*_*') # Apply some loose PT cuts on the objects we use to create the final states # so the combinatorics don't blow up process.muonsForFinalStates = cms.EDFilter( "PATMuonRefSelector", src = cms.InputTag(muonsrc), cut = cms.string('pt > 4'), filter = cms.bool(False), ) process.electronsForFinalStates = cms.EDFilter( "PATElectronRefSelector", src = cms.InputTag(esrc), cut = cms.string('abs(eta) < 2.5 & pt > 4'), filter = cms.bool(False), ) # Require that the PT of the jet (either corrected jet or tau) # to be greater than 17 process.tausForFinalStates = cms.EDFilter( "PATTauRefSelector", src = cms.InputTag(tausrc), cut = cms.string('abs(eta) < 2.5 & pt > 17 & tauID("decayModeFinding")'), filter = cms.bool(False), ) process.selectObjectsForFinalStates = cms.Sequence( process.muonsForFinalStates + process.electronsForFinalStates + process.tausForFinalStates ) sequence += process.selectObjectsForFinalStates # Now build all of our DiLeptons and TriLepton final states lepton_types = [('Elec', cms.InputTag("electronsForFinalStates")), ('Mu', cms.InputTag("muonsForFinalStates")), ('Tau', cms.InputTag("tausForFinalStates"))] process.buildDiLeptons = cms.Sequence() process.load( "FinalStateAnalysis.PatTools.finalStates.patFinalStatesEmbedExtraCollections_cfi") # If we don't have tracks, don't fit the FS vertices if noTracks: process.patFinalStateVertexFitter.enable = False # Build di-lepton pairs for dilepton in _combinatorics(lepton_types, 2): # Don't build two jet states if (dilepton[0][0], dilepton[1][0]) == ('Tau', 'Tau'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%sFinalStateProducer" % (dilepton[0][0], dilepton[1][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = dilepton[0][1], leg2Src = dilepton[1][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s" % (dilepton[0][0], dilepton[1][0]) setattr(process, producer_name + "Raw", producer) process.buildDiLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildDiLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src = final_module_name ) setattr(process, producer_name, final_module) process.buildDiLeptons += final_module setattr(process, producer_name, final_module) output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildDiLeptons # Build tri-lepton pairs process.buildTriLeptons = cms.Sequence() for trilepton in _combinatorics(lepton_types, 3): # Don't build three jet states if (trilepton[0][0], trilepton[1][0], trilepton[2][0]) == \ ('Tau', 'Tau', 'Tau'): continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%sFinalStateProducer" % (trilepton[0][0], trilepton[1][0], trilepton[2][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = trilepton[0][1], leg2Src = trilepton[1][1], leg3Src = trilepton[2][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s" % ( trilepton[0][0], trilepton[1][0], trilepton[2][0]) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildTriLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildTriLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src = final_module_name ) setattr(process, producer_name, final_module) process.buildTriLeptons += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildTriLeptons # Build 4 lepton final states process.buildQuadLeptons = cms.Sequence() for quadlepton in _combinatorics(lepton_types, 4): # Don't build states with more than 2 hadronic taus if [x[0] for x in quadlepton].count('Tau') > 2: continue # Define some basic selections for building combinations cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning producer = cms.EDProducer( "PAT%s%s%s%sFinalStateProducer" % (quadlepton[0][0], quadlepton[1][0], quadlepton[2][0], quadlepton[3][0]), evtSrc = cms.InputTag("patFinalStateEventProducer"), leg1Src = quadlepton[0][1], leg2Src = quadlepton[1][1], leg3Src = quadlepton[2][1], leg4Src = quadlepton[3][1], # X-cleaning cut = cms.string(' & '.join(cuts)) ) producer_name = "finalState%s%s%s%s" % ( quadlepton[0][0], quadlepton[1][0], quadlepton[2][0], quadlepton[3][0] ) #setattr(process, producer_name, producer) #process.buildTriLeptons += producer setattr(process, producer_name + "Raw", producer) process.buildQuadLeptons += producer # Embed the other collections embedder_seq = helpers.cloneProcessingSnippet(process, process.patFinalStatesEmbedObjects, producer_name) process.buildQuadLeptons += embedder_seq # Do some trickery so the final module has a nice output name final_module_name = chain_sequence(embedder_seq, producer_name + "Raw") final_module = cms.EDProducer( "PATFinalStateCopier", src = final_module_name ) setattr(process, producer_name, final_module) process.buildQuadLeptons += final_module output_commands.append("*_%s_*_*" % producer_name) sequence += process.buildQuadLeptons