コード例 #1
0
def addFlashggPF(process):
  print "JET PRODUCER :: Flashgg PF producer ::"
  from RecoJets.JetProducers.ak4PFJets_cfi  import ak4PFJets
  from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
  
  process.ak4PFJets  = ak4PFJets.clone (src = 'packedPFCandidates', doAreaFastjet = True)
  process.ak4GenJets = ak4GenJets.clone(src = 'packedGenParticles')
  ## cluster the jets
  addJetCollection(
    process,
    labelName      = 'AK4PF',
    jetSource      = cms.InputTag('ak4PFJets'),
    pvSource       = cms.InputTag('offlineSlimmedPrimaryVertices'),
    pfCandidates   = cms.InputTag('packedPFCandidates'),
    svSource       = cms.InputTag('slimmedSecondaryVertices'),
    btagDiscriminators = [ flashggBTag ],
    jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'),
    
    genJetCollection = cms.InputTag('ak4GenJets'),
    genParticles     = cms.InputTag('prunedGenParticles'),
    # jet param
    algo = 'AK', rParam = 0.4
  )
  ## adjust MC matching
  process.patJetGenJetMatchAK4PF.matched = "ak4GenJets"
  process.patJetPartonMatchAK4PF.matched = "prunedGenParticles"
  #process.patJetPartons.particles        = "prunedGenParticles"
  
  #adjust PV used for Jet Corrections
  process.patJetCorrFactorsAK4PF.primaryVertices = "offlineSlimmedPrimaryVertices"
コード例 #2
0
def addFlashggPFCHSLegJets(process):
  #process.load("Configuration.StandardSequences.Geometry_cff")
	#process.myPrefer = cms.ESPrefer("CaloSubdetectorGeometry" [,"ZDC"
	#                                   [,ZdcGeometryFromDBEP = cms.vstring("<C++ data type>[/<data label>]"[,...])]
	#																	                                   )
	# load various necessary plugins.
  process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
  process.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')
	# leptons to remove as per default CHS workflow
  process.selectedMuons = cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedMuons"), cut = cms.string('''abs(eta)<2.5 && pt>10. &&
				(pfIsolationR04().sumChargedHadronPt+
				 max(0.,pfIsolationR04().sumNeutralHadronEt+
					 pfIsolationR04().sumPhotonEt-
					 0.50*pfIsolationR04().sumPUPt))/pt < 0.20 && 
				(isPFMuon && (isGlobalMuon || isTrackerMuon) )'''))
  process.selectedElectrons = cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedElectrons"), cut = cms.string('''abs(eta)<2.5 && pt>20. &&
				gsfTrack.isAvailable() &&
				gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
				(pfIsolationVariables().sumChargedHadronPt+
				 max(0.,pfIsolationVariables().sumNeutralHadronEt+
					 pfIsolationVariables().sumPhotonEt-
					 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15'''))
	# Simple producer which just removes the Candidates which don't come from the legacy vertex according to the Flashgg Vertex Map
  process.flashggCHSLegacyVertexCandidates = cms.EDProducer('FlashggCHSLegacyVertexCandidateProducer',
                                                          PFCandidatesTag=cms.untracked.InputTag('packedPFCandidates'),
                                                          DiPhotonTag=cms.untracked.InputTag('flashggDiPhotons'),
                                                          VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
                                                          VertexTag=cms.untracked.InputTag('offlineSlimmedPrimaryVertices')
                                                  )
  process.pfCHSLeg = cms.EDFilter("CandPtrSelector", src = cms.InputTag("flashggCHSLegacyVertexCandidates"), cut = cms.string(""))
  # then remove the previously selected muons
  process.pfNoMuonCHSLeg =  cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHSLeg"), veto = cms.InputTag("selectedMuons"))
  # then remove the previously selected electrons
  process.pfNoElectronsCHSLeg = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHSLeg"), veto =  cms.InputTag("selectedElectrons"))
  #Import RECO jet producer for ak4 PF and GEN jet
  from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
  from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
  process.ak4PFJetsCHSLeg = ak4PFJets.clone(src = 'pfNoElectronsCHSLeg', doAreaFastjet = True)
  process.ak4GenJetsLeg = ak4GenJets.clone(src = 'packedGenParticles')
	# cluster the jets
  addJetCollection(
      process,
      postfix   = "",
      labelName = 'AK4PFCHSLeg',
		  pfCandidates = cms.InputTag('packedPFCandidates'),
      jetSource = cms.InputTag('ak4PFJetsCHSLeg'),
      #trackSource = cms.InputTag('unpackedTracksAndVertices'), 
      pvSource = cms.InputTag('unpackedTracksAndVertices'), 
      jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
      #btagDiscriminators = [      'combinedSecondaryVertexBJetTags'     ]
      btagDiscriminators = [      'pfJetProbabilityBJetTags'     ]
      ,algo= 'AK', rParam = 0.4
      )
  # adjust MC matching
  process.patJetGenJetMatchAK4PFCHSLeg.matched = "ak4GenJetsLeg"
  process.patJetPartonMatchAK4PFCHSLeg.matched = "prunedGenParticles"
  process.patJetPartons.particles = "prunedGenParticles"
  # adjust PV collection used for Jet Corrections
  process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices"
コード例 #3
0
  def addGenJetCollection(self,
      proc,
      jet,
      inputCollection    = "",
      minPtFastjet       = None,
    ):
    print("jetCollectionTools::GenJetAdder::addGenJetCollection: Adding Gen Jet Collection: {}".format(jet))

    #
    # Decide which genJet collection we are dealing with
    #
    genJetInfo = GenJetInfo(jet,inputCollection)
    jetLower = genJetInfo.jetLower
    jetUpper = genJetInfo.jetUpper

    #=======================================================
    #
    # If genJet collection in MiniAOD is not 
    # specified, build the genjet collection.
    #
    #========================================================
    if not inputCollection:
      print("jetCollectionTools::GenJetAdder::addGenJetCollection: inputCollection not specified. Building genjet collection now")
      #
      # Setup GenParticles
      #
      packedGenPartNoNu = "packedGenParticlesForJetsNoNu"
      if packedGenPartNoNu not in self.prerequisites:
        self.addProcessAndTask(proc, packedGenPartNoNu, cms.EDFilter("CandPtrSelector",
            src = cms.InputTag("packedGenParticles"),
            cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"),
          )
        )
        self.prerequisites.append(packedGenPartNoNu)    
      #
      # Create the GenJet collection
      #
      genJetsCollection = "{}{}{}".format(genJetInfo.jetAlgo.upper(), genJetInfo.jetSize, 'GenJetsNoNu')
      self.addProcessAndTask(proc, genJetsCollection, ak4GenJets.clone(
          src           = packedGenPartNoNu,
          jetAlgorithm  = cms.string(supportedJetAlgos[genJetInfo.jetAlgo]),
          rParam        = cms.double(genJetInfo.jetSizeNr),
        )
      )
      #
      # Set minimum pt threshold of gen jets to be saved after fastjet clustering
      #
      if minPtFastjet != None:
        getattr(proc, genJetsCollection).jetPtMin = minPtFastjet
      self.prerequisites.append(genJetsCollection)

    return genJetInfo
コード例 #4
0
def defineGenTtbarCategorizerSequence(process):

    process.ak4GenJetsCustom = ak4GenJets.clone(
        src='packedGenParticles',
        rParam=cms.double(0.4),
        jetAlgorithm=cms.string("AntiKt"))
    process.genJetFlavourPlusLeptonInfos = genJetFlavourPlusLeptonInfos.clone(
        jets='ak4GenJetsCustom',
        rParam=cms.double(0.4),
        jetAlgorithm=cms.string("AntiKt"))
    process.matchGenBHadron = matchGenBHadron.clone(
        genParticles='prunedGenParticles')
    process.matchGenCHadron = matchGenCHadron.clone(
        genParticles='prunedGenParticles')
    process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
        particles='prunedGenParticles')
    process.categorizeGenTtbar = cms.EDProducer(
        "GenTtbarCategorizer",
        # Phase space of additional jets
        genJetPtMin=cms.double(20.),
        genJetAbsEtaMax=cms.double(2.4),
        # Input tags holding information about b/c hadron matching
        genJets=cms.InputTag("ak4GenJetsCustom"),
        genBHadJetIndex=cms.InputTag("matchGenBHadron", "genBHadJetIndex"),
        genBHadFlavour=cms.InputTag("matchGenBHadron", "genBHadFlavour"),
        genBHadFromTopWeakDecay=cms.InputTag("matchGenBHadron",
                                             "genBHadFromTopWeakDecay"),
        genBHadPlusMothers=cms.InputTag("matchGenBHadron",
                                        "genBHadPlusMothers"),
        genBHadPlusMothersIndices=cms.InputTag("matchGenBHadron",
                                               "genBHadPlusMothersIndices"),
        genBHadIndex=cms.InputTag("matchGenBHadron", "genBHadIndex"),
        genBHadLeptonHadronIndex=cms.InputTag("matchGenBHadron",
                                              "genBHadLeptonHadronIndex"),
        genBHadLeptonViaTau=cms.InputTag("matchGenBHadron",
                                         "genBHadLeptonViaTau"),
        genCHadJetIndex=cms.InputTag("matchGenCHadron", "genCHadJetIndex"),
        genCHadFlavour=cms.InputTag("matchGenCHadron", "genCHadFlavour"),
        genCHadFromTopWeakDecay=cms.InputTag("matchGenCHadron",
                                             "genCHadFromTopWeakDecay"),
        genCHadBHadronId=cms.InputTag("matchGenCHadron", "genCHadBHadronId"),
    )
    process.genTtbarCategorizerSequence = cms.Sequence(
        process.ak4GenJetsCustom * process.genJetFlavourPlusLeptonInfos *
        process.matchGenBHadron * process.matchGenCHadron *
        process.categorizeGenTtbar)
コード例 #5
0
def defineGenTtbarCategorizerSequence(process):
    
    process.ak4GenJetsCustom = ak4GenJets.clone(src = 'packedGenParticles',
                                                rParam = cms.double(0.4),
                                                jetAlgorithm = cms.string("AntiKt")
                                                )
    process.genJetFlavourPlusLeptonInfos = genJetFlavourPlusLeptonInfos.clone( jets = 'ak4GenJetsCustom',
                                                                               rParam = cms.double(0.4),
                                                                               jetAlgorithm = cms.string("AntiKt")
                                                                               )
    process.matchGenBHadron = matchGenBHadron.clone(genParticles = 'prunedGenParticles')
    process.matchGenCHadron = matchGenCHadron.clone(genParticles = 'prunedGenParticles')
    process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(particles = 'prunedGenParticles')
    process.categorizeGenTtbar = cms.EDProducer("GenTtbarCategorizer",
                                                # Phase space of additional jets
                                                genJetPtMin = cms.double(20.),
                                                genJetAbsEtaMax = cms.double(2.4),
                                                # Input tags holding information about b/c hadron matching
                                                genJets = cms.InputTag("ak4GenJetsCustom"),
                                                genBHadJetIndex = cms.InputTag("matchGenBHadron", "genBHadJetIndex"),
                                                genBHadFlavour = cms.InputTag("matchGenBHadron", "genBHadFlavour"),
                                                genBHadFromTopWeakDecay = cms.InputTag("matchGenBHadron", "genBHadFromTopWeakDecay"),
                                                genBHadPlusMothers = cms.InputTag("matchGenBHadron", "genBHadPlusMothers"),
                                                genBHadPlusMothersIndices = cms.InputTag("matchGenBHadron", "genBHadPlusMothersIndices"),
                                                genBHadIndex = cms.InputTag("matchGenBHadron", "genBHadIndex"),
                                                genBHadLeptonHadronIndex = cms.InputTag("matchGenBHadron", "genBHadLeptonHadronIndex"),
                                                genBHadLeptonViaTau = cms.InputTag("matchGenBHadron", "genBHadLeptonViaTau"),
                                                genCHadJetIndex = cms.InputTag("matchGenCHadron", "genCHadJetIndex"),
                                                genCHadFlavour = cms.InputTag("matchGenCHadron", "genCHadFlavour"),
                                                genCHadFromTopWeakDecay = cms.InputTag("matchGenCHadron", "genCHadFromTopWeakDecay"),
                                                genCHadBHadronId = cms.InputTag("matchGenCHadron", "genCHadBHadronId"),
                                                )
    process.genTtbarCategorizerSequence=cms.Sequence(process.ak4GenJetsCustom
                                                     *process.genJetFlavourPlusLeptonInfos
                                                     *process.matchGenBHadron
                                                     *process.matchGenCHadron
                                                     *process.categorizeGenTtbar)
コード例 #6
0
ファイル: RecoGenJets_cff.py プロジェクト: CMS-HGCAL/cmssw
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
from RecoJets.JetProducers.ak8GenJets_cfi import ak8GenJets

from RecoHI.HiJetAlgos.HiGenJets_cff import *

ak4GenJetsNoNu = ak4GenJets.clone(src=cms.InputTag("genParticlesForJetsNoNu"))
ak8GenJetsNoNu = ak8GenJets.clone(src=cms.InputTag("genParticlesForJetsNoNu"))

ak4GenJetsNoMuNoNu = ak4GenJets.clone(
    src=cms.InputTag("genParticlesForJetsNoMuNoNu"))
ak8GenJetsNoMuNoNu = ak8GenJets.clone(
    src=cms.InputTag("genParticlesForJetsNoMuNoNu"))

recoGenJetsTask = cms.Task(ak4GenJets, ak8GenJets, ak4GenJetsNoNu,
                           ak8GenJetsNoNu)
recoGenJets = cms.Sequence(recoGenJetsTask)

recoAllGenJets = cms.Sequence(ak4GenJets + ak8GenJets)

recoAllGenJetsNoNu = cms.Sequence(ak4GenJetsNoNu + ak8GenJetsNoNu)

recoAllGenJetsNoMuNoNu = cms.Sequence(ak4GenJetsNoMuNoNu + ak8GenJetsNoMuNoNu)
コード例 #7
0
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

ak8GenJets = ak4GenJets.clone(
    rParam       = 0.8
)

ak8GenJetsSoftDrop = ak8GenJets.clone(
    useSoftDrop = cms.bool(True),
    zcut = cms.double(0.1),
    beta = cms.double(0.0),
    R0   = cms.double(0.8),
    useExplicitGhosts = cms.bool(True),
    writeCompound = cms.bool(True),
    jetCollInstanceName = cms.string("SubJets"),
    jetPtMin = 100.0
)

ak8GenJetsConstituents = cms.EDProducer("GenJetConstituentSelector",
                                          src = cms.InputTag("ak8GenJets"),
                                          cut = cms.string("pt > 100.0")
                                         )
コード例 #8
0
        veto=cms.InputTag("selectedElectrons"))

    process.pfNoMuon = cms.EDProducer("CandPtrProjector",
                                      src=cms.InputTag("packedPFCandidates"),
                                      veto=cms.InputTag("selectedMuons"))
    process.pfNoElectrons = cms.EDProducer(
        "CandPtrProjector",
        src=cms.InputTag("pfNoMuon"),
        veto=cms.InputTag("selectedElectrons"))

    process.packedGenParticlesForJetsNoNu = cms.EDFilter(
        "CandPtrSelector",
        src=cms.InputTag("packedGenParticles"),
        cut=cms.string(
            "abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
    process.ak4GenJetsNoNu = ak4GenJets.clone(
        src='packedGenParticlesForJetsNoNu')

    if options.usePFchs:
        if options.useTopProjections:
            process.ak4PFJets = ak4PFJets.clone(src='pfNoElectronsCHS',
                                                doAreaFastjet=True)
        else:
            process.ak4PFJets = ak4PFJets.clone(src='pfCHS',
                                                doAreaFastjet=True)
    else:
        if options.useTopProjections:
            process.ak4PFJets = ak4PFJets.clone(src='pfNoElectrons',
                                                doAreaFastjet=True)
        else:
            process.ak4PFJets = ak4PFJets.clone(src='packedPFCandidates',
                                                doAreaFastjet=True)
genParticleCollection = 'prunedGenParticles'
genJetInputParticleCollection = 'packedGenParticles'

## producing a subset of particles to be used for jet clustering
from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu
process.genParticlesForJetsNoNu = genParticlesForJetsNoNu.clone(
    src=genJetInputParticleCollection)

# Supplies PDG ID to real name resolution of MC particles
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

# Producing own jets for testing purposes
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsCustom = ak4GenJets.clone(
    src='genParticlesForJetsNoNu',
    #    src = genJetInputParticleCollection,
    rParam=cms.double(0.4),
    jetAlgorithm=cms.string("AntiKt"))

# Ghost particle collection used for Hadron-Jet association
# MUST use proper input particle collection
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
    particles=genParticleCollection)

# Input particle collection for matching to gen jets (partons + leptons)
# MUST use use proper input jet collection: the jets to which hadrons should be associated
# rParam and jetAlgorithm MUST match those used for jets to be associated with hadrons
# More details on the tool: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition
from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import genJetFlavourPlusLeptonInfos
process.genJetFlavourPlusLeptonInfos = genJetFlavourPlusLeptonInfos.clone(
コード例 #10
0
process.load('RecoJets.JetProducers.QGTagger_cfi')
process.QGTagger.srcJets = cms.InputTag("selectedUpdatedPatJetsDeepFlavour")
process.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs')

process.QGTaggerSubJet = process.QGTagger.clone(
    srcJets=cms.InputTag("selectedUpdatedPatJetsSoftDropSubjetsDeepFlavour"),
    jetsLabel=cms.string('QGL_AK4PFchs'),
)

process.QGTaggerAK8 = process.QGTagger.clone(
    srcJets=cms.InputTag("selectedUpdatedPatJetsAK8DeepFlavour"),
    jetsLabel=cms.string('QGL_AK4PFchs'),
)

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsWithNu = ak4GenJets.clone(src='packedGenParticles')

## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("packedGenParticles"),
    cut=cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))

## Define GenJets
process.ak4GenJetsRecluster = ak4GenJets.clone(
    src='packedGenParticlesForJetsNoNu')

process.patGenJetMatchWithNu = cms.EDProducer(
    "GenJetMatcher",  # cut on deltaR; pick best by deltaR           
    src=cms.InputTag("selectedUpdatedPatJetsDeepFlavour"
                     ),  # RECO jets (any View<Jet> is ok) 
コード例 #11
0
def addFlashggPFCHS0(process):
  print "JET PRODUCER :: Flashgg PFCHS producer ::"
  
  # leptons to remove as per default CHS workflow
  # select the isolated leptons : electrons + muons
  process.selectedMuons     = cms.EDFilter("CandPtrSelector", 
                                           src = cms.InputTag("slimmedMuons"), 
                                           cut = cms.string('''abs(eta)<2.5 && pt>10. &&
                                           (pfIsolationR04().sumChargedHadronPt+
                                           max(0.,pfIsolationR04().sumNeutralHadronEt+
                                           pfIsolationR04().sumPhotonEt-
                                           0.50*pfIsolationR04().sumPUPt))/pt < 0.20 && 
                                           (isPFMuon && (isGlobalMuon || isTrackerMuon) )'''))
  
  process.selectedElectrons = cms.EDFilter("CandPtrSelector", 
                                           src = cms.InputTag("slimmedElectrons"), 
                                           cut = cms.string('''abs(eta)<2.5 && pt>20. &&
                                           gsfTrack.isAvailable() &&
                                           gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
                                           (pfIsolationVariables().sumChargedHadronPt+
                                           max(0.,pfIsolationVariables().sumNeutralHadronEt+
                                           pfIsolationVariables().sumPhotonEt-
                                           0.5*pfIsolationVariables().sumPUPt))/pt < 0.15'''))
  
  # Simple producer which just removes the Candidates which
  # don't come from the legacy vertex according to the Flashgg Vertex Map
  process.flashggCHSLegacyVertexCandidates = cms.EDProducer('FlashggCHSLegacyVertexCandidateProducer',
                                                            PFCandidatesTag       = cms.untracked.InputTag('packedPFCandidates'),
                                                            DiPhotonTag           = cms.untracked.InputTag('flashggDiPhotons'),
                                                            VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
                                                            VertexTag = cms.untracked.InputTag('offlineSlimmedPrimaryVertices')
                                                          )
  
  process.pfCHS0 = cms.EDFilter("CandPtrSelector", 
                                src = cms.InputTag("flashggCHSLegacyVertexCandidates"), 
                                cut = cms.string(""))
  
  # then remove the previously selected muons
  process.pfNoMuonCHS0      = cms.EDProducer("CandPtrProjector", 
                                             src  = cms.InputTag("pfCHS0"), 
                                             veto = cms.InputTag("selectedMuons"))
  # then remove the previously selected electrons
  process.pfNoElectronsCHS0 = cms.EDProducer("CandPtrProjector", 
                                             src  = cms.InputTag("pfNoMuonCHS0"), 
                                             veto = cms.InputTag("selectedElectrons"))
  
  #Import RECO jet producer for ak4 PF and GEN jet
  from RecoJets.JetProducers.ak4PFJets_cfi  import ak4PFJets
  from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
  process.ak4PFJetsCHS0 = ak4PFJets.clone ( src = 'pfNoElectronsCHS0', doAreaFastjet = True)
  process.ak4GenJets    = ak4GenJets.clone( src = 'packedGenParticles')
  
  # NOTE : these line are from the new Jet recipe 
  # The following is make patJets, but EI is done with the above
  process.load("Configuration.StandardSequences.MagneticField_cff")
  process.load("Configuration.Geometry.GeometryRecoDB_cff")
  process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
  
  
  
  # cluster the jets
  # NOTE: this is the 74X recipe for the jet clustering 
  addJetCollection(
    process,
    labelName      = 'AK4PFCHS0',
    jetSource      = cms.InputTag('ak4PFJetsCHS0'),
    pvSource       = cms.InputTag('offlineSlimmedPrimaryVertices'),
    pfCandidates   = cms.InputTag('packedPFCandidates'),
    svSource       = cms.InputTag('slimmedSecondaryVertices'),
    btagDiscriminators =  [ flashggBTag ],
    jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'),
    
    genJetCollection = cms.InputTag('ak4GenJets0'),
    genParticles     = cms.InputTag('prunedGenParticles'),
    # jet param
    algo = 'AK', rParam = 0.4
  )
  
  # adjust MC matching
  process.patJetGenJetMatchAK4PFCHS0.matched = "ak4GenJetsLeg"
  process.patJetPartonMatchAK4PFCHS0.matched = "prunedGenParticles"
  #process.patJetPartons.particles = "prunedGenParticles"

  #adjust PV used for Jet Corrections
  process.patJetCorrFactorsAK4PFCHS0.primaryVertices = "offlineSlimmedPrimaryVertices"
コード例 #12
0
def initialize(isMC=True):

    process = cms.Process("EX")
    process.source = cms.Source(
        "PoolSource",
        #fileNames = cms.untracked.vstring('root://xrootd.unl.edu//store/mc/RunIISpring15MiniAODv2/WprimeToWhToWlephbb_narrow_M-1200_13TeV-madgraph/MINIAODSIM/Asympt50ns_74X_mcRun2_asymptotic50ns_v0-v1/30000/6248D38C-8D76-E511-B243-20CF305B058C.root')
        #fileNames = cms.untracked.vstring('root://xrootd.unl.edu//store/mc/RunIISpring15MiniAODv2/WprimeToWhToWlephbb_narrow_M-4000_13TeV-madgraph/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/60000/E4EB03F2-4170-E511-B5C4-00259073E466.root')
        fileNames=cms.untracked.vstring(
            'root://xrootd.unl.edu//store/mc/RunIISpring15MiniAODv2/WprimeToMuNu_M-3000_TuneCUETP8M1_13TeV-pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/60000/10EFFE5D-4374-E511-905E-003048F0113E.root'
        ))
    process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(100))
    #    process.met = cms.EDFilter("PtMinCandViewSelector",
    #                               src = cms.InputTag("slimmedMETs"),
    #                               ptMin   = cms.double(150),
    #                       )

    #    process.metFilter = cms.EDFilter("CandViewCountFilter",
    #                                    src = cms.InputTag("met"),
    #                                     minNumber = cms.uint32(1),
    #                                     filter = cms.bool(True)
    #                                     )

    #    process.metPath = cms.Path(
    #        process.met
    #        *process.metFilter
    #        )

    #    process.EventSelection = cms.PSet(
    #        SelectEvents = cms.untracked.PSet(
    #            SelectEvents = cms.vstring(
    #                'metPath')
    #            )
    #        )

    process.OUT = cms.OutputModule(
        "PoolOutputModule",
        #                                  process.EventSelection,
        fileName=cms.untracked.string('test.root'),
        outputCommands=cms.untracked.vstring(['drop *']))
    process.endpath = cms.EndPath(process.OUT)

    # Let CMSSW take care of scheduling
    process.options = cms.untracked.PSet(
        wantSummary=cms.untracked.bool(True),
        allowUnscheduled=cms.untracked.bool(True))

    skip_ca15 = False

    ########################################
    # Boosted Substructure
    ########################################

    # Select candidates that would pass CHS requirements
    process.chs = cms.EDFilter("CandPtrSelector",
                               src=cms.InputTag("packedPFCandidates"),
                               cut=cms.string("fromPV"))

    # Apply pruning to AK R=0.8 jets
    process.ak08PFPrunedJetsCHS = cms.EDProducer(
        "FastjetJetProducer",
        PFJetParameters,
        AnomalousCellParameters,
        jetAlgorithm=cms.string("AntiKt"),
        rParam=cms.double(0.8),
        usePruning=cms.bool(True),
        nFilt=cms.int32(2),
        zcut=cms.double(0.1),
        rcut_factor=cms.double(0.5),
        useExplicitGhosts=cms.bool(True),
        writeCompound=cms.bool(True),  # Also write subjets for pruned fj
        jetCollInstanceName=cms.string("SubJets"))
    process.ak08PFPrunedJetsCHS.src = cms.InputTag("chs")
    process.ak08PFPrunedJetsCHS.jetPtMin = cms.double(200.)

    if isMC:
        process.OUT.outputCommands.append("keep *_slimmedJetsAK8_*_PAT")
    else:
        process.OUT.outputCommands.append("keep *_slimmedJetsAK8_*_RECO")

    process.OUT.outputCommands.append("keep *_ak08PFPrunedJetsCHS_*_EX")

    if not skip_ca15:
        # CA, R=1.5, pT > 200 GeV
        process.ca15PFJetsCHS = cms.EDProducer(
            "FastjetJetProducer",
            PFJetParameters,
            AnomalousCellParameters,
            jetAlgorithm=cms.string("CambridgeAachen"),
            rParam=cms.double(1.5))
        process.ca15PFJetsCHS.src = cms.InputTag("chs")
        process.ca15PFJetsCHS.jetPtMin = cms.double(200.)

        # Calculate tau1, tau2 and tau3 for ungroomed CA R=1.5 jets
        process.ca15PFJetsCHSNSubjettiness = cms.EDProducer(
            "NjettinessAdder",
            src=cms.InputTag("ca15PFJetsCHS"),
            cone=cms.double(1.5),
            Njets=cms.vuint32(1, 2, 3),
            # variables for measure definition :
            measureDefinition=cms.uint32(
                0),  # CMS default is normalized measure
            beta=cms.double(1.0),  # CMS default is 1
            R0=cms.double(1.5),  # CMS default is jet cone size
            Rcutoff=cms.double(-999.0),  # not used by default
            # variables for axes definition :
            axesDefinition=cms.uint32(6),  # CMS default is 1-pass KT axes
            nPass=cms.int32(-999),  # not used by default
            akAxesR0=cms.double(-999.0)  # not used by default
        )

        # Apply pruning to CA R=1.5 jets
        process.ca15PFPrunedJetsCHS = process.ca15PFJetsCHS.clone(
            usePruning=cms.bool(True),
            nFilt=cms.int32(2),
            zcut=cms.double(0.1),
            rcut_factor=cms.double(0.5),
            useExplicitGhosts=cms.bool(True),
            writeCompound=cms.bool(True),  # Also write subjets for pruned fj
            jetCollInstanceName=cms.string("SubJets"),
        )

        # Apply softdrop to CA R=1.5 jets
        process.ca15PFSoftdropJetsCHS = process.ca15PFJetsCHS.clone(
            useSoftDrop=cms.bool(True),
            zcut=cms.double(0.1),
            beta=cms.double(0.0),
            R0=cms.double(1.5),
            useExplicitGhosts=cms.bool(True))

        # Apply softdrop z=0.2, beta=1 to CA R=1.5 jets
        process.ca15PFSoftdropZ2B1JetsCHS = process.ca15PFJetsCHS.clone(
            useSoftDrop=cms.bool(True),
            zcut=cms.double(0.2),
            beta=cms.double(1.),
            R0=cms.double(1.5),
            useExplicitGhosts=cms.bool(True))

        # Apply trimming to CA R=1.5 jets
        process.ca15PFTrimmedJetsCHS = process.ca15PFJetsCHS.clone(
            useTrimming=cms.bool(True),
            rFilt=cms.double(0.2),
            trimPtFracMin=cms.double(0.06),
            useExplicitGhosts=cms.bool(True))

        # Calculate tau1, tau2 and tau3 for softdrop (z=0.2, beta=1) CA R=1.5 jets
        process.ca15PFSoftdropZ2B1JetsCHSNSubjettiness = cms.EDProducer(
            "NjettinessAdder",
            src=cms.InputTag("ca15PFSoftdropZ2B1JetsCHS"),
            cone=cms.double(1.5),
            Njets=cms.vuint32(1, 2, 3),
            # variables for measure definition :
            measureDefinition=cms.uint32(
                0),  # CMS default is normalized measure
            beta=cms.double(1.0),  # CMS default is 1
            R0=cms.double(1.5),  # CMS default is jet cone size
            Rcutoff=cms.double(-999.0),  # not used by default
            # variables for axes definition :
            axesDefinition=cms.uint32(6),  # CMS default is 1-pass KT axes
            nPass=cms.int32(-999),  # not used by default
            akAxesR0=cms.double(-999.0)  # not used by default
        )

        # HEPTopTagger (MultiR)
        process.looseOptRHTT = cms.EDProducer(
            "HTTTopJetProducer",
            PFJetParameters,
            AnomalousCellParameters,
            jetCollInstanceName=cms.string("SubJets"),
            useExplicitGhosts=cms.bool(True),
            writeCompound=cms.bool(True),
            optimalR=cms.bool(True),
            algorithm=cms.int32(1),
            jetAlgorithm=cms.string("CambridgeAachen"),
            rParam=cms.double(1.5),
            mode=cms.int32(4),
            minFatjetPt=cms.double(200.),
            minCandPt=cms.double(200.),
            minSubjetPt=cms.double(30.),
            minCandMass=cms.double(0.),
            maxCandMass=cms.double(1000),
            massRatioWidth=cms.double(100.),
            minM23Cut=cms.double(0.),
            minM13Cut=cms.double(0.),
            maxM13Cut=cms.double(2.))
        process.looseOptRHTT.src = cms.InputTag("chs")
        process.looseOptRHTT.jetPtMin = cms.double(200.)

        process.OUT.outputCommands.append("keep *_ca15PFJetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFPrunedJetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFSoftdropJetsCHS_*_EX")
        process.OUT.outputCommands.append(
            "keep *_ca15PFSoftdropZ2B1JetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFTrimmedJetsCHS_*_EX")
        process.OUT.outputCommands.append(
            "keep *_ca15PFJetsCHSNSubjettiness_*_EX")
        process.OUT.outputCommands.append(
            "keep *_ca15PFSoftdropZ2B1JetsCHSNSubjettiness_*_EX")
        process.OUT.outputCommands.append("keep *_looseOptRHTT_*_EX")

    ########################################
    # Hbb Tagging
    ########################################

    process.load("Configuration.StandardSequences.MagneticField_cff")
    process.load('Configuration.Geometry.GeometryRecoDB_cff')
    process.load("RecoBTag.Configuration.RecoBTag_cff"
                 )  # this loads all available b-taggers

    process.load(
        "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
    from Configuration.AlCa.GlobalTag import GlobalTag
    process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc')

    for fatjet_name in ["slimmedJetsAK8", "ca15PFJetsCHS"]:

        if skip_ca15 and (fatjet_name in ["ca15PFJetsCHS"]):
            continue

        if fatjet_name == "slimmedJetsAK8":
            delta_r = 0.8
            maxSVDeltaRToJet = 0.7
            weightFile = 'RecoBTag/SecondaryVertex/data/BoostedDoubleSV_AK8_BDT_v2.weights.xml.gz'
            jetAlgo = "AntiKt"
        elif fatjet_name == "ca15PFJetsCHS":
            delta_r = 1.5
            maxSVDeltaRToJet = 1.3
            weightFile = 'RecoBTag/SecondaryVertex/data/BoostedDoubleSV_CA15_BDT_v2.weights.xml.gz'
            jetAlgo = "CambridgeAachen"
        else:
            print "Invalid fatjet for b-tagging: ", fatjet_name
            sys.exit()

        # Define the module names
        impact_info_name = fatjet_name + "ImpactParameterTagInfos"
        isv_info_name = fatjet_name + "pfInclusiveSecondaryVertexFinderTagInfos"
        sm_info_name = fatjet_name + "softPFMuonsTagInfos"
        se_info_name = fatjet_name + "softPFElectronsTagInfos"
        bb_comp_name = fatjet_name + "candidateBoostedDoubleSecondaryVertexComputer"
        tag_name = fatjet_name + "pfBoostedDoubleSecondaryVertexBJetTags"

        # Setup the modules
        # IMPACT PARAMETER
        setattr(
            process, impact_info_name,
            process.pfImpactParameterTagInfos.clone(
                primaryVertex=cms.InputTag("offlineSlimmedPrimaryVertices"),
                candidates=cms.InputTag("packedPFCandidates"),
                computeProbabilities=cms.bool(False),
                computeGhostTrack=cms.bool(False),
                maxDeltaR=cms.double(delta_r),
                jets=cms.InputTag(fatjet_name),
            ))
        getattr(process, impact_info_name).explicitJTA = cms.bool(False)

        # ISV
        setattr(
            process, isv_info_name,
            process.pfInclusiveSecondaryVertexFinderTagInfos.clone(
                extSVCollection=cms.InputTag('slimmedSecondaryVertices'),
                trackIPTagInfos=cms.InputTag(impact_info_name),
            ))
        getattr(process, isv_info_name).useSVClustering = cms.bool(False)
        getattr(process, isv_info_name).rParam = cms.double(delta_r)
        getattr(process, isv_info_name).extSVDeltaRToJet = cms.double(delta_r)
        getattr(
            process,
            isv_info_name).trackSelection.jetDeltaRMax = cms.double(delta_r)
        getattr(
            process,
            isv_info_name).vertexCuts.maxDeltaRToJetAxis = cms.double(delta_r)
        getattr(process, isv_info_name).jetAlgorithm = cms.string(jetAlgo)

        # DOUBLE B COMPUTER
        setattr(
            process, bb_comp_name,
            cms.ESProducer(
                "CandidateBoostedDoubleSecondaryVertexESProducer",
                trackSelectionBlock,
                beta=cms.double(1.0),
                R0=cms.double(delta_r),
                maxSVDeltaRToJet=cms.double(maxSVDeltaRToJet),
                useCondDB=cms.bool(False),
                weightFile=cms.FileInPath(weightFile),
                useGBRForest=cms.bool(True),
                useAdaBoost=cms.bool(False),
                trackPairV0Filter=cms.PSet(k0sMassWindow=cms.double(0.03))))
        getattr(process,
                bb_comp_name).trackSelection.jetDeltaRMax = cms.double(delta_r)

        # TAGS
        setattr(
            process, tag_name,
            cms.EDProducer("JetTagProducer",
                           jetTagComputer=cms.string(bb_comp_name),
                           tagInfos=cms.VInputTag(
                               cms.InputTag(impact_info_name),
                               cms.InputTag(isv_info_name))))

        # SOFT MUON
        setattr(
            process, sm_info_name,
            softPFMuonsTagInfos.clone(
                jets=cms.InputTag(fatjet_name),
                muons=cms.InputTag("slimmedMuons"),
                primaryVertex=cms.InputTag("offlineSlimmedPrimaryVertices")))

        # SOFT ELECTRON
        setattr(
            process, se_info_name,
            softPFElectronsTagInfos.clone(
                jets=cms.InputTag(fatjet_name),
                electrons=cms.InputTag("slimmedElectrons"),
                primaryVertex=cms.InputTag("offlineSlimmedPrimaryVertices"),
                DeltaRElectronJet=cms.double(delta_r),
            ))

        # Produce the output
        for object_name in [
                impact_info_name, isv_info_name, sm_info_name, se_info_name,
                bb_comp_name, tag_name
        ]:

            process.OUT.outputCommands.append(
                "keep *_{0}_*_EX".format(object_name))

    ########################################
    # Subjet b-tagging
    ########################################

    for fatjet_name in [
            "ak08PFPrunedJetsCHS", "ca15PFPrunedJetsCHS", "looseOptRHTT"
    ]:

        if skip_ca15 and (fatjet_name
                          in ["ca15PFPrunedJetsCHS", "looseOptRHTT"]):
            continue

        if fatjet_name == "ak08PFPrunedJetsCHS":
            delta_r = 0.8
            jetAlgo = "AntiKt"
        elif fatjet_name == "ca15PFPrunedJetsCHS":
            delta_r = 1.5
            jetAlgo = "CambridgeAachen"
        elif fatjet_name == "looseOptRHTT":
            delta_r = 1.5
            jetAlgo = "CambridgeAachen"
        else:
            print "Invalid fatjet for subjet b-tagging: ", fatjet_name
            sys.exit()

        # Define the module names
        impact_info_name = fatjet_name + "ImpactParameterTagInfos"
        isv_info_name = fatjet_name + "pfInclusiveSecondaryVertexFinderTagInfos"
        csvv2_computer_name = fatjet_name + "combinedSecondaryVertexV2Computer"
        csvv2ivf_name = fatjet_name + "pfCombinedInclusiveSecondaryVertexV2BJetTags"

        # Setup the modules
        # IMPACT PARAMETER
        setattr(
            process, impact_info_name,
            process.pfImpactParameterTagInfos.clone(
                primaryVertex=cms.InputTag("offlineSlimmedPrimaryVertices"),
                candidates=cms.InputTag("packedPFCandidates"),
                computeProbabilities=cms.bool(False),
                computeGhostTrack=cms.bool(False),
                maxDeltaR=cms.double(delta_r),
                jets=cms.InputTag(fatjet_name, "SubJets"),
            ))
        getattr(process, impact_info_name).explicitJTA = cms.bool(True)

        # ISV
        setattr(
            process, isv_info_name,
            process.pfInclusiveSecondaryVertexFinderTagInfos.clone(
                extSVCollection=cms.InputTag('slimmedSecondaryVertices'),
                trackIPTagInfos=cms.InputTag(impact_info_name),
            ))
        getattr(process, isv_info_name).useSVClustering = cms.bool(True)
        getattr(process, isv_info_name).rParam = cms.double(delta_r)
        getattr(process, isv_info_name).extSVDeltaRToJet = cms.double(delta_r)
        getattr(
            process,
            isv_info_name).trackSelection.jetDeltaRMax = cms.double(delta_r)
        getattr(
            process,
            isv_info_name).vertexCuts.maxDeltaRToJetAxis = cms.double(delta_r)
        getattr(process, isv_info_name).jetAlgorithm = cms.string(jetAlgo)
        getattr(process, isv_info_name).fatJets = cms.InputTag(
            fatjet_name.replace("ak08PFPrunedJetsCHS",
                                "slimmedJetsAK8").replace(
                                    "looseOptRHTT", "ca15PFJetsCHS"))
        getattr(process,
                isv_info_name).groomedFatJets = cms.InputTag(fatjet_name)

        # CSV V2 COMPUTER
        setattr(process, csvv2_computer_name,
                process.candidateCombinedSecondaryVertexV2Computer.clone())

        # CSV IVF V2
        setattr(
            process, csvv2ivf_name,
            process.pfCombinedInclusiveSecondaryVertexV2BJetTags.clone(
                tagInfos=cms.VInputTag(cms.InputTag(impact_info_name),
                                       cms.InputTag(isv_info_name)),
                jetTagComputer=cms.string(csvv2_computer_name, )))

        # Produce the output
        process.OUT.outputCommands.append(
            "keep *_{0}_*_EX".format(csvv2ivf_name))

    ###
    ### GenHFHadronMatcher
    ###
    if isMC:
        process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

        genParticleCollection = 'prunedGenParticles'

        genJetCollection = "slimmedGenJets"

        genJetInputParticleCollection = 'packedGenParticles'

        from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
        process.ak8GenJetsCustom = ak4GenJets.clone(
            src=genJetInputParticleCollection,
            rParam=cms.double(0.8),
            jetAlgorithm=cms.string("AntiKt"))
        #        genJetAK08Collection = "ak8GenJetsCustom"

        # Ghost particle collection used for Hadron-Jet association
        # MUST use proper input particle collection
        from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
        process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
            particles=genParticleCollection)

        # Input particle collection for matching to gen jets (partons + leptons)
        # MUST use use proper input jet collection: the jets to which hadrons should be associated
        # rParam and jetAlgorithm MUST match those used for jets to be associated with hadrons
        # More details on the tool: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition
        from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import genJetFlavourPlusLeptonInfos
        process.genJetFlavourPlusLeptonInfos = genJetFlavourPlusLeptonInfos.clone(
            jets=genJetCollection,
            rParam=cms.double(0.4),
            jetAlgorithm=cms.string("AntiKt"))

        # Plugin for analysing B hadrons
        # MUST use the same particle collection as in selectedHadronsAndPartons
        from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import matchGenBHadron
        process.matchGenBHadron = matchGenBHadron.clone(
            genParticles=genParticleCollection)

        # Plugin for analysing C hadrons
        # MUST use the same particle collection as in selectedHadronsAndPartons
        from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import matchGenCHadron
        process.matchGenCHadron = matchGenCHadron.clone(
            genParticles=genParticleCollection)
        process.OUT.outputCommands.append("keep *_matchGenBHadron__EX")
        process.OUT.outputCommands.append("keep *_matchGenCHadron__EX")
        process.OUT.outputCommands.append("keep *_matchGenBHadron_*_EX")
        process.OUT.outputCommands.append("keep *_matchGenCHadron_*_EX")
        process.OUT.outputCommands.append("keep *_ak8GenJetsCustom_*_EX")

    #Schedule to run soft muon and electron taggers on miniAOD
    process.softPFElectronsTagInfos.jets = cms.InputTag("slimmedJets")
    process.softPFElectronsTagInfos.electrons = cms.InputTag(
        "slimmedElectrons")
    process.softPFElectronsTagInfos.primaryVertex = cms.InputTag(
        "offlineSlimmedPrimaryVertices")

    process.softPFMuonsTagInfos.jets = cms.InputTag("slimmedJets")
    process.softPFMuonsTagInfos.muons = cms.InputTag("slimmedMuons")
    process.softPFMuonsTagInfos.primaryVertex = cms.InputTag(
        "offlineSlimmedPrimaryVertices")

    process.OUT.outputCommands.append("keep *_softPFElectronsTagInfos_*_*")
    process.OUT.outputCommands.append("keep *_softPFMuonsTagInfos_*_*")
    process.OUT.outputCommands.append("keep *_softPFElectronBJetTags_*_EX")
    process.OUT.outputCommands.append("keep *_softPFMuonBJetTags_*_EX")

    ########################################
    # Generator level hadronic tau decays
    ########################################
    if isMC:
        process.load("PhysicsTools.JetMCAlgos.TauGenJets_cfi")
        process.tauGenJets.GenParticles = cms.InputTag('prunedGenParticles')
        process.load(
            "PhysicsTools.JetMCAlgos.TauGenJetsDecayModeSelectorAllHadrons_cfi"
        )
        process.OUT.outputCommands.append(
            "keep *_tauGenJetsSelectorAllHadrons_*_EX")

    return process
コード例 #13
0
def load_PUPPIJet_sequence(proc, seq_name, rParam):

	puppi_seq = cms.Sequence()
	for r in rParam:
		if r==0.4:
			ak4GenJets.src = 'packedGenParticles'
			setattr(proc,"ak4GenJets",ak4GenJets)
			# Select candidates that would pass CHS requirements
			#AK4PFchs = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))
			#setattr(proc,"ak4PFchsJets",AK4PFchs)
			#AK4PUPPI = ak4PFJets.clone(src = 'packedPFCandidates')
			ak4PUPPI = ak4PFJets.clone(src = 'particleFlowPUPPI')
			setattr(proc,"ak4PUPPI",ak4PUPPI)
			puppi_seq = cms.Sequence(puppi_seq*ak4GenJets*ak4PUPPI)
			addJetCollection(
				proc,
				labelName = 'AK4PUPPIJets',
				jetSource = cms.InputTag('ak4PUPPI'),
				algo = 'ak4',
				rParam = 0.4,
				jetCorrections = None,
				trackSource = cms.InputTag('unpackedTracksAndVertices'),
				pvSource = cms.InputTag('unpackedTracksAndVertices'),
				#btagDiscriminators = ['combinedSecondaryVertexBJetTags'],
			)
			for module in [proc.patJetsAK4PUPPIJets]:
				module.addJetCharge = False
				module.addBTagInfo = False
				module.getJetMCFlavour = False
				module.addAssociatedTracks = False
			for module in [proc.patJetPartonMatchAK4PUPPIJets]:
				module.matched='prunedGenParticles'

		elif r==0.8:
			ak8GenJets = ak4GenJets.clone(rParam=0.8)
			ak8GenJets.src = 'packedGenParticles'
			setattr(proc,"ak8GenJets",ak8GenJets)
			# Select candidates that would pass CHS requirements
			#AK8PFchs = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))
			#setattr(proc,"ak8PFchsJets",AK8PFchs)
			#AK8PUPPI = ak4PFJets.clone(src = 'packedPFCandidates', rParam = 0.8)
			ak8PUPPI = ak4PFJets.clone(src = 'particleFlowPUPPI', rParam = 0.8)
			setattr(proc,"ak8PUPPI",ak8PUPPI)
			puppi_seq = cms.Sequence(puppi_seq*ak8GenJets*ak8PUPPI)
			addJetCollection(
				proc,
				labelName = 'AK8PUPPIJets',
				jetSource = cms.InputTag('ak8PUPPI'),
				algo = 'ak8',
				rParam = 0.8,
				jetCorrections = None,
				trackSource = cms.InputTag('unpackedTracksAndVertices'),
				pvSource = cms.InputTag('unpackedTracksAndVertices'),
				#btagDiscriminators = ['combinedSecondaryVertexBJetTags'],
			)
			for module in [proc.patJetsAK8PUPPIJets]:
				module.addJetCharge = False
				module.addBTagInfo = False
				module.getJetMCFlavour = False
				module.addAssociatedTracks = False
			for module in [proc.patJetPartonMatchAK8PUPPIJets]:
				module.matched='prunedGenParticles'

	setattr(proc, seq_name, puppi_seq)
コード例 #14
0
                       ignoreParticleIDs=cms.vuint32(1000022, 1000012, 1000014,
                                                     1000016, 2000012, 2000014,
                                                     2000016, 1000039, 5100039,
                                                     4000012, 4000014, 4000016,
                                                     9900012, 9900014, 9900016,
                                                     39, 12, 14, 16),
                       partonicFinalState=cms.bool(False),
                       excludeResonances=cms.bool(False),
                       excludeFromResonancePids=cms.vuint32(12, 13, 14, 16),
                       tausAsJets=cms.bool(False)))

    genJetInputParticleCollection = 'myGenParticlesForJets'

    from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
    process.ak4GenJetsReproduced = ak4GenJets.clone(
        src=genJetInputParticleCollection,
        rParam=cms.double(0.4),
        jetAlgorithm=cms.string("AntiKt"))

    process.GenParticleWithoutChargedLeptonFromTop = cms.EDProducer(
        'GenParticleTopOriginChargedleptonFilter',
        PackedGenParticle=cms.InputTag("packedGenParticles"),
        PrunedGenParticle=cms.InputTag("prunedGenParticles"))

    process.myGenParticlesWithChargedLeptonFromTopForJet = process.myGenParticlesForJets.clone(
        src=cms.InputTag("GenParticleWithoutChargedLeptonFromTop",
                         "TopOriginChargedleptonFilteredGenParticle", ""))
    process.ak4GenJetsWithChargedLepFromTop = ak4GenJets.clone(
        src=cms.InputTag('myGenParticlesWithChargedLeptonFromTopForJet'),
        rParam=cms.double(0.4),
        jetAlgorithm=cms.string("AntiKt"))
コード例 #15
0
# Setting input particle collections to be used by the tools
genJetCollection = 'ak4GenJetsCustom'
genParticleCollection = 'prunedGenParticles'
genJetInputParticleCollection = 'packedGenParticles'

## producing a subset of particles to be used for jet clustering
from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu
genParticlesForJetsNoNu = genParticlesForJetsNoNu.clone(
    src = genJetInputParticleCollection
)

# Producing own jets for testing purposes
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
ak4GenJetsCustom = ak4GenJets.clone(
    src = 'genParticlesForJetsNoNu',
    rParam = cms.double(0.4),
    jetAlgorithm = cms.string("AntiKt"),
#    jetPtMin = 20.
)

# Ghost particle collection used for Hadron-Jet association 
# MUST use proper input particle collection
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
    particles = genParticleCollection
)

# Input particle collection for matching to gen jets (partons + leptons) 
# MUST use use proper input jet collection: the jets to which hadrons should be associated
# rParam and jetAlgorithm MUST match those used for jets to be associated with hadrons
# More details on the tool: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition
from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import genJetFlavourPlusLeptonInfos
コード例 #16
0
    jetCollInstanceName = cms.string("SubJets")
)

akSoftDrop4HIGenJets = cms.EDProducer(
    "SoftDropJetProducer",
    GenJetParameters,
    AnomalousCellParameters,
    jetAlgorithm        = cms.string("AntiKt"),
    rParam              = cms.double(0.4),
    zcut                = cms.double(0.1),
    beta                = cms.double(0.0),
    R0                  = cms.double(0.4),
    useOnlyCharged      = cms.bool(False),
    useExplicitGhosts   = cms.bool(True),
    writeCompound       = cms.bool(True),
    jetCollInstanceName = cms.string("SubJets")
)

akSoftDropZ05B154GenJets = akSoftDrop4GenJets.clone(
    zcut = cms.double(0.5), beta = cms.double(1.5))

akSoftDropZ05B154HIGenJets = akSoftDrop4HIGenJets.clone(
    zcut = cms.double(0.5), beta = cms.double(1.5))

# cloning jets for other radii
ak1GenJets = ak4GenJets.clone(rParam = 0.1)
ak2GenJets = ak4GenJets.clone(rParam = 0.2)
ak3GenJets = ak4GenJets.clone(rParam = 0.3)
ak5GenJets = ak4GenJets.clone(rParam = 0.5)
ak6GenJets = ak4GenJets.clone(rParam = 0.6)
コード例 #17
0
genParticlesMerged = cms.EDProducer(
    "MergedGenParticleProducer",
    inputPruned=cms.InputTag("prunedGenParticles"),
    inputPacked=cms.InputTag("packedGenParticles"))

#select only stable particles (status=1) for reclustering GenJets for the matching; exclude neutrinos
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
genParticlesForGenJets = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("genParticlesMerged"),
    cut=cms.string(
        "status==1 && abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16 && abs(pdgId) < 1000000"
    ))

#recluster GenJets
genJetsReclustered = ak4GenJets.clone(
    src=cms.InputTag('genParticlesForGenJets'))
'''
genXJetsReclustered = cms.EDProducer(
    'XJetProducer',
    src = cms.InputTag('genParticlesForGenJets'),
    genJets = cms.InputTag("genJetsReclustered")
)
'''

#TFileService = cms.Service("TFileService", fileName = cms.string("histoZ.root") )

#produce DisplacedGenVertices and match to GenJets
displacedGenVertices = cms.EDProducer(
    "DisplacedGenVertexProducer",
    srcGenParticles=cms.InputTag("genParticlesMerged"),
    srcGenJets=cms.InputTag("genJetsReclustered"))
コード例 #18
0
  process.pfClusterRefsForJets_step += process.ak4PFCaloJets


# ----------------------- Jet Tool Box  -----------------
# ----- giulia test: do not recluster ak4 and ca8 jets to save time --------


# ##Load the toolBoxMiniHelper
# #from RecoJets.JetProducers.jettoolboxMiniHelper_cff import * 
# ##for some reason doesn't work  ?__?
# ## just copy&paste the cff here

process.chs = cms.EDFilter('CandPtrSelector', src = cms.InputTag('packedPFCandidates'), cut = cms.string('fromPV'))

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.slimmedGenJetsAK8 = ak4GenJets.clone(src = 'packedGenParticles', rParam = 0.8)

# process.ak4PFJets.src = 'packedPFCandidates'
# process.ak4PFJets.doAreaFastjet = True

# process.ak4PFJetsCHS = process.ak4PFJetsCHS.clone(src = 'chs', doAreaFastjet = True) #boh ?
# process.ak8PFJetsCHS = process.ak4PFJetsCHS.clone(src = 'chs', doAreaFastjet = True, rParam = 0.8)
# process.ca8PFJetsCHS = process.ca4PFJets.clone(src = 'chs', doAreaFastjet = True, rParam = 0.8)

# process.ak4GenJets.src = 'packedGenParticles'
# process.ak8GenJets = process.ak4GenJets.clone(src = 'packedGenParticles', rParam = 0.8)
# process.ca8GenJets = process.ca4GenJets.clone(src = 'packedGenParticles', rParam = 0.8)

# process.fixedGridRhoFastjetAll.pfCandidatesTag = 'packedPFCandidates'

# process.ak4PFJetsCHSPruned = ak5PFJetsCHSPruned.clone(
コード例 #19
0
## Set input particle collections to be used by the tools
genParticleCollection = ''
genJetCollection = ''
if options.runOnAOD:
    genParticleCollection = 'genParticles'
    genJetCollection = 'ak4GenJetsCustom'
    ## producing a subset of genParticles to be used for jet clustering in AOD
    from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu
    process.genParticlesForJetsCustom = genParticlesForJetsNoNu.clone()
    process.task.add(process.genParticlesForJetsCustom)
    ## Produce own jets (re-clustering in miniAOD needed at present to avoid crash)
    from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
    process.ak4GenJetsCustom = ak4GenJets.clone(
        src = 'genParticlesForJetsCustom',
        rParam = cms.double(0.4),
        jetAlgorithm = cms.string("AntiKt")
    )
    process.task.add(process.ak4GenJetsCustom)
else:
    genParticleCollection = 'prunedGenParticles'
    genJetCollection = 'slimmedGenJets'

## Supplies PDG ID to real name resolution of MC particles
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")


## Ghost particle collection used for Hadron-Jet association 
# MUST use proper input particle collection
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
コード例 #20
0
ファイル: b2gedmntuples_cfg.py プロジェクト: dittmer/B2GAnaFW
#################################################
## After 7.4.0, only need to make AK8 gen jets.
## The rest are stored by default in MiniAOD directly. 
#################################################

## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", 
    src = cms.InputTag("packedGenParticles"), 
    cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
    )
## Fat GenJets
if "MC" in options.DataProcessing: 
    from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
    process.ak8GenJetsNoNu = ak4GenJets.clone(
        rParam = cms.double(0.8),
        src = cms.InputTag("packedGenParticlesForJetsNoNu")
    )

    ## SoftDrop fat GenJets (two jet collections are produced, fat jets and subjets)
    from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
    from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
    process.ak8GenJetsNoNuSoftDrop = ak4GenJets.clone(
        rParam = cms.double(0.8),
        src = cms.InputTag("packedGenParticlesForJetsNoNu"),
        useSoftDrop = cms.bool(True),
        zcut = cms.double(0.1),
        beta = cms.double(0.0),
        R0   = cms.double(0.8),
        useExplicitGhosts = cms.bool(True),
        writeCompound = cms.bool(True),
        jetCollInstanceName=cms.string("SubJets")    
コード例 #21
0
genParticleCollection = 'prunedGenParticles'
genJetInputParticleCollection = 'packedGenParticles'
    
## producing a subset of particles to be used for jet clustering
from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu
process.genParticlesForJetsNoNu = genParticlesForJetsNoNu.clone(
	src = cms.InputTag(genJetInputParticleCollection)
)
seq += process.genParticlesForJetsNoNu

    
# Producing own jets for testing purposes
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsCustom = ak4GenJets.clone(
        src = cms.InputTag("genParticlesForJetsNoNu"),
        #    src = genJetInputParticleCollection,
		jetAlgorithm = cms.string("AntiKt"),
        rParam = cms.double(0.4)
)
seq += process.ak4GenJetsCustom

    
# Ghost particle collection used for Hadron-Jet association 
# MUST use proper input particle collection
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
        particles = cms.InputTag(genParticleCollection)
)
seq += process.selectedHadronsAndPartons

from PhysicsTools.JetMCAlgos.AK4PFJetsMCFlavourInfos_cfi import ak4JetFlavourInfos
process.genJetFlavourInfos = ak4JetFlavourInfos.clone(
コード例 #22
0

###
### AK8 jets with subjet b-tagging
###

#################################################
## Make jets
#################################################

## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedGenParticles"), cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
## Fat GenJets
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak8GenJetsNoNu = ak4GenJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("packedGenParticlesForJetsNoNu")
)

## Pruned fat GenJets (two jet collections are produced, fat jets and subjets)
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak8GenJetsNoNuPruned = ak4GenJets.clone(
    SubJetParameters,
    rParam = cms.double(0.8),
    src = cms.InputTag("packedGenParticlesForJetsNoNu"),
    usePruning = cms.bool(True),
    writeCompound = cms.bool(True),
    jetCollInstanceName=cms.string("SubJets")
)

## Select charged hadron subtracted packed PF candidates
コード例 #23
0
ファイル: ak8GenJets_cfi.py プロジェクト: dimattia/cmssw
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

ak8GenJets = ak4GenJets.clone(
    rParam       = cms.double(0.8)
    )

ak8GenJetsSoftDrop = ak8GenJets.clone(
    useSoftDrop = cms.bool(True),
    zcut = cms.double(0.1),
    beta = cms.double(0.0),
    R0   = cms.double(0.8),
    useExplicitGhosts = cms.bool(True),
    writeCompound = cms.bool(True),
    jetCollInstanceName=cms.string("SubJets"),
    jetPtMin = 100.0
    )
コード例 #24
0
#  reverseDecision = cms.bool(False)
#)
#####
##   For tt+X
#####
# Setting input particle collections to be used by the tools
genJetCollection              = 'ak4GenJetsCustom'
genParticleCollection         = 'prunedGenParticles'
genJetInputParticleCollection = 'packedGenParticles'
# Supplies PDG ID to real name resolution of MC particles
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
# Producing own jets for testing purposes
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsCustom = ak4GenJets.clone(
  src = genJetInputParticleCollection,
  rParam = cms.double(0.4),
  jetAlgorithm = cms.string("AntiKt")
)
# Ghost particle collection used for Hadron-Jet association 
# MUST use proper input particle collection
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
  particles = genParticleCollection
)
# Input particle collection for matching to gen jets (partons + leptons) 
# MUST use use proper input jet collection: the jets to which hadrons should be associated
# rParam and jetAlgorithm MUST match those used for jets to be associated with hadrons
# More details on the tool: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition
from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import genJetFlavourPlusLeptonInfos
process.genJetFlavourPlusLeptonInfos = genJetFlavourPlusLeptonInfos.clone(
  jets = genJetCollection,
コード例 #25
0
#merge GenParticles for easy matching of GenJets to vertices
genParticlesMerged = cms.EDProducer(
    "MergedGenParticleProducer",
    inputPruned=cms.InputTag("prunedGenParticles"),
    inputPacked=cms.InputTag("packedGenParticles"))

#select only stable particles (status=1) for reclustering GenJets for the matching; exclude neutrinos
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

genParticlesForGenJets = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("genParticlesMerged"),
    cut=cms.string(
        "status==1 && abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"
    ))

#recluster GenJets
genJetsReclustered = ak4GenJets.clone(src='genParticlesForGenJets')

#produce DisplacedGenVertices and match to GenJets
displacedGenVertices = cms.EDProducer(
    "DisplacedGenVertexProducer",
    srcGenParticles=cms.InputTag("genParticlesMerged"),
    srcGenJets=cms.InputTag("genJetsReclustered"))

DisplacedGenVertexSequence = cms.Sequence(genParticlesMerged +
                                          genParticlesForGenJets +
                                          genJetsReclustered +
                                          displacedGenVertices)
コード例 #26
0
                                     veto=cms.InputTag("selectedMuons"))
process.pfNoElectronsCHS = cms.EDProducer(
    "CandPtrProjector",
    src=cms.InputTag("pfNoMuonCHS"),
    veto=cms.InputTag("selectedElectrons"))

#Import RECO jet producer for ak4 PF and GEN jet
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4PFJetsCHS = ak4PFJets.clone(src='pfNoElectronsCHS',
                                       doAreaFastjet=True)
process.packedGenParticlesForJetsNoNu = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("packedGenParticles"),
    cut=cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
process.ak4GenJetsNoNu = ak4GenJets.clone(src='packedGenParticlesForJetsNoNu')

# The following is make patJets, but EI is done with the above
process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("Configuration.Geometry.GeometryRecoDB_cff")
process.load(
    "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc')

bTagDiscriminators = ['pfCombinedInclusiveSecondaryVertexV2BJetTags']

from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
addJetCollection(process,
                 labelName='AK4PFCHS',
                 jetSource=cms.InputTag('ak4PFJetsCHS'),
コード例 #27
0
def initialize(isMC=True):

    process = cms.Process("EX")
    process.source = cms.Source("PoolSource",
        #fileNames = cms.untracked.vstring('root://xrootd.unl.edu//store/mc/RunIISpring15MiniAODv2/WprimeToWhToWlephbb_narrow_M-1200_13TeV-madgraph/MINIAODSIM/Asympt50ns_74X_mcRun2_asymptotic50ns_v0-v1/30000/6248D38C-8D76-E511-B243-20CF305B058C.root')
#fileNames = cms.untracked.vstring('root://xrootd.unl.edu//store/mc/RunIISpring15MiniAODv2/WprimeToWhToWlephbb_narrow_M-4000_13TeV-madgraph/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/60000/E4EB03F2-4170-E511-B5C4-00259073E466.root')
fileNames = cms.untracked.vstring('root://xrootd.unl.edu//store/mc/RunIISpring15MiniAODv2/WprimeToMuNu_M-3000_TuneCUETP8M1_13TeV-pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/60000/10EFFE5D-4374-E511-905E-003048F0113E.root')
    )
    process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) )
#    process.met = cms.EDFilter("PtMinCandViewSelector",
#                               src = cms.InputTag("slimmedMETs"),
#                               ptMin   = cms.double(150),
#                       )
 
#    process.metFilter = cms.EDFilter("CandViewCountFilter",
#                                    src = cms.InputTag("met"),
#                                     minNumber = cms.uint32(1),
#                                     filter = cms.bool(True)
#                                     ) 
    
#    process.metPath = cms.Path(    
#        process.met
#        *process.metFilter
#        )

#    process.EventSelection = cms.PSet(
#        SelectEvents = cms.untracked.PSet(
#            SelectEvents = cms.vstring(
#                'metPath')
#            )
#        )
    

    process.OUT = cms.OutputModule("PoolOutputModule",
 #                                  process.EventSelection, 
                                   fileName = cms.untracked.string('test.root'),
                                   outputCommands = cms.untracked.vstring(['drop *'])
                                   )
    process.endpath= cms.EndPath(process.OUT)


    # Let CMSSW take care of scheduling 
    process.options = cms.untracked.PSet(     
        wantSummary = cms.untracked.bool(True),
        allowUnscheduled = cms.untracked.bool(True)
        )

    skip_ca15 = False

    ########################################
    # Boosted Substructure
    ########################################


    # Select candidates that would pass CHS requirements
    process.chs = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))

    # Apply pruning to AK R=0.8 jets
    process.ak08PFPrunedJetsCHS = cms.EDProducer(
        "FastjetJetProducer",
        PFJetParameters,
        AnomalousCellParameters,
        jetAlgorithm = cms.string("AntiKt"),
        rParam       = cms.double(0.8),
        usePruning = cms.bool(True),
        nFilt = cms.int32(2),
        zcut = cms.double(0.1),
        rcut_factor = cms.double(0.5),
        useExplicitGhosts = cms.bool(True),
        writeCompound = cms.bool(True), # Also write subjets for pruned fj
        jetCollInstanceName=cms.string("SubJets")
    )
    process.ak08PFPrunedJetsCHS.src = cms.InputTag("chs")
    process.ak08PFPrunedJetsCHS.jetPtMin = cms.double(200.)

    if isMC:
        process.OUT.outputCommands.append("keep *_slimmedJetsAK8_*_PAT")
    else:
        process.OUT.outputCommands.append("keep *_slimmedJetsAK8_*_RECO")

    process.OUT.outputCommands.append("keep *_ak08PFPrunedJetsCHS_*_EX")


    if not skip_ca15:
        # CA, R=1.5, pT > 200 GeV
        process.ca15PFJetsCHS = cms.EDProducer(
                "FastjetJetProducer",
                PFJetParameters,
                AnomalousCellParameters,
                jetAlgorithm = cms.string("CambridgeAachen"),
                rParam       = cms.double(1.5))
        process.ca15PFJetsCHS.src = cms.InputTag("chs")
        process.ca15PFJetsCHS.jetPtMin = cms.double(200.)

        # Calculate tau1, tau2 and tau3 for ungroomed CA R=1.5 jets
        process.ca15PFJetsCHSNSubjettiness  = cms.EDProducer("NjettinessAdder",
                                                             src=cms.InputTag("ca15PFJetsCHS"),
                                                             cone=cms.double(1.5),
                                                             Njets = cms.vuint32(1,2,3),
                                                             # variables for measure definition : 
                                                             measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
                                                             beta = cms.double(1.0),              # CMS default is 1
                                                             R0 = cms.double(1.5),                # CMS default is jet cone size
                                                             Rcutoff = cms.double( -999.0),       # not used by default
                                                             # variables for axes definition :
                                                             axesDefinition = cms.uint32( 6 ),    # CMS default is 1-pass KT axes
                                                             nPass = cms.int32(-999),             # not used by default
                                                             akAxesR0 = cms.double(-999.0)        # not used by default
        )

        # Apply pruning to CA R=1.5 jets
        process.ca15PFPrunedJetsCHS = process.ca15PFJetsCHS.clone(
            usePruning = cms.bool(True),
            nFilt = cms.int32(2),
            zcut = cms.double(0.1),
            rcut_factor = cms.double(0.5),
            useExplicitGhosts = cms.bool(True),
            writeCompound = cms.bool(True), # Also write subjets for pruned fj
            jetCollInstanceName=cms.string("SubJets"),
        )

        # Apply softdrop to CA R=1.5 jets
        process.ca15PFSoftdropJetsCHS = process.ca15PFJetsCHS.clone(
            useSoftDrop = cms.bool(True),
            zcut = cms.double(0.1),
            beta = cms.double(0.0),
            R0 = cms.double(1.5),
            useExplicitGhosts = cms.bool(True))

        # Apply softdrop z=0.2, beta=1 to CA R=1.5 jets
        process.ca15PFSoftdropZ2B1JetsCHS = process.ca15PFJetsCHS.clone(
            useSoftDrop = cms.bool(True),
            zcut = cms.double(0.2),
            beta = cms.double(1.),
            R0 = cms.double(1.5),
            useExplicitGhosts = cms.bool(True))

        # Apply trimming to CA R=1.5 jets
        process.ca15PFTrimmedJetsCHS = process.ca15PFJetsCHS.clone(
            useTrimming = cms.bool(True),
            rFilt = cms.double(0.2),
            trimPtFracMin = cms.double(0.06),
            useExplicitGhosts = cms.bool(True))

        # Calculate tau1, tau2 and tau3 for softdrop (z=0.2, beta=1) CA R=1.5 jets
        process.ca15PFSoftdropZ2B1JetsCHSNSubjettiness  = cms.EDProducer("NjettinessAdder",
                                                                         src=cms.InputTag("ca15PFSoftdropZ2B1JetsCHS"),
                                                                         cone=cms.double(1.5),
                                                                         Njets = cms.vuint32(1,2,3),
                                                                         # variables for measure definition : 
                                                                         measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
                                                                         beta = cms.double(1.0),              # CMS default is 1
                                                                         R0 = cms.double(1.5),                # CMS default is jet cone size
                                                                         Rcutoff = cms.double( -999.0),       # not used by default
                                                                         # variables for axes definition :
                                                                         axesDefinition = cms.uint32( 6 ),    # CMS default is 1-pass KT axes
                                                                         nPass = cms.int32(-999),             # not used by default
                                                                         akAxesR0 = cms.double(-999.0)        # not used by default
        )


        # HEPTopTagger (MultiR)
        process.looseOptRHTT = cms.EDProducer(
            "HTTTopJetProducer",
            PFJetParameters,
            AnomalousCellParameters,
            jetCollInstanceName=cms.string("SubJets"),
            useExplicitGhosts = cms.bool(True),
            writeCompound  = cms.bool(True), 
            optimalR       = cms.bool(True),
            algorithm      = cms.int32(1),
            jetAlgorithm   = cms.string("CambridgeAachen"),
            rParam         = cms.double(1.5),
            mode           = cms.int32(4),
            minFatjetPt    = cms.double(200.),
            minCandPt      = cms.double(200.),
            minSubjetPt    = cms.double(30.),
            minCandMass    = cms.double(0.),
            maxCandMass    = cms.double(1000),
            massRatioWidth = cms.double(100.),
            minM23Cut      = cms.double(0.),
            minM13Cut      = cms.double(0.),
            maxM13Cut      = cms.double(2.))
        process.looseOptRHTT.src = cms.InputTag("chs")
        process.looseOptRHTT.jetPtMin = cms.double(200.)

        process.OUT.outputCommands.append("keep *_ca15PFJetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFPrunedJetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFSoftdropJetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFSoftdropZ2B1JetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFTrimmedJetsCHS_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFJetsCHSNSubjettiness_*_EX")
        process.OUT.outputCommands.append("keep *_ca15PFSoftdropZ2B1JetsCHSNSubjettiness_*_EX")
        process.OUT.outputCommands.append("keep *_looseOptRHTT_*_EX")




    ########################################
    # Hbb Tagging
    ########################################

    process.load("Configuration.StandardSequences.MagneticField_cff")
    process.load('Configuration.Geometry.GeometryRecoDB_cff')
    process.load("RecoBTag.Configuration.RecoBTag_cff") # this loads all available b-taggers

    process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
    from Configuration.AlCa.GlobalTag import GlobalTag
    process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc')

    for fatjet_name in ["slimmedJetsAK8", "ca15PFJetsCHS"]:

        if skip_ca15 and (fatjet_name in ["ca15PFJetsCHS"]):
            continue


        if fatjet_name == "slimmedJetsAK8":        
            delta_r = 0.8
            maxSVDeltaRToJet = 0.7
            weightFile = 'RecoBTag/SecondaryVertex/data/BoostedDoubleSV_AK8_BDT_v2.weights.xml.gz'
            jetAlgo = "AntiKt"
        elif fatjet_name == "ca15PFJetsCHS":        
            delta_r = 1.5
            maxSVDeltaRToJet = 1.3
            weightFile = 'RecoBTag/SecondaryVertex/data/BoostedDoubleSV_CA15_BDT_v2.weights.xml.gz'
            jetAlgo = "CambridgeAachen"
        else:
            print "Invalid fatjet for b-tagging: ", fatjet_name
            sys.exit()

        # Define the module names
        impact_info_name          = fatjet_name + "ImpactParameterTagInfos"
        isv_info_name             = fatjet_name + "pfInclusiveSecondaryVertexFinderTagInfos"        
        sm_info_name              = fatjet_name + "softPFMuonsTagInfos"
        se_info_name              = fatjet_name + "softPFElectronsTagInfos"
        bb_comp_name              = fatjet_name + "candidateBoostedDoubleSecondaryVertexComputer"
        tag_name                  = fatjet_name + "pfBoostedDoubleSecondaryVertexBJetTags"

        # Setup the modules
        # IMPACT PARAMETER
        setattr(process, 
                impact_info_name, 
                process.pfImpactParameterTagInfos.clone(
                    primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices"),
                    candidates = cms.InputTag("packedPFCandidates"),
                    computeProbabilities = cms.bool(False),
                    computeGhostTrack = cms.bool(False),
                    maxDeltaR = cms.double(delta_r),
                    jets = cms.InputTag(fatjet_name),
                ))
        getattr(process, impact_info_name).explicitJTA = cms.bool(False)

        # ISV
        setattr(process,
                isv_info_name,                
                process.pfInclusiveSecondaryVertexFinderTagInfos.clone(
                   extSVCollection               = cms.InputTag('slimmedSecondaryVertices'),
                   trackIPTagInfos               = cms.InputTag(impact_info_name),                
                ))
        getattr(process, isv_info_name).useSVClustering = cms.bool(False)
        getattr(process, isv_info_name).rParam = cms.double(delta_r)
        getattr(process, isv_info_name).extSVDeltaRToJet = cms.double(delta_r)
        getattr(process, isv_info_name).trackSelection.jetDeltaRMax = cms.double(delta_r)
        getattr(process, isv_info_name).vertexCuts.maxDeltaRToJetAxis = cms.double(delta_r)
        getattr(process, isv_info_name).jetAlgorithm = cms.string(jetAlgo)

        # DOUBLE B COMPUTER
        setattr(process,
                bb_comp_name,                
                cms.ESProducer("CandidateBoostedDoubleSecondaryVertexESProducer",
                               trackSelectionBlock,
                               beta = cms.double(1.0),
                               R0 = cms.double(delta_r),
                               maxSVDeltaRToJet = cms.double(maxSVDeltaRToJet),
                               useCondDB = cms.bool(False),
                               weightFile = cms.FileInPath(weightFile),
                               useGBRForest = cms.bool(True),
                               useAdaBoost = cms.bool(False),
                               trackPairV0Filter = cms.PSet(k0sMassWindow = cms.double(0.03))
                           ))
        getattr(process, bb_comp_name).trackSelection.jetDeltaRMax = cms.double(delta_r)

        # TAGS
        setattr(process,
                tag_name, 
                cms.EDProducer("JetTagProducer",
                               jetTagComputer = cms.string(bb_comp_name),
                               tagInfos = cms.VInputTag(cms.InputTag(impact_info_name),
                                                        cms.InputTag(isv_info_name)
                                                    )))


        # SOFT MUON
        setattr(process,
                sm_info_name,
                softPFMuonsTagInfos.clone(
                    jets = cms.InputTag(fatjet_name),
                    muons = cms.InputTag("slimmedMuons"),
                    primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices")             
                ))

        # SOFT ELECTRON
        setattr(process,
                se_info_name,
                softPFElectronsTagInfos.clone(
                    jets = cms.InputTag(fatjet_name),
                    electrons = cms.InputTag("slimmedElectrons"),
                    primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices"),                
                    DeltaRElectronJet=cms.double(delta_r),
                ))



        # Produce the output
        for object_name in [impact_info_name, isv_info_name,
                            sm_info_name, se_info_name,          
                            bb_comp_name, tag_name]:

            process.OUT.outputCommands.append("keep *_{0}_*_EX".format(object_name))


    ########################################
    # Subjet b-tagging
    ########################################


    for fatjet_name in ["ak08PFPrunedJetsCHS", "ca15PFPrunedJetsCHS", "looseOptRHTT"]:

        if skip_ca15 and (fatjet_name in ["ca15PFPrunedJetsCHS", "looseOptRHTT"]):
            continue

        if fatjet_name == "ak08PFPrunedJetsCHS":        
            delta_r = 0.8
            jetAlgo = "AntiKt"
        elif fatjet_name == "ca15PFPrunedJetsCHS":        
            delta_r = 1.5
            jetAlgo = "CambridgeAachen"
        elif fatjet_name == "looseOptRHTT":
            delta_r = 1.5
            jetAlgo = "CambridgeAachen"
        else:
            print "Invalid fatjet for subjet b-tagging: ", fatjet_name
            sys.exit()

        # Define the module names
        impact_info_name          = fatjet_name + "ImpactParameterTagInfos"
        isv_info_name             = fatjet_name + "pfInclusiveSecondaryVertexFinderTagInfos"        
        csvv2_computer_name       = fatjet_name + "combinedSecondaryVertexV2Computer"
        csvv2ivf_name             = fatjet_name + "pfCombinedInclusiveSecondaryVertexV2BJetTags"        

        # Setup the modules
        # IMPACT PARAMETER
        setattr(process, 
                impact_info_name, 
                process.pfImpactParameterTagInfos.clone(
                    primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices"),
                    candidates = cms.InputTag("packedPFCandidates"),
                    computeProbabilities = cms.bool(False),
                    computeGhostTrack = cms.bool(False),
                    maxDeltaR = cms.double(delta_r),
                    jets = cms.InputTag(fatjet_name, "SubJets"),
                ))
        getattr(process, impact_info_name).explicitJTA = cms.bool(True)

        # ISV
        setattr(process,
                isv_info_name,                
                process.pfInclusiveSecondaryVertexFinderTagInfos.clone(
                   extSVCollection               = cms.InputTag('slimmedSecondaryVertices'),
                   trackIPTagInfos               = cms.InputTag(impact_info_name),                
                ))
        getattr(process, isv_info_name).useSVClustering = cms.bool(True)
        getattr(process, isv_info_name).rParam = cms.double(delta_r)
        getattr(process, isv_info_name).extSVDeltaRToJet = cms.double(delta_r)
        getattr(process, isv_info_name).trackSelection.jetDeltaRMax = cms.double(delta_r)
        getattr(process, isv_info_name).vertexCuts.maxDeltaRToJetAxis = cms.double(delta_r)
        getattr(process, isv_info_name).jetAlgorithm = cms.string(jetAlgo)
        getattr(process, isv_info_name).fatJets  =  cms.InputTag(fatjet_name.replace("ak08PFPrunedJetsCHS","slimmedJetsAK8").replace("looseOptRHTT","ca15PFJetsCHS"))
        getattr(process, isv_info_name).groomedFatJets  =  cms.InputTag(fatjet_name)

        # CSV V2 COMPUTER
        setattr(process,
                csvv2_computer_name,
                process.candidateCombinedSecondaryVertexV2Computer.clone())

        # CSV IVF V2
        setattr(process,
                csvv2ivf_name,
                process.pfCombinedInclusiveSecondaryVertexV2BJetTags.clone(
                    tagInfos = cms.VInputTag(cms.InputTag(impact_info_name),
                                             cms.InputTag(isv_info_name)),
                    jetTagComputer = cms.string(csvv2_computer_name,)
                ))


        # Produce the output
        process.OUT.outputCommands.append("keep *_{0}_*_EX".format(csvv2ivf_name))




    ###
    ### GenHFHadronMatcher
    ###
    if isMC:
        process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

        genParticleCollection = 'prunedGenParticles'

        genJetCollection = "slimmedGenJets"


        genJetInputParticleCollection = 'packedGenParticles'
             
        from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
        process.ak8GenJetsCustom = ak4GenJets.clone(
            src = genJetInputParticleCollection,
            rParam = cms.double(0.8),
            jetAlgorithm = cms.string("AntiKt")
            )
 #        genJetAK08Collection = "ak8GenJetsCustom"


        # Ghost particle collection used for Hadron-Jet association
        # MUST use proper input particle collection
        from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
        process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
            particles = genParticleCollection
        )

        # Input particle collection for matching to gen jets (partons + leptons)
        # MUST use use proper input jet collection: the jets to which hadrons should be associated
        # rParam and jetAlgorithm MUST match those used for jets to be associated with hadrons
        # More details on the tool: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition
        from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import genJetFlavourPlusLeptonInfos
        process.genJetFlavourPlusLeptonInfos = genJetFlavourPlusLeptonInfos.clone(
            jets = genJetCollection,
            rParam = cms.double(0.4),
            jetAlgorithm = cms.string("AntiKt")
        )


        # Plugin for analysing B hadrons
        # MUST use the same particle collection as in selectedHadronsAndPartons
        from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import matchGenBHadron
        process.matchGenBHadron = matchGenBHadron.clone(
            genParticles = genParticleCollection
        )

        # Plugin for analysing C hadrons
        # MUST use the same particle collection as in selectedHadronsAndPartons
        from PhysicsTools.JetMCAlgos.sequences.GenHFHadronMatching_cff import matchGenCHadron
        process.matchGenCHadron = matchGenCHadron.clone(
            genParticles = genParticleCollection
        )
        process.OUT.outputCommands.append("keep *_matchGenBHadron__EX")
        process.OUT.outputCommands.append("keep *_matchGenCHadron__EX")
        process.OUT.outputCommands.append("keep *_matchGenBHadron_*_EX")
        process.OUT.outputCommands.append("keep *_matchGenCHadron_*_EX")
        process.OUT.outputCommands.append("keep *_ak8GenJetsCustom_*_EX")

    #Schedule to run soft muon and electron taggers on miniAOD
    process.softPFElectronsTagInfos.jets = cms.InputTag("slimmedJets")
    process.softPFElectronsTagInfos.electrons = cms.InputTag("slimmedElectrons")
    process.softPFElectronsTagInfos.primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices")
            
    process.softPFMuonsTagInfos.jets = cms.InputTag("slimmedJets")
    process.softPFMuonsTagInfos.muons = cms.InputTag("slimmedMuons")
    process.softPFMuonsTagInfos.primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices")
        
    process.OUT.outputCommands.append("keep *_softPFElectronsTagInfos_*_*")
    process.OUT.outputCommands.append("keep *_softPFMuonsTagInfos_*_*")
    process.OUT.outputCommands.append("keep *_softPFElectronBJetTags_*_EX")
    process.OUT.outputCommands.append("keep *_softPFMuonBJetTags_*_EX")



    ########################################
    # Generator level hadronic tau decays
    ########################################
    if isMC:
        process.load("PhysicsTools.JetMCAlgos.TauGenJets_cfi")
        process.tauGenJets.GenParticles = cms.InputTag('prunedGenParticles')
        process.load("PhysicsTools.JetMCAlgos.TauGenJetsDecayModeSelectorAllHadrons_cfi")
        process.OUT.outputCommands.append("keep *_tauGenJetsSelectorAllHadrons_*_EX")

    return process
コード例 #28
0
ファイル: makeJets_cff.py プロジェクト: UBParker/JMEValidator
import FWCore.ParameterSet.Config as cms
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets

#PFCHS
pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))

# make GEN jets
AK4GenJets = ak4GenJets.clone( rParam = 0.4 )
AK4GenJets.src = cms.InputTag('packedGenParticles');

AK8GenJets = ak4GenJets.clone( rParam = 0.8 )
AK8GenJets.src = cms.InputTag('packedGenParticles');

AK4PFchsJets = ak4PFJets.clone();
AK4PFchsJets.src = cms.InputTag('pfCHS','','JRA');

AK8PFchsJets = ak4PFJets.clone( rParam = 0.8 );
AK8PFchsJets.src = cms.InputTag('pfCHS','','JRA');

AK4PFJetsPuppi = ak4PFJetsPuppi.clone( )
AK4PFJetsPuppi.src =  cms.InputTag('puppi','','JRA') #PFJetParameters

AK8PFJetsPuppi = ak4PFJetsPuppi.clone( rParam = 0.8 )
AK8PFJetsPuppi.src =  cms.InputTag('puppi','','JRA') #PFJetParameters
コード例 #29
0
ファイル: RecoGenJets_cff.py プロジェクト: p2l1pfp/cmssw
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
from RecoJets.JetProducers.ak8GenJets_cfi import ak8GenJets

from RecoHI.HiJetAlgos.HiGenJets_cff import *

ak4GenJetsNoNu = ak4GenJets.clone(src="genParticlesForJetsNoNu")
ak8GenJetsNoNu = ak8GenJets.clone(src="genParticlesForJetsNoNu")

ak4GenJetsNoMuNoNu = ak4GenJets.clone(src="genParticlesForJetsNoMuNoNu")
ak8GenJetsNoMuNoNu = ak8GenJets.clone(src="genParticlesForJetsNoMuNoNu")

recoGenJetsTask = cms.Task(ak4GenJets, ak8GenJets, ak4GenJetsNoNu,
                           ak8GenJetsNoNu)
recoGenJets = cms.Sequence(recoGenJetsTask)

recoAllGenJetsTask = cms.Task(ak4GenJets, ak8GenJets)
recoAllGenJets = cms.Sequence(recoAllGenJetsTask)

recoAllGenJetsNoNuTask = cms.Task(ak4GenJetsNoNu, ak8GenJetsNoNu)
recoAllGenJetsNoNu = cms.Sequence(recoAllGenJetsNoNuTask)

recoAllGenJetsNoMuNoNuTask = cms.Task(ak4GenJetsNoMuNoNu, ak8GenJetsNoMuNoNu)
recoAllGenJetsNoMuNoNu = cms.Sequence(recoAllGenJetsNoMuNoNuTask)
コード例 #30
0
    "MergedGenParticleProducer",
    inputPruned=cms.InputTag("prunedGenParticles"),
    inputPacked=cms.InputTag("packedGenParticles"))

#select only stable particles (status=1) for reclustering GenJets for the matching; exclude neutrinos & SUSY particles
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
genParticlesForGenJets = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("genParticlesMerged"),
    cut=cms.string(
        "status==1 && abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16 && abs(pdgId) < 1000000"
    ),
)

#recluster GenJets
genJetsReclustered = ak4GenJets.clone(
    src=cms.InputTag('genParticlesForGenJets'),
    jetPtMin=cms.double(1.0)  #default: 3 GeV 
)

#produce DisplacedGenVertices and match to GenJets
displacedGenVertices = cms.EDProducer(
    "DisplacedGenVertexProducer",
    srcGenParticles=cms.InputTag("genParticlesMerged"),
    srcGenJets=cms.InputTag("genJetsReclustered"))

displacedGenVertexSequence = cms.Sequence(genParticlesMerged +
                                          genParticlesForGenJets +
                                          genJetsReclustered +
                                          displacedGenVertices)
コード例 #31
0
## Filter out neutrinos from packed GenParticles
#for miniaod
process.packedGenParticlesForJetsNoNu = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("packedGenParticles"),
    cut=cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
task.add(process.packedGenParticlesForJetsNoNu)

#for aod
process.load('RecoJets.Configuration.GenJetParticles_cff')
task.add(process.genParticlesForJetsNoNu)

## Define GenJets
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsNoNu = ak4GenJets.clone(
    src='genParticlesForJetsNoNu',
    srcPVs=cms.InputTag("offlinePrimaryVertices"),
)  #different in miniaod!!!#'packedGenParticlesForJetsNoNu')
task.add(process.ak4GenJetsNoNu)

process.ak4GenJetsNoNuFakeRejected = ak4GenJets.clone(
    src='genParticlesForJetsNoNu',
    srcPVs=cms.InputTag('selectedPrimaryVerticesFakeRejected', '',
                        'ReclusterAOD'),
)  #different in miniaod!!!#'packedGenParticlesForJetsNoNu')
task.add(process.ak4GenJetsNoNuFakeRejected)

#---------------------#
#     Reco Jets       #
#---------------------#

## recluster reco jets
コード例 #32
0
def initFatJets(process, isData, labels):
    """
    @labels: ['AK8', 'CA15', ...]
    """

    ########################################
    ##         INITIAL SETUP              ##
    ########################################

    sequence = cms.Sequence()

    addattr = AddAttr(process, sequence)

    if not isData and not hasattr(process, 'packedGenParticlesForJetsNoNu'):
        genParticlesNoNu = addattr(
            'packedGenParticlesForJetsNoNu',
            cms.EDFilter(
                "CandPtrSelector",
                src=cms.InputTag(finalStateGenParticles),
                cut=cms.string(
                    "abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
            ))

        for label in labels:
            matches = re.match('(AK|CA)([0-9]+)$', label)
            if not matches:
                raise RuntimeError('Unknown algo label ' + label)

            # set up radius and algoName from the input label
            radius = float(matches.group(2)) * 0.1
            if matches.group(1) == 'CA':
                algoName = 'CambridgeAachen'
            elif matches.group(1) == 'AK':
                algoName = 'AntiKt'

            # gen jets
            addattr(
                'genJetsNoNu' + label,
                ak4GenJets.clone(
                    doAreaFastjet=cms.bool(
                        False
                    ),  # This flag is turned on by default in CMSSW and makes things much slower, do not turn this on
                    jetAlgorithm=cms.string(algoName),
                    rParam=cms.double(radius),
                    src=genParticlesNoNu))
            genJetsMod = addattr.last

            sdZcut, sdBeta = sdParams(radius)

            # gen jets soft drop for subjet gen matching
            addattr(
                'genJetsNoNuSoftDrop' + label,
                genJetsMod.clone(R0=cms.double(radius),
                                 useSoftDrop=cms.bool(True),
                                 zcut=cms.double(sdZcut),
                                 beta=cms.double(sdBeta),
                                 writeCompound=cms.bool(True),
                                 useExplicitGhosts=cms.bool(True),
                                 jetCollInstanceName=cms.string("SubJets")))

    # Charged hadron subtraction
    if not hasattr(process, 'pfCHS'):
        addattr(
            'pfCHS',
            cms.EDFilter("CandPtrSelector",
                         src=cms.InputTag(pfSource),
                         cut=cms.string("fromPV")))

    return sequence
コード例 #33
0
def initFatJets(process,isData):
  adaptPVs(process, pvCollection=cms.InputTag('offlineSlimmedPrimaryVertices'))
  isMC = not isData

  ########################################
  ##         INITIAL SETUP              ##
  ########################################
  jetCorrectionsAK4 = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None')
  jetCorrectionsAK8 = ('AK8PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None')
  if isData:
      jetCorrectionsAK4[1].append('L2L3Residual')
      jetCorrectionsAK8[1].append('L2L3Residual')

  ## Various collection names
  genParticles = 'prunedGenParticles'
  jetSource = 'ak4PFJets'
  genJetCollection = 'ak4GenJetsNoNu'
  pfCandidates = 'packedPFCandidates'
  pvSource = 'offlineSlimmedPrimaryVertices'
  svSource = 'slimmedSecondaryVertices'
  muSource = 'slimmedMuons'
  elSource = 'slimmedElectrons'

  PFjetAlgo="AK4"

  ## Load standard PAT objects
  process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
  process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff")

  bTagInfos = [
      'pfImpactParameterTagInfos'
     ,'pfSecondaryVertexTagInfos'
     ,'pfInclusiveSecondaryVertexFinderTagInfos'
     ,'softPFMuonsTagInfos'
     ,'softPFElectronsTagInfos'
  ]
  ## b-tag discriminators
  bTagDiscriminators = [
      'pfCombinedSecondaryVertexV2BJetTags'
      ,'pfCombinedInclusiveSecondaryVertexV2BJetTags'
  ]
  
  process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))
  if isMC:
    process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedGenParticles"), cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
    process.ak4GenJetsNoNu = ak4GenJets.clone(src = 'packedGenParticlesForJetsNoNu')
  process.ak4PFJets = ak4PFJets.clone(src='pfCHS',doAreaFastjet=True)

  postfix='PFlow'
  
  ## Switch the default jet collection (done in order to use the above specified b-tag infos and discriminators)
  switchJetCollection(
      process,
      jetSource = cms.InputTag(jetSource),
      pfCandidates = cms.InputTag(pfCandidates),
      pvSource = cms.InputTag(pvSource),
      svSource = cms.InputTag(svSource),
      muSource = cms.InputTag(muSource),
      elSource = cms.InputTag(elSource),
      btagInfos = bTagInfos,
      btagDiscriminators = bTagDiscriminators,
      jetCorrections = jetCorrectionsAK4,
      genJetCollection = cms.InputTag(genJetCollection),
      genParticles = cms.InputTag(genParticles),
      postfix = postfix
  )

  if isMC:
    process.fatjetInitSequence = cms.Sequence(
        process.packedGenParticlesForJetsNoNu+
        process.ak4GenJetsNoNu
    )
  else:
    process.fatjetInitSequence = cms.Sequence()
  process.fatjetInitSequence += process.pfCHS
  process.fatjetInitSequence += process.ak4PFJets

  return process.fatjetInitSequence
コード例 #34
0
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc')
process.load("Configuration.StandardSequences.MagneticField_cff")

######################
# load low-pt charged GenJet configuration here
# get charged genParticles
process.load('QCDAnalysis.UEAnalysis.UEAnalysisParticles_cfi')
process.chargeParticles.cut = cms.string('charge != 0 & pt > 0.3 & status = 1')
# get genjet definitions
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
from RecoJets.JetProducers.ak5GenJets_cfi import ak5GenJets
# clone normal ak4 genjets
process.ak4ChgGenJets = ak4GenJets.clone(
src = cms.InputTag("chargeParticles"),
jetPtMin = cms.double(0.3)
)
# clone normal ak5 genjets
process.ak5ChgGenJets = ak5GenJets.clone( 
src = cms.InputTag("chargeParticles"),
jetPtMin = cms.double(0.3)
)
# add the processes
process.chargedgenjets = cms.Path(process.UEAnalysisParticles*process.ak4ChgGenJets*process.ak5ChgGenJets)
######################

# Here starts the CFF specific part
import CommonFSQFramework.Core.customizePAT
process = CommonFSQFramework.Core.customizePAT.customize(process)

# GT customization
コード例 #35
0
def makeFatJets(process,isData,pfCandidates,algoLabel,jetRadius):
  
  isMC = not isData
  postfix='PFlow'
  if pfCandidates=='particleFlow':
    # mini aod needs a different config
    pfCandidates = 'pfCHS'
  
  if pfCandidates=='pfCHS':
    puMethod='CHS'
  else:
    puMethod='Puppi'

  rLabel = algoLabel+str(int(jetRadius*10))
  neroLabel = rLabel+puMethod

  if algoLabel=='CA':
    jetAlgo = 'CambridgeAachen'
  else:
    jetAlgo = 'AntiKt'

  if jetRadius<1:
    sdZcut = 0.1
    sdBeta = 0.0
  else:
    sdZcut = 0.2
    sdBeta = 1.0

  setattr(process,neroLabel+'Sequence',cms.Sequence())
  newSeq = getattr(process,neroLabel+'Sequence')
  
  ## Various collection names
  genParticles = 'prunedGenParticles'
  pvSource = 'offlineSlimmedPrimaryVertices'
  svSource = 'slimmedSecondaryVertices'
  muSource = 'slimmedMuons'
  elSource = 'slimmedElectrons'
  bTagInfos = [
      'pfImpactParameterTagInfos'
     ,'pfSecondaryVertexTagInfos'
     ,'pfInclusiveSecondaryVertexFinderTagInfos'
     ,'softPFMuonsTagInfos'
     ,'softPFElectronsTagInfos'
  ]
  ## b-tag discriminators
  bTagDiscriminators = [
      'pfCombinedSecondaryVertexV2BJetTags'
      ,'pfCombinedInclusiveSecondaryVertexV2BJetTags'
  ]


  bTagInfosSubjets = [
      'pfImpactParameterTagInfos'
     ,'pfSecondaryVertexTagInfos'
     ,'pfInclusiveSecondaryVertexFinderTagInfos'
     ,'softPFMuonsTagInfos'
     ,'softPFElectronsTagInfos'
  ]
  ## b-tag discriminators
  bTagDiscriminatorsSubjets = [
      'pfCombinedSecondaryVertexV2BJetTags'
      ,'pfCombinedInclusiveSecondaryVertexV2BJetTags'
  ]

  bTagInfosSubjets=['None']
  bTagDiscriminatorsSubjets=['None']

  ### jet clustering ### 
  ########################################
  ##           REMAKE JETS              ##
  ########################################

  addingGenJets = False

  if not(hasattr(process,"genJetsNoNu"+rLabel)) and isMC:
    addingGenJets = True
    setattr(process,"genJetsNoNu"+rLabel, ak4GenJets.clone(
                                           jetAlgorithm = cms.string(jetAlgo),
                                           rParam = cms.double(jetRadius),
                                           src = cms.InputTag("packedGenParticlesForJetsNoNu")
                                         )
    )
  setattr(process,"PFJets"+neroLabel, ak4PFJets.clone(
                                                jetAlgorithm = cms.string(jetAlgo),
                                                rParam = cms.double(jetRadius),
                                                src = cms.InputTag(pfCandidates),
                                                srcPVs = cms.InputTag(pvSource),
                                                doAreaFastjet = cms.bool(True),
                                                jetPtMin = cms.double(150)
                                            )
  )
  if not(hasattr(process,"genJetsNoNuSoftDrop"+rLabel)) and isMC:
    addingGenJets = True
    setattr(process,"genJetsNoNuSoftDrop"+rLabel, getattr(process,'genJetsNoNu'+rLabel).clone(
                                                      R0 = cms.double(jetRadius),
                                                      useSoftDrop = cms.bool(True),
                                                      zcut = cms.double(sdZcut),
                                                      beta = cms.double(sdBeta),
                                                      writeCompound = cms.bool(True),
                                                      jetCollInstanceName=cms.string("SubJets")
                                                  )
    )
  setattr(process,"PFJets"+"SoftDrop"+neroLabel, getattr(process,'PFJets'+neroLabel).clone(
                                                          useSoftDrop = cms.bool(True),
                                                          R0 = cms.double(jetRadius),
                                                          zcut = cms.double(sdZcut),
                                                          beta = cms.double(sdBeta),
                                                          writeCompound = cms.bool(True),
                                                          useExplicitGhosts = cms.bool(True),
                                                          jetCollInstanceName=cms.string("SubJets"),
                                                          jetPtMin = cms.double(150)
                                                      )
  )
  if addingGenJets and not(isData):
    newSeq += getattr(process,'genJetsNoNu'+rLabel)
    newSeq += getattr(process,'genJetsNoNuSoftDrop'+rLabel)
  newSeq += getattr(process,'PFJets'+neroLabel)
  newSeq += getattr(process,'PFJets'+"SoftDrop"+neroLabel)
  
  ########################################
  ##           SUBSTRUCTURE             ##
  #######################################

  setattr(process,neroLabel+'Njettiness',                          
          Njettiness.clone(                                      
            src = cms.InputTag('PFJets'+neroLabel),       
            R0 = cms.double(jetRadius),
            Njets = cms.vuint32(1,2,3,4)
          )
  )

  setattr(process,neroLabel+'SDKinematics',
      cms.EDProducer('RecoJetDeltaRValueMapProducer',
            src = cms.InputTag('PFJets'+neroLabel),
            matched = cms.InputTag('PFJets'+"SoftDrop"+neroLabel),
            distMax = cms.double(1.5),
            values = cms.vstring('mass'),
            valueLabels = cms.vstring('Mass'),
      )
  )

  newSeq += getattr(process,neroLabel+'SDKinematics')
  newSeq += getattr(process,neroLabel+'Njettiness')

  ### subjet b-tagging ###

  setattr(process,neroLabel+'PFImpactParameterTagInfos',
      pfImpactParameterTagInfos.clone(
          jets      = cms.InputTag('PFJets'+"SoftDrop"+neroLabel,'SubJets'),
          maxDeltaR = cms.double(jetRadius),
          primaryVertex = cms.InputTag('offlineSlimmedPrimaryVertices'),
          candidates = cms.InputTag('packedPFCandidates')
      )
  )

  setattr(process,neroLabel+'PFInclusiveSecondaryVertexFinderTagInfos',
    pfInclusiveSecondaryVertexFinderTagInfos.clone(
      trackIPTagInfos = cms.InputTag(neroLabel+'PFImpactParameterTagInfos'),
      extSVCollection = cms.InputTag('slimmedSecondaryVertices')
    )
  )
  setattr(process,neroLabel+'PFCombinedInclusiveSecondaryVertexV2BJetTags',
    pfCombinedInclusiveSecondaryVertexV2BJetTags.clone(
      tagInfos = cms.VInputTag( 
        cms.InputTag(neroLabel+"PFImpactParameterTagInfos"), 
        cms.InputTag(neroLabel+"PFInclusiveSecondaryVertexFinderTagInfos") 
      )
    )
  )
  newSeq += getattr(process,neroLabel+'PFImpactParameterTagInfos')
  newSeq += getattr(process,neroLabel+'PFInclusiveSecondaryVertexFinderTagInfos')
  newSeq += getattr(process,neroLabel+'PFCombinedInclusiveSecondaryVertexV2BJetTags')
  
  bTagInfos = ['None']
  bTagDiscriminators = ['None']

  ########################################
  ##          MAKE PAT JETS             ##
  ########################################

  addJetCollection(
      process,
      labelName='PF'+neroLabel,
      jetSource=cms.InputTag('PFJets'+neroLabel),
      algo=algoLabel,           # needed for jet flavor clustering
      rParam=jetRadius, # needed for jet flavor clustering
      pfCandidates = cms.InputTag('packedPFCandidates'),
      pvSource = cms.InputTag(pvSource),
      svSource = cms.InputTag(svSource),
      muSource = cms.InputTag(muSource),
      elSource = cms.InputTag(elSource),
      btagInfos = bTagInfos,
      btagDiscriminators = bTagDiscriminators,
      genJetCollection = cms.InputTag('genJetsNoNu'+rLabel),
      genParticles = cms.InputTag(genParticles),
      getJetMCFlavour = False, # jet flavor disabled
  )
  getattr(process,'selectedPatJetsPF'+neroLabel).cut = cms.string("abs(eta) < " + str(2.5))
  ## SOFT DROP ##
  addJetCollection(
      process,
      labelName='SoftDropPF'+neroLabel,
      jetSource=cms.InputTag('PFJets'+"SoftDrop"+neroLabel),
      pfCandidates = cms.InputTag('packedPFCandidates'),
      algo=algoLabel,
      rParam=jetRadius,
      btagInfos = ['None'],
      btagDiscriminators = ['None'],
      genJetCollection = cms.InputTag('genJetsNoNu'+rLabel),
      genParticles = cms.InputTag(genParticles),
      getJetMCFlavour = False, # jet flavor disabled
  )
  addJetCollection(
      process,
      labelName='SoftDropSubjetsPF'+neroLabel,
      jetSource=cms.InputTag('PFJets'+"SoftDrop"+neroLabel,'SubJets'),
      algo=algoLabel,  
      rParam=jetRadius, 
      pfCandidates = cms.InputTag('packedPFCandidates'),
      pvSource = cms.InputTag(pvSource),
      svSource = cms.InputTag(svSource),
      muSource = cms.InputTag(muSource),
      elSource = cms.InputTag(elSource),
      btagInfos = bTagInfosSubjets,
      btagDiscriminators = bTagDiscriminatorsSubjets,
      genJetCollection = cms.InputTag('genJetsNoNuSoftDrop'+rLabel,'SubJets'),
      genParticles = cms.InputTag(genParticles),
      explicitJTA = True,  # needed for subjet b tagging
      svClustering = True, # needed for subjet b tagging
      fatJets = cms.InputTag('PFJets'+neroLabel),              # needed for subjet flavor clustering
      groomedFatJets = cms.InputTag('PFJets'+"SoftDrop"+neroLabel), # needed for subjet flavor clustering
      runIVF = False,
      getJetMCFlavour = False, # jet flavor disabled
  )
  
  isMC = not(isData)
  if isMC:
    newSeq += getattr(process,'patJetPartonMatchPF'+neroLabel)
    newSeq += getattr(process,'patJetGenJetMatchPF'+neroLabel)
  newSeq += getattr(process,'patJetsPF'+neroLabel)
  newSeq += getattr(process,'selectedPatJetsPF'+neroLabel)
  
  if isMC:
    newSeq += getattr(process,'patJetPartonMatchSoftDropPF'+neroLabel)
    newSeq += getattr(process,'patJetGenJetMatchSoftDropPF'+neroLabel)
  newSeq += getattr(process,'patJetsSoftDropPF'+neroLabel)
  newSeq += getattr(process,'selectedPatJetsSoftDropPF'+neroLabel)
  
  if isMC:
    newSeq += getattr(process,'patJetPartonMatchSoftDropSubjetsPF'+neroLabel)
    newSeq += getattr(process,'patJetGenJetMatchSoftDropSubjetsPF'+neroLabel)
  newSeq += getattr(process,'patJetsSoftDropSubjetsPF'+neroLabel)
  newSeq += getattr(process,'selectedPatJetsSoftDropSubjetsPF'+neroLabel)
  
  setattr(process,"selectedPatJetsSoftDropPF"+"Packed"+neroLabel, 
          cms.EDProducer("BoostedJetMerger",    
                          jetSrc=cms.InputTag("selectedPatJetsSoftDropPF"+neroLabel),
                          subjetSrc=cms.InputTag("selectedPatJetsSoftDropSubjetsPF"+neroLabel)  
          )
  )
  ## PACK ##
  setattr(process,"packedPatJetsPF"+neroLabel, 
          cms.EDProducer("JetSubstructurePacker",
                          jetSrc = cms.InputTag('selectedPatJetsPF'+neroLabel),
                          distMax = cms.double(jetRadius),
                          algoTags = cms.VInputTag(),
                          algoLabels = cms.vstring(),
                          fixDaughters = cms.bool(False)
                        )
  )
  getattr(process,"packedPatJetsPF"+neroLabel).algoTags.append(
      cms.InputTag('selectedPatJetsSoftDropPF'+"Packed"+neroLabel)
  )
  getattr(process,"packedPatJetsPF"+neroLabel).algoLabels.append(
      'SoftDrop'
  )
  getattr(process,'patJetsPF'+neroLabel).userData.userFloats.src += [neroLabel+'Njettiness:tau1']
  getattr(process,'patJetsPF'+neroLabel).userData.userFloats.src += [neroLabel+'Njettiness:tau2']
  getattr(process,'patJetsPF'+neroLabel).userData.userFloats.src += [neroLabel+'Njettiness:tau3']
  getattr(process,'patJetsPF'+neroLabel).userData.userFloats.src += [neroLabel+'Njettiness:tau4']
  getattr(process,'patJetsPF'+neroLabel).userData.userFloats.src += [neroLabel+'SDKinematics:Mass']

  for m in ['patJetsPF'+neroLabel,'patJetsSoftDropSubjetsPF'+neroLabel]:
    if hasattr(process,m) and getattr( getattr(process,m),'addBTagInfo'):
      setattr( getattr(process,m), 'addTagInfos', cms.bool(True))
    #if hasattr(process,m):
    #  setattr( getattr(process,m), 'addJetFlavourInfo', cms.bool(True))

  newSeq += cms.Sequence(
      getattr(process,'selectedPatJetsSoftDropPF'+"Packed"+neroLabel)+
      getattr(process,'packedPatJetsPF'+neroLabel)
  )

  if isData:
      removeMCMatching(process, ['All'], outputModules = [])
  return newSeq
コード例 #36
0
    def addGenJetCollection(
        self,
        proc,
        jet,
        inputCollection="",
        genName="",
        minPt=5.,
    ):
        print(
            "jetCollectionTools::GenJetAdder::addGenJetCollection: Adding Gen Jet Collection: {}"
            .format(jet))
        currentTasks = []

        #
        # Decide which jet collection we're dealing with
        #
        jetLower = jet.lower()
        jetUpper = jet.upper()
        tagName = jetUpper
        genJetInfo = GenJetInfo(jet, inputCollection)

        #=======================================================
        #
        # If gen jet collection in MiniAOD is not
        # specified, build the genjet collection.
        #
        #========================================================
        if not inputCollection:
            print(
                "jetCollectionTools::GenJetAdder::addGenJetCollection: inputCollection not specified. Building genjet collection now"
            )
            #
            # Setup GenParticles
            #
            packedGenPartNoNu = "packedGenParticlesForJetsNoNu"
            if packedGenPartNoNu not in self.prerequisites:
                setattr(
                    proc, packedGenPartNoNu,
                    cms.EDFilter(
                        "CandPtrSelector",
                        src=cms.InputTag("packedGenParticles"),
                        cut=cms.string(
                            "abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"
                        ),
                    ))
                self.prerequisites.append(packedGenPartNoNu)
            #
            # Create the GenJet collection
            #
            genJetsCollection = "{}{}{}".format(genJetInfo.jetAlgo.upper(),
                                                genJetInfo.jetSize,
                                                'GenJetsNoNu')
            setattr(
                proc, genJetsCollection,
                ak4GenJets.clone(
                    src=packedGenPartNoNu,
                    jetAlgorithm=cms.string(
                        supportedJetAlgos[genJetInfo.jetAlgo]),
                    rParam=cms.double(genJetInfo.jetSizeNr),
                ))
            self.prerequisites.append(genJetsCollection)
        #
        # GenJet Flavour Labelling
        #
        genFlavour = "{}Flavour".format(genJetInfo.jetTagName)
        setattr(
            proc, genFlavour,
            patJetFlavourAssociation.clone(
                jets=cms.InputTag(genJetsCollection),
                jetAlgorithm=cms.string(supportedJetAlgos[genJetInfo.jetAlgo]),
                rParam=cms.double(genJetInfo.jetSizeNr),
            ))

        currentTasks.append(genFlavour)
        self.main.extend(currentTasks)

        return genJetInfo
コード例 #37
0
## Details in: PhysicsTools/JetExamples/test/printJetFlavourInfo.cc, PhysicsTools/JetExamples/test/printJetFlavourInfo.py
## and in: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition  

## Supply PDG ID to real name resolution of MC particles
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

## Input particles for gen jets (stable gen particles to be used in clustering, excluding electrons, muons and neutrinos from hard interaction)
from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJets
process.genParticlesForJetsNoNuNoLepton = genParticlesForJets.clone(
    src = genJetInputParticleCollection,
    excludeResonances = True,
    excludeFromResonancePids = [11, 12, 13, 14, 16],
)

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsNoNuNoLepton = ak4GenJets.clone(src = "genParticlesForJetsNoNuNoLepton")

# Ghost particle collection for matching to gen jets (b/c hadrons + leptons)
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(particles = genParticleCollection)

# Flavour info: jet collection with all associated ghosts
# For the moment leptons need to be specified explicitely here, until lepton access can be made more generic in miniAOD
# This is only needed as long as the jetConstituents are not accessible directly in miniAOD, then it should be fixed
# by using the leptons from the constituents, instead of feeding them as ghosts into the jets 

from PhysicsTools.JetMCAlgos.AK4PFJetsMCFlavourInfos_cfi import ak4JetFlavourInfos
process.ak4GenJetFlavourPlusLeptonInfos = ak4JetFlavourInfos.clone(
    jets = genJetCollection,
    leptons = cms.InputTag("selectedHadronsAndPartons", "leptons")
)
コード例 #38
0
# the cofigurations
# process.load("flashgg/MicroAOD/flashggVertexMaps_cfi")
# flashggTkVtxMap_cfi.py
process.load("flashgg/MicroAOD/flashggTkVtxMap_cfi") 
process.load("flashgg/MicroAOD/flashggPhotons_cfi")
process.load("flashgg/MicroAOD/flashggDiPhotons_cfi")
process.load("flashgg/MicroAOD/flashggPreselectedDiPhotons_cfi")
process.load("flashgg/MicroAOD/flashggElectrons_cfi")

# Import RECO jet producer for ak4 PF and GEN jet

from RecoJets.JetProducers.ak4PFJets_cfi  import ak4PFJets
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

process.ak4PFJets = ak4PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True)
process.ak4GenJets = ak4GenJets.clone(src = 'packedGenParticles')

# The following is make patJets, but EI is done with the above
process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
process.load("Configuration.EventContent.EventContent_cff")
process.load('Configuration.StandardSequences.Geometry_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'PLS170_V7AN1::All'

from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
addJetCollection(
    process,
    postfix        = "",
    labelName      = 'AK4PF',
    jetSource      = cms.InputTag('ak4PFJets'),
コード例 #39
0
def makeTreeTreeFromMiniAOD(process,
outFileName,
NJetsMin=2,
HTMin=350.,
MHTMin=0.,
reportEveryEvt=10,
testFileName="",
Global_Tag="",
METFiltersProcess="",
MC=False,
debug = False,
QCD=False,
LostLepton=False,
numProcessedEvt=1000,
doAK8Reclustering=False,
doJECCorrection=False,
doPuppi=False,
leptonFilter=True,
genJetsAK8Reclustering=True,
customizeHBHENoiseForEarlyData=False,
customizeHBHENoiseForRun2015D=True,
jsonFileName="",
reDoPruningAndSoftdrop=False,
isCrab=False):

    process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff")
    if (MC):
        customizeHBHENoiseForRun2015D=False

    process.GlobalTag.globaltag = Global_Tag

    ## Added Geometry cfi files ###
    ## Not in current EXO-WW configuration ##
    process.load("Geometry.CMSCommonData.cmsIdealGeometryXML_cfi");
    process.load("Geometry.CaloEventSetup.CaloGeometry_cfi");
    process.load("Geometry.CaloEventSetup.CaloTopology_cfi");

    ## --- Log output ------------------------------------------------------
    process.load("FWCore.MessageService.MessageLogger_cfi")
    process.MessageLogger.cerr = cms.untracked.PSet(
        placeholder = cms.untracked.bool(True)
        )
    process.MessageLogger.cout = cms.untracked.PSet(
        INFO = cms.untracked.PSet(reportEvery = cms.untracked.int32(reportEveryEvt))
        )
    process.options = cms.untracked.PSet(
        wantSummary = cms.untracked.bool(True)
        ) 


    ## --- Files to process ------------------------------------------------
    process.maxEvents = cms.untracked.PSet(
        input = cms.untracked.int32(numProcessedEvt)
        )
    process.source = cms.Source("PoolSource",

        fileNames = cms.untracked.vstring(testFileName)
        )

 ## ----------------------------------------------------------------------------------------------
## Triggers
## ----------------------------------------------------------------------------------------------
# The trigger results are saved to the tree as a vector
# Three vectors are saved:
# 1) names of the triggers
# 2) trigger results
# 3) trigger prescales
# the indexing of these vectors must match
# If the version number of the input trigger name is omitted,
# any matching trigger will be included (default behavior)
    from SemiLeptonicWVA.Utils.triggerproducer_cfi import triggerProducer
    process.TriggerProducer = triggerProducer.clone( 
        trigTagArg1 = cms.string('TriggerResults'),
        trigTagArg2 = cms.string(''),
        trigTagArg3 = cms.string('HLT'),
        prescaleTagArg1 = cms.string('patTrigger'),
        prescaleTagArg2 = cms.string(''),
        prescaleTagArg3 = cms.string(''),
        triggerNameList = cms.vstring( # list of trigger names
            'HLT_Ele22_eta2p1_WPTight_Gsf_v',
            'HLT_IsoMu20_v',
            'HLT_IsoTkMu20_v',
	    'HLT_Ele27_WP85_Gsf_v'
            )
        )

    ## --- Output file -----------------------------------------------------
    process.TFileService = cms.Service(
        "TFileService",
        fileName = cms.string(outFileName+".root")
        )

    ############### JSON Filter            
    import FWCore.PythonUtilities.LumiList as LumiList
    import sys

    if not MC:
        if(len(jsonFileName)>0):
            import FWCore.PythonUtilities.LumiList as LumiList
            process.source.lumisToProcess = LumiList.LumiList(filename = jsonFileName).getVLuminosityBlockRange()
        else:
            print "ERROR!! running on data with no json file applied!"
            sys.exit()

####### some gen infos
    from SemiLeptonicWVA.Utils.geneventinfo_cfi import geneventinfo
    process.GenEventInfo = geneventinfo.clone()
    
###Lepton Filter
    process.filterSeq = cms.Sequence ()

    process.load('SemiLeptonicWVA.Utils.leptonfilter_cfi')

    process.leptonFilter.electronsInputTag = cms.InputTag("slimmedElectrons")
    process.leptonFilter.muonsInputTag = cms.InputTag("slimmedMuons")
    process.leptonFilter.eleFilterPtCut = cms.double(20.0)
    process.leptonFilter.muFilterPtCut = cms.double(20.0)
    
    if (leptonFilter):
        process.filterSeq = cms.Sequence (process.leptonFilter)
    
       ## --- Setup of TreeMaker ----------------------------------------------
    FilterNames = cms.VInputTag()
    FilterNames.append(cms.InputTag("HBHENoiseFilterRA2","HBHENoiseFilterResult","PAT"))
    FilterNames.append(cms.InputTag("beamHaloFilter"))
    FilterNames.append(cms.InputTag("eeNoiseFilter"))
    FilterNames.append(cms.InputTag("trackingFailureFilter"))
    FilterNames.append(cms.InputTag("inconsistentMuons"))
    FilterNames.append(cms.InputTag("greedyMuons"))
    FilterNames.append(cms.InputTag("ra2EcalTPFilter"))
    FilterNames.append(cms.InputTag("ra2EcalBEFilter"))
    FilterNames.append(cms.InputTag("hcalLaserEventFilter"))
    FilterNames.append(cms.InputTag("ecalLaserCorrFilter"))
    FilterNames.append(cms.InputTag("eeBadScFilter"))
    FilterNames.append(cms.InputTag("PBNRFilter"))
    FilterNames.append(cms.InputTag("HCALLaserEvtFilterList2012"))
    FilterNames.append(cms.InputTag("manystripclus53X"))
    FilterNames.append(cms.InputTag("toomanystripclus53X"))
    FilterNames.append(cms.InputTag("logErrorTooManyClusters"))
    FilterNames.append(cms.InputTag("RA2HONoiseFilter"))

    
    ## --- Setup WeightProducer -------------------------------------------
    from SemiLeptonicWVA.WeightProducer.getWeightProducer_cff import getWeightProducer
    process.WeightProducer = getWeightProducer(testFileName)
    process.WeightProducer.Lumi                       = cms.double(5000)
    process.WeightProducer.PU                         = cms.int32(0) # PU S10 3 for S10 2 for S7
    process.WeightProducer.FileNamePUDataDistribution = cms.string("NONE")
    print process.WeightProducer.PU

    from RecoBTag.Configuration.RecoBTag_cff import *
    from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import *
    process.slimmedJetsPFJetTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
      j2tParametersVX,
      jets = cms.InputTag("iterativeCone5PFJets")
    )
    process.slimmedJetsPFJetTracksAssociatorAtVertex.jets = "slimmedJets"
    process.slimmedJetsPFJetTracksAssociatorAtVertex.tracks = "generalTracks"
    
    process.slimmedJetsPFImpactParameterTagInfos = impactParameterTagInfos.clone()
    process.slimmedJetsPFImpactParameterTagInfos.jetTracks = "slimmedJetsPFJetTracksAssociatorAtVertex"
    process.slimmedJetsPFSecondaryVertexTagInfos = secondaryVertexTagInfos.clone()
    process.slimmedJetsPFSecondaryVertexTagInfos.trackIPTagInfos = "slimmedJetsPFImpactParameterTagInfos"
    
    process.slimmedJetsPFJetBtaggingSV = cms.Sequence(
    	process.slimmedJetsPFImpactParameterTagInfos *
    process.slimmedJetsPFSecondaryVertexTagInfos 
    )
    process.slimmedJetsPFJetsBtag = cms.Sequence(
    process.slimmedJetsPFJetTracksAssociatorAtVertex *
    process.slimmedJetsPFJetBtaggingSV
    )
    
    ## isotrack producer
    from SemiLeptonicWVA.Utils.trackIsolationMaker_cfi import trackIsolationFilter
    from SemiLeptonicWVA.Utils.trackIsolationMaker_cfi import trackIsolationCounter
    ## default
    process.IsolatedTracks = trackIsolationFilter.clone(
      doTrkIsoVeto= False,
      vertexInputTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
      pfCandidatesTag = cms.InputTag("packedPFCandidates"),
      dR_ConeSize         = cms.double(0.3),
      dz_CutValue         = cms.double(0.05),
      minPt_PFCandidate   = cms.double(15.0),
      isoCut              = cms.double(0.1),
      )
    process.CountIsoTracks = trackIsolationCounter.clone(
      src = cms.InputTag("IsolatedTracks"),
      minNumber = 1,
      )

    process.substructureSequence = cms.Sequence()
    process.softdrop_onMiniAOD = cms.Sequence()
    process.pruning_onMiniAOD = cms.Sequence()
    process.redoPatJets = cms.Sequence()
    process.puppi_onMiniAOD = cms.Sequence()
    process.redoPuppiJets = cms.Sequence()

    if (doAK8Reclustering):
        from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass

        process.chs = cms.EDFilter("CandPtrSelector",
                               src = cms.InputTag('packedPFCandidates'),
                               cut = cms.string('fromPV')
                               )

        process.NjettinessAK8 = cms.EDProducer("NjettinessAdder",
                            src=cms.InputTag("ak8PFJetsCHS"),
                            Njets=cms.vuint32(1,2,3,4),          # compute 1-, 2-, 3-, 4- subjettiness
                            # variables for measure definition : 
                            measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
                            beta = cms.double(1.0),              # CMS default is 1
                            R0 = cms.double( 0.8 ),              # CMS default is jet cone size
                            Rcutoff = cms.double( -999.0),       # not used by default
                            # variables for axes definition :
                            axesDefinition = cms.uint32( 6 ),    # CMS default is 1-pass KT axes
                            nPass = cms.int32(-999),             # not used by default
                            akAxesR0 = cms.double(-999.0)        # not used by default
                            )

        process.ak4PFJetsCHS = ak4PFJetsCHS.clone(src = 'chs')
        process.ak8PFJetsCHS = ak8PFJetsCHS.clone( src = 'chs', jetPtMin = 100.0 )

        process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'chs', jetPtMin = 100.0 )
        process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone()
        process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'chs', jetPtMin = 100.0 )
        process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone()

        process.substructureSequence+=process.chs
        process.substructureSequence+=process.ak8PFJetsCHS
        process.substructureSequence+=process.NjettinessAK8

        process.softdrop_onMiniAOD += process.ak8PFJetsCHSSoftDrop + process.ak8PFJetsCHSSoftDropMass
        process.pruning_onMiniAOD += process.ak8PFJetsCHSPruned + process.ak8PFJetsCHSPrunedMass

        ####### Redo pat jets sequence ##########
        from ExoDiBosonResonances.EDBRJets.redoPatJets_cff import patJetCorrFactorsAK8, patJetsAK8, selectedPatJetsAK8

        # Redo pat jets from ak8PFJetsCHS

        process.patJetCorrFactorsAK8 = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHS' )
        process.patJetsAK8 = patJetsAK8.clone( jetSource = 'ak8PFJetsCHS' )
        process.patJetsAK8.userData.userFloats.src = [ cms.InputTag("ak8PFJetsCHSPrunedMass"), cms.InputTag("ak8PFJetsCHSSoftDropMass"), cms.InputTag("NjettinessAK8:tau1"), cms.InputTag("NjettinessAK8:tau2"), cms.InputTag("NjettinessAK8:tau3")]
        process.patJetsAK8.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8") )
        process.selectedPatJetsAK8 = selectedPatJetsAK8.clone( cut = cms.string('pt > 20') )

        process.redoPatJets+=process.patJetCorrFactorsAK8
        process.redoPatJets+=process.patJetsAK8
        process.redoPatJets+=process.selectedPatJetsAK8

        if (reDoPruningAndSoftdrop):
            process.patJetCorrFactorsAK8Pruned = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHSPruned' )
            process.patJetsAK8Pruned = patJetsAK8.clone( jetSource = 'ak8PFJetsCHSPruned' )
            process.patJetsAK8Pruned.userData.userFloats.src = [ "" ]
            process.patJetsAK8Pruned.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8Pruned") )
            process.selectedPatJetsAK8Pruned = selectedPatJetsAK8.clone( 
                src = cms.InputTag('patJetsAK8Pruned'),
                cut = cms.string('pt > 20') 
                )

            process.redoPatJets+=process.patJetCorrFactorsAK8Pruned
            process.redoPatJets+=process.patJetsAK8Pruned
            process.redoPatJets+=process.selectedPatJetsAK8Pruned

            process.patJetCorrFactorsAK8Softdrop = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHSSoftDrop' )
            process.patJetsAK8Softdrop = patJetsAK8.clone( jetSource = 'ak8PFJetsCHSSoftDrop' )
            process.patJetsAK8Softdrop.userData.userFloats.src = [ "" ]
            process.patJetsAK8Softdrop.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8Softdrop") )
            process.selectedPatJetsAK8Softdrop = selectedPatJetsAK8.clone(
                src = cms.InputTag('patJetsAK8Softdrop'),
                cut = cms.string('pt > 20') 
                )

            process.redoPatJets+=process.patJetCorrFactorsAK8Softdrop
            process.redoPatJets+=process.patJetsAK8Softdrop
            process.redoPatJets+=process.selectedPatJetsAK8Softdrop

    if (doPuppi):

        from CommonTools.PileupAlgos.Puppi_cff import puppi
        from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi

        process.ak8PFJetsPuppi = ak4PFJetsPuppi.clone( rParam = 0.8 )
        process.puppi = puppi.clone( candName = cms.InputTag('packedPFCandidates'),
                             vertexName = cms.InputTag('offlineSlimmedPrimaryVertices'))

        process.puppi_onMiniAOD = cms.Sequence(process.puppi + process.ak8PFJetsPuppi)

        from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass

        process.NjettinessAK8 = cms.EDProducer("NjettinessAdder",
                            src=cms.InputTag("ak8PFJetsPuppi"),
                            Njets=cms.vuint32(1,2,3,4),          # compute 1-, 2-, 3-, 4- subjettiness
                            # variables for measure definition : 
                            measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
                            beta = cms.double(1.0),              # CMS default is 1
                            R0 = cms.double( 0.8 ),              # CMS default is jet cone size
                            Rcutoff = cms.double( -999.0),       # not used by default
                            # variables for axes definition :
                            axesDefinition = cms.uint32( 6 ),    # CMS default is 1-pass KT axes
                            nPass = cms.int32(-999),             # not used by default
                            akAxesR0 = cms.double(-999.0)        # not used by default
                            )

        process.ak4PFJetsPuppi = ak4PFJetsPuppi.clone(src = 'puppi')
        process.ak8PFJetsPuppi = process.ak8PFJetsPuppi.clone( src = 'puppi', jetPtMin = 100.0 )

        process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'puppi', jetPtMin = 100.0 )
        process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone(    
            matched = cms.InputTag("ak8PFJetsCHSPruned"),
            src = cms.InputTag("ak8PFJetsPuppi")
            )
        process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'puppi', jetPtMin = 100.0 )
        process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone(
            matched = cms.InputTag("ak8PFJetsCHSSoftDrop"),
            src = cms.InputTag("ak8PFJetsPuppi")
            )

        process.substructureSequence+=process.puppi
        process.substructureSequence+=process.ak8PFJetsPuppi
        process.substructureSequence+=process.NjettinessAK8

        process.softdrop_onMiniAOD += process.ak8PFJetsCHSSoftDrop + process.ak8PFJetsCHSSoftDropMass
        process.pruning_onMiniAOD += process.ak8PFJetsCHSPruned + process.ak8PFJetsCHSPrunedMass

        ####### Redo pat jets sequence ##########
        from ExoDiBosonResonances.EDBRJets.redoPatJets_cff import patJetCorrFactorsAK8, patJetsAK8, selectedPatJetsAK8

        # Redo pat jets from puppi AK8

        process.puppiJetCorrFactorsAK8 = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsPuppi',
                                                                     levels = cms.vstring('L2Relative',
                                                                                          'L3Absolute')
                                                                     )
        process.puppiJetsAK8 = patJetsAK8.clone( jetSource = 'ak8PFJetsPuppi' )
        process.puppiJetsAK8.userData.userFloats.src = [ cms.InputTag("ak8PFJetsCHSPrunedMass"), cms.InputTag("ak8PFJetsCHSSoftDropMass"), cms.InputTag("NjettinessAK8:tau1"), cms.InputTag("NjettinessAK8:tau2"), cms.InputTag("NjettinessAK8:tau3")]
        process.puppiJetsAK8.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("puppiJetCorrFactorsAK8") )
        process.selectedPuppiJetsAK8 = selectedPatJetsAK8.clone( src = 'puppiJetsAK8', cut = cms.string('pt > 20') )

        process.redoPuppiJets+=process.puppiJetCorrFactorsAK8
        process.redoPuppiJets+=process.puppiJetsAK8
        process.redoPuppiJets+=process.selectedPuppiJetsAK8

#######AK8 GEN JETS################

    process.substructureSequenceGen = cms.Sequence()
    process.softdropGen_onMiniAOD = cms.Sequence()
    process.pruningGen_onMiniAOD = cms.Sequence()
    process.redoGenJets = cms.Sequence()
#    process.puppi_onMiniAOD = cms.Sequence()

    if (genJetsAK8Reclustering and MC):    
        from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
        
        process.ak8GenJets = ak4GenJets.clone(src = cms.InputTag('packedGenParticles'),
                                          rParam = cms.double(0.8)
                                          )

        from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass

        process.NjettinessGenAK8 = cms.EDProducer("NjettinessAdder",
                            src=cms.InputTag("ak8GenJets"),
                            Njets=cms.vuint32(1,2,3,4),          # compute 1-, 2-, 3-, 4- subjettiness
                            # variables for measure definition : 
                            measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
                            beta = cms.double(1.0),              # CMS default is 1
                            R0 = cms.double( 0.8 ),              # CMS default is jet cone size
                            Rcutoff = cms.double( -999.0),       # not used by default
                            # variables for axes definition :
                            axesDefinition = cms.uint32( 6 ),    # CMS default is 1-pass KT axes
                            nPass = cms.int32(-999),             # not used by default
                            akAxesR0 = cms.double(-999.0)        # not used by default
                            )

        process.genParticlesForJets = cms.EDProducer("InputGenJetsParticleSelector",
                                             src = cms.InputTag("packedGenParticles"),
                                             ignoreParticleIDs = cms.vuint32(
                1000022,
                1000012, 1000014, 1000016,
                2000012, 2000014, 2000016,
                1000039, 5100039,
                4000012, 4000014, 4000016,
                9900012, 9900014, 9900016,
                39),
                                             partonicFinalState = cms.bool(False),
                                             excludeResonances = cms.bool(False),
                                             excludeFromResonancePids = cms.vuint32(12, 13, 14, 16),
                                             tausAsJets = cms.bool(False)
                                             )

        from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters

        process.ak8GenJetsPruned = ak4GenJets.clone(
            SubJetParameters,
            rParam = cms.double(0.8),
            src = cms.InputTag("genParticlesForJets"),
            usePruning = cms.bool(True),
            writeCompound = cms.bool(True),
            jetCollInstanceName=cms.string("SubJets")
            )

#        process.ak8GenJetsPruned = ak8PFJetsCHSPruned.clone( src = 'packedGenParticles', jetPtMin = 100.0 )
        process.ak8GenJetsPrunedMass = ak8PFJetsCHSPrunedMass.clone(    
            matched = cms.InputTag("ak8GenJetsPruned"),
            src = cms.InputTag("ak8GenJets")
            )

        process.ak8GenJetsSoftDrop = ak4GenJets.clone(
            SubJetParameters,
            rParam = cms.double(0.8),
            src = cms.InputTag("genParticlesForJets"),
            useSoftDrop = cms.bool(True),
            R0 = cms.double(0.8),
            beta = cms.double(0.0),
            writeCompound = cms.bool(True),
            jetCollInstanceName=cms.string("SubJets")
            )

        process.ak8GenJetsSoftDropMass = ak8PFJetsCHSSoftDropMass.clone(
            matched = cms.InputTag("ak8GenJetsSoftDrop"),
            src = cms.InputTag("ak8GenJets")
            )

        process.substructureSequenceGen+=process.genParticlesForJets
        process.substructureSequenceGen+=process.ak8GenJets
        process.substructureSequenceGen+=process.NjettinessGenAK8

        process.softdropGen_onMiniAOD += process.ak8GenJetsSoftDrop + process.ak8GenJetsSoftDropMass
        process.pruningGen_onMiniAOD += process.ak8GenJetsPruned + process.ak8GenJetsPrunedMass

        ####### Redo pat jets sequence ##########
        from ExoDiBosonResonances.EDBRJets.redoPatJets_cff import patJetCorrFactorsAK8, patJetsAK8, selectedPatJetsAK8

        # Redo pat jets from gen AK8

        process.genJetsAK8 = patJetsAK8.clone( jetSource = 'ak8GenJets' )
        process.genJetsAK8.userData.userFloats.src = [ cms.InputTag("ak8GenJetsPrunedMass"), cms.InputTag("ak8GenJetsSoftDropMass"), cms.InputTag("NjettinessGenAK8:tau1"), cms.InputTag("NjettinessGenAK8:tau2"), cms.InputTag("NjettinessGenAK8:tau3")]
        process.genJetsAK8.addJetCorrFactors = cms.bool(False)
        process.genJetsAK8.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("") )
        process.selectedGenJetsAK8 = selectedPatJetsAK8.clone( src = 'genJetsAK8', cut = cms.string('pt > 20') )

        process.redoGenJets+=process.genJetsAK8
        process.redoGenJets+=process.selectedGenJetsAK8


######### A4PF-nonCHS jets ###########

    from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets

    process.ak4PFJets = ak4PFJets.clone(src = "packedPFCandidates")

    from SemiLeptonicWVA.Utils.ak4pfjets_cfi import patJetCorrFactorsAK4, patJetsAK4

    process.patJetCorrFactorsAK4 = patJetCorrFactorsAK4.clone( src = 'ak4PFJets' )
    process.patJetsAK4 = patJetsAK4.clone( jetSource = 'ak4PFJets' )


    #
    # Set up electron ID (VID framework)
    #
    from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
    # turn on VID producer, indicate data format to be
    # DataFormat.AOD or DataFormat.MiniAOD, as appropriate
    dataFormat=DataFormat.MiniAOD
    switchOnVIDElectronIdProducer(process,dataFormat)

    process.egmGsfElectronIDSequence = cms.Sequence(process.egmGsfElectronIDs)

    # define which IDs we want to produce
    my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
                     'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff']
    #add them to the VID producer
    for idmod in my_id_modules:
        setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)

    # Producers
    from SemiLeptonicWVA.Utils.electron_cfi import electron
    process.Electrons = electron.clone(
        VertexTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
        EleTag = cms.InputTag("slimmedElectrons"),
        MinPt = cms.double(-1),
        RhoTag = cms.InputTag("fixedGridRhoFastjetAll"),
        eleVetoIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-veto"),
        eleLooseIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-loose"),
        eleMediumIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-medium"),
        eleTightIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-tight"),
        eleHEEPIdMap = cms.InputTag("egmGsfElectronIDs:heepElectronID-HEEPV60")
    )

    # Add in Photons:
    switchOnVIDPhotonIdProducer(process, dataFormat)
    my_id_modules = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff']
    for idmod in my_id_modules:
        setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection)
    from SemiLeptonicWVA.Utils.photon_cfi import photon
    process.Photons = photon.clone(
        PhoTag = cms.InputTag("slimmedPhotons"),
        phoLooseIdMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-loose"),
        phoMediumIdMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-medium"),
        phoTightIdMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-tight"),
        phoTightIdFullInfoMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-tight")
    )

    from SemiLeptonicWVA.Utils.muon_cfi import muon
    process.Muons = muon.clone(
        VertexTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
        MuTag = cms.InputTag("slimmedMuons"),
        MinPt = cms.double(-1),
        RhoTag = cms.InputTag("fixedGridRhoFastjetAll")
    )
    from SemiLeptonicWVA.Utils.subJetSelection_cfi import SubJetSelection
    process.HTJets = SubJetSelection.clone(
    JetTag  = cms.InputTag('slimmedJets'),
    MinPt								  = cms.double(50),
    MaxEta								  = cms.double(2.5),
    )
    from SemiLeptonicWVA.Utils.htdouble_cfi import htdouble
    process.HT = htdouble.clone(
    JetTag  = cms.InputTag('HTJets'),
    )
    from SemiLeptonicWVA.Utils.njetint_cfi import njetint
    process.NJets = njetint.clone(
    JetTag  = cms.InputTag('HTJets'),
    )
    from SemiLeptonicWVA.Utils.btagint_cfi import btagint
    process.BTags = btagint.clone(
    JetTag  = cms.InputTag('HTJets'),
    BTagInputTag	        = cms.string('combinedInclusiveSecondaryVertexV2BJetTags'),
    BTagCutValue					= cms.double(0.679)
    )
    from SemiLeptonicWVA.Utils.subJetSelection_cfi import SubJetSelection
    process.MHTJets = SubJetSelection.clone(
    JetTag  = cms.InputTag('slimmedJets'),
    MinPt								  = cms.double(30),
    MaxEta								  = cms.double(5.0),
    )
    process.MHTJetsAK8 = SubJetSelection.clone(
    JetTag  = cms.InputTag('slimmedJetsAK8'),
    MinPt								  = cms.double(30),
    MaxEta								  = cms.double(5.0),
    )
    from SemiLeptonicWVA.Utils.jetproperties_cfi import jetproperties
    process.MHTJetsProperties = jetproperties.clone(
    JetTag  = cms.InputTag('MHTJets'),
    doJEC  = cms.bool(doJECCorrection),
    L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK4PFchs.txt"),
    L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK4PFchs.txt"),
    L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK4PFchs.txt"),
    L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK4PFchs.txt"),
    )
    from SemiLeptonicWVA.Utils.jetpropertiesAK8_cfi import jetpropertiesAK8
    process.MHTJetsPropertiesAK8 = jetpropertiesAK8.clone(
    JetTag  = cms.InputTag('MHTJetsAK8'),
    puppiJetTag = cms.InputTag('selectedPuppiJetsAK8'),
    doJEC  = cms.bool(doJECCorrection),
    doReclusteringForPrunedAndSoftdrop = cms.bool(reDoPruningAndSoftdrop),
    L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK8PFchs.txt"),
    L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK8PFchs.txt"),
    L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK8PFchs.txt"),
    L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK8PFchs.txt"),
    )
    if (reDoPruningAndSoftdrop):
        process.MHTJetsPropertiesAK8.prunedJetTag  = cms.InputTag('selectedPatJetsAK8Pruned')
        process.MHTJetsPropertiesAK8.softdropJetTag  = cms.InputTag('selectedPatJetsAK8Softdrop')
    else:
        process.MHTJetsPropertiesAK8.prunedJetTag  = cms.InputTag('slimmedJetsAK8')
        process.MHTJetsPropertiesAK8.softdropJetTag  = cms.InputTag('slimmedJetsAK8')

    if (MC):
        process.MHTJetsProperties.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK4PFchs.txt")
        process.MHTJetsProperties.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK4PFchs.txt")
        process.MHTJetsProperties.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK4PFchs.txt")
        process.MHTJetsProperties.L2L3File = cms.string("NONE")
        process.MHTJetsPropertiesAK8.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK8PFchs.txt")
        process.MHTJetsPropertiesAK8.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK8PFchs.txt")
        process.MHTJetsPropertiesAK8.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK8PFchs.txt")
        process.MHTJetsPropertiesAK8.L2L3File = cms.string("NONE")

    from SemiLeptonicWVA.Utils.jetproperties_cfi import jetproperties
    process.JetsProperties = jetproperties.clone(
    JetTag  = cms.InputTag('slimmedJets'),
    MinPt = cms.double(-1),
    doJEC  = cms.bool(doJECCorrection),
    L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK4PFchs.txt"),
    L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK4PFchs.txt"),
    L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK4PFchs.txt"),
    L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK4PFchs.txt"),
    )
    from SemiLeptonicWVA.Utils.jetpropertiesAK8_cfi import jetpropertiesAK8
    process.JetsPropertiesAK8 = jetpropertiesAK8.clone(
    JetTag  = cms.InputTag('slimmedJetsAK8'),
    MinPt = cms.double(-1),
    doJEC  = cms.bool(doJECCorrection),
    doReclusteringForPrunedAndSoftdrop = cms.bool(reDoPruningAndSoftdrop),
    L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK8PFchs.txt"),
    L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK8PFchs.txt"),
    L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK8PFchs.txt"),
    L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK8PFchs.txt"),
    )
    if (reDoPruningAndSoftdrop):
        process.JetsPropertiesAK8.prunedJetTag  = cms.InputTag('selectedPatJetsAK8Pruned')
        process.JetsPropertiesAK8.softdropJetTag  = cms.InputTag('selectedPatJetsAK8Softdrop')
    else:
        process.JetsPropertiesAK8.prunedJetTag  = cms.InputTag('slimmedJetsAK8')
        process.JetsPropertiesAK8.softdropJetTag  = cms.InputTag('slimmedJetsAK8')
    if (MC):
        process.JetsProperties.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK4PFchs.txt")
        process.JetsProperties.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK4PFchs.txt")
        process.JetsProperties.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK4PFchs.txt")
        process.JetsProperties.L2L3File = cms.string("NONE")
        process.JetsPropertiesAK8.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK8PFchs.txt")
        process.JetsPropertiesAK8.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK8PFchs.txt")
        process.JetsPropertiesAK8.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK8PFchs.txt")
        process.JetsPropertiesAK8.L2L3File = cms.string("NONE")

    if doAK8Reclustering:
        process.JetsPropertiesAK8.JetTag = cms.InputTag('selectedPatJetsAK8')
    if doPuppi:
        process.JetsPropertiesAK8.JetTag = cms.InputTag('selectedPuppiJetsAK8')
    from SemiLeptonicWVA.Utils.mhtdouble_cfi import mhtdouble
    process.MHT = mhtdouble.clone(
    JetTag  = cms.InputTag('MHTJets'),
    )
    from SemiLeptonicWVA.Utils.deltaphidouble_cfi import deltaphidouble
    process.DeltaPhi = deltaphidouble.clone(
    DeltaPhiJets  = cms.InputTag('HTJets'),
    MHTJets  = cms.InputTag("MHTJets"),
    )
    from SemiLeptonicWVA.Utils.metdouble_cfi import metdouble
    process.MET = metdouble.clone(
    METTag  = cms.InputTag("slimmedMETs"),
    JetTag  = cms.InputTag('slimmedJets'),
    doJEC  = cms.bool(doJECCorrection),
    L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK4PFchs.txt"),
    L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK4PFchs.txt"),
    L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK4PFchs.txt"),
    L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK4PFchs.txt"),
    MuTag = cms.InputTag("slimmedMuons"),
    RhoTag = cms.InputTag("fixedGridRhoFastjetAll"),
    corrMet = cms.bool(doJECCorrection),
    )

    if (MC):
        process.MET.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK4PFchs.txt")
        process.MET.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK4PFchs.txt")
        process.MET.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK4PFchs.txt")
        process.MET.L2L3File = cms.string("NONE")

    from SemiLeptonicWVA.Utils.primaryverticies_cfi import primaryverticies
    process.NVtx = primaryverticies.clone(
    VertexCollection  = cms.InputTag('offlineSlimmedPrimaryVertices'),
    )
    from SemiLeptonicWVA.Utils.genLeptonRecoCand_cfi import genLeptonRecoCand
    process.GenLeptons = genLeptonRecoCand.clone(
    PrunedGenParticleTag  = cms.InputTag("prunedGenParticles"),
    )
    from SemiLeptonicWVA.Utils.genJet_cfi import genJet
    process.GenJets = genJet.clone(
                            GenJetCollTag  = cms.InputTag("slimmedGenJets"),
                            )
    from SemiLeptonicWVA.Utils.genJetAK8_cfi import genJetAK8
    process.GenJetsAK8 = genJetAK8.clone(
                            GenJetCollTag  = cms.InputTag("selectedGenJetsAK8"),
                            )
    if not MC:
        process.GenLeptons = cms.Sequence()
        process.GenJets = cms.Sequence()
        process.GenJetsAK8 = cms.Sequence()



    ##### MET filters #####

    #### -----> MET Filter Flags from MiniAOD/TWiki <----- ####
    import HLTrigger.HLTfilters.triggerResultsFilter_cfi as hlt
    process.metBits_miniAOD = hlt.triggerResultsFilter.clone()
    # default is to use the latest process (but can set different process through Commandline Args)
    process.metBits_miniAOD.hltResults = cms.InputTag('TriggerResults::%s'%METFiltersProcess) 
    process.metBits_miniAOD.l1tResults = cms.InputTag('')
    #currently configured for CSCTightHaloFilter + GoodVertices
    met_bits = ['(Flag_CSCTightHaloFilter)','(Flag_goodVertices)','(Flag_eeBadScFilter)']
    bitsexpr = ' AND '.join(met_bits)
    process.metBits_miniAOD.triggerConditions = cms.vstring(bitsexpr)

    #### -----> HBHE noise filter <----- ####
    process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi')
    process.HBHENoiseFilterResultProducer.minZeros = cms.int32(99999)
    process.HBHENoiseFilterResultProducer.IgnoreTS4TS5ifJetInLowBVRegion=cms.bool(False) 
    process.HBHENoiseFilterResultProducer.defaultDecision = cms.string("HBHENoiseFilterResultRun2Loose")
    
    ########## save flags for filters
    from SemiLeptonicWVA.Utils.filterproducer_cfi import filterProducer
    process.FilterProducer = filterProducer.clone(
                                 noiseFilterTag = cms.InputTag("TriggerResults"),
                                 HBHENoiseFilter_Selector_ = cms.string("Flag_HBHENoiseFilter"),
                                 HBHENoiseIsoFilter_Selector_ = cms.string("Flag_HBHENoiseIsoFilter"),
                                 CSCHaloNoiseFilter_Selector_ = cms.string("Flag_CSCTightHaloFilter"),
                                 GoodVtxNoiseFilter_Selector_ = cms.string("Flag_goodVertices"),
                                 EEBadScNoiseFilter_Selector_ = cms.string("Flag_eeBadScFilter"),
                                 HBHENoiseFilterLoose = cms.InputTag("HBHENoiseFilterResultProducer", "HBHENoiseFilterResultRun2Loose"),
                                 HBHENoiseFilterTight = cms.InputTag("HBHENoiseFilterResultProducer", "HBHENoiseFilterResultRun2Tight"),
                                 HBHENoiseIsoFilter = cms.InputTag("HBHENoiseFilterResultProducer", "HBHEIsoNoiseFilterResult")
                                 )


    RecoCandVector = cms.vstring()
    RecoCandVector.extend(['IsolatedTracks']) # basic muons electrons and isoalted tracks
    RecoCandVector.extend(['GenLeptons:Boson(GenBoson)|GenLeptons:BosonPDGId(I_GenBosonPDGId)','GenLeptons:Muon(GenMu)|GenLeptons:MuonTauDecay(I_GenMuFromTau)' ,'GenLeptons:Electron(GenElec)|GenLeptons:ElectronTauDecay(I_GenElecFromTau)','GenLeptons:Tau(GenTau)|GenLeptons:TauHadronic(I_GenTauHad)','GenLeptons:Neutrino(GenNu)'] ) # gen information on leptons
    RecoCandVector.extend(['GenJets:GenJet(GenJets)'] ) # gen information on jets
    RecoCandVector.extend(['GenJetsAK8:GenJetAK8(GenJetsAK8)|GenJetsAK8:GenAK8prunedMass(F_prunedMass)|GenJetsAK8:GenAK8softdropMass(F_softdropMass)|GenJetsAK8:GenAK8tau1(F_tau1)|GenJetsAK8:GenAK8tau2(F_tau2)|GenJetsAK8:GenAK8tau3(F_tau3)'] ) # gen information on AK8 jets
    RecoCandVector.extend(['JetsProperties(Jets)|JetsProperties:bDiscriminatorCSV(F_bDiscriminatorCSV)|JetsProperties:bDiscriminatorICSV(F_bDiscriminatorICSV)|JetsProperties:chargedEmEnergyFraction(F_chargedEmEnergyFraction)|JetsProperties:chargedHadronEnergyFraction(F_chargedHadronEnergyFraction)|JetsProperties:chargedHadronMultiplicity(I_chargedHadronMultiplicity)|JetsProperties:electronMultiplicity(I_electronMultiplicity)|JetsProperties:jetArea(F_jetArea)|JetsProperties:muonEnergyFraction(F_muonEnergyFraction)|JetsProperties:muonMultiplicity(I_muonMultiplicity)|JetsProperties:neutralEmEnergyFraction(F_neutralEmEnergyFraction)|JetsProperties:neutralHadronMultiplicity(I_neutralHadronMultiplicity)|JetsProperties:photonEnergyFraction(F_photonEnergyFraction)|JetsProperties:photonMultiplicity(I_photonMultiplicity)|JetsProperties:isLooseJetId(b_isLooseJetId)|JetsProperties:isTightJetId(b_isTightJetId)|JetsProperties:isTightLepVetoJetId(b_isTightLepVetoJetId)|JetsProperties:PtCorr(F_PtCorr)|JetsProperties:EtaCorr(F_EtaCorr)|JetsProperties:PhiCorr(F_PhiCorr)|JetsProperties:ECorr(F_ECorr)'] ) # jet information on various variables
    RecoCandVector.extend(['JetsPropertiesAK8(AK8Jets)|JetsPropertiesAK8:AK8bDiscriminatorCSV(F_bDiscriminatorCSV)|JetsPropertiesAK8:AK8bDiscriminatorICSV(F_bDiscriminatorICSV)|JetsPropertiesAK8:AK8chargedEmEnergyFraction(F_chargedEmEnergyFraction)|JetsPropertiesAK8:AK8chargedHadronEnergyFraction(F_chargedHadronEnergyFraction)|JetsPropertiesAK8:AK8chargedHadronMultiplicity(I_chargedHadronMultiplicity)|JetsPropertiesAK8:AK8electronMultiplicity(I_electronMultiplicity)|JetsPropertiesAK8:AK8jetArea(F_jetArea)|JetsPropertiesAK8:AK8muonEnergyFraction(F_muonEnergyFraction)|JetsPropertiesAK8:AK8muonMultiplicity(I_muonMultiplicity)|JetsPropertiesAK8:AK8neutralEmEnergyFraction(F_neutralEmEnergyFraction)|JetsPropertiesAK8:AK8neutralHadronMultiplicity(I_neutralHadronMultiplicity)|JetsPropertiesAK8:AK8photonEnergyFraction(F_photonEnergyFraction)|JetsPropertiesAK8:AK8photonMultiplicity(I_photonMultiplicity)|JetsPropertiesAK8:AK8prunedMass(F_prunedMass)|JetsPropertiesAK8:AK8softDropMass(F_softDropMass)|JetsPropertiesAK8:AK8trimmedMass(F_trimmedMass)|JetsPropertiesAK8:AK8filteredMass(F_filteredMass)|JetsPropertiesAK8:AK8tau1(F_tau1)|JetsPropertiesAK8:AK8tau2(F_tau2)|JetsPropertiesAK8:AK8tau3(F_tau3)|JetsPropertiesAK8:AK8isLooseJetId(b_AK8isLooseJetId)|JetsPropertiesAK8:AK8isTightJetId(b_AK8isTightJetId)|JetsPropertiesAK8:AK8isTightLepVetoJetId(b_AK8isTightLepVetoJetId)|JetsPropertiesAK8:PtCorr(F_PtCorr)|JetsPropertiesAK8:EtaCorr(F_EtaCorr)|JetsPropertiesAK8:PhiCorr(F_PhiCorr)|JetsPropertiesAK8:ECorr(F_ECorr)'] ) # AK8 jet information on various variables
# 
    RecoCandVector.extend(['Electrons(Electrons)|Electrons:charge(I_charge)|Electrons:isHEEP(b_isHEEP)|Electrons:type(I_type)|Electrons:mass(F_mass)|Electrons:pfDeltaCorrRelIso(F_pfDeltaCorrRelIso)|Electrons:pfRhoCorrRelIso04(F_pfRhoCorrRelIso04)|Electrons:pfRhoCorrRelIso03(F_pfRhoCorrRelIso03)|Electrons:pfRelIso(F_pfRelIso)|Electrons:photonIso(F_photonIso)|Electrons:neutralHadIso(F_neutralHadIso)|Electrons:chargedHadIso(F_chargedHadIso)|Electrons:trackIso(F_trackIso)|Electrons:isLoose(b_isLoose)|Electrons:isMedium(b_isMedium)|Electrons:isTight(b_isTight)|Electrons:SCEnergy(F_SCEnergy)|Electrons:deltaEtaSCTracker(F_deltaEtaSCTracker)|Electrons:deltaPhiSCTracker(F_deltaPhiSCTracker)|Electrons:sigmaIetaIeta(F_sigmaIetaIeta)|Electrons:sigmaIphiIphi(F_sigmaIphiIphi)'] ) # electron information on various variables
    RecoCandVector.extend(['Muons(Muons)|Muons:charge(I_charge)|Muons:isHighPt(b_isHighPt)|Muons:type(I_type)|Muons:mass(F_mass)|Muons:pfDeltaCorrRelIso(F_pfDeltaCorrRelIso)|Muons:pfRelIso(F_pfRelIso)|Muons:photonIso(F_photonIso)|Muons:neutralHadIso(F_neutralHadIso)|Muons:chargedHadIso(F_chargedHadIso)|Muons:trackIso(F_trackIso)|Muons:isLoose(b_isLoose)|Muons:isMedium(b_isMedium)|Muons:isTight(b_isTight)|Muons:isPFMuon(b_isPFMuon)'] ) # muon information on various variables
    RecoCandVector.extend(['Photons(Photons)|Photons:isLoose(b_isLoose)|Photons:isMedium(b_isMedium)|Photons:isTight(b_isTight)|Photons:minPt(F_minPt)|Photons:phoSCEtaMultiRange(F_phoSCEtaMultiRange)|Photons:phoSingleTowerHadOverEm(F_phoSingleTowerHadOverEm)|Photons:phoFull5x5SigmaIEtaIEta(F_phoFull5x5SigmaIEtaIEta)|Photons:phoAnyPFIsoWithEA(F_phoAnyPFIsoWithEA)|Photons:phoAnyPFIsoWithEAAndExpoScaling(F_phoAnyPFIsoWithEAAndExpoScaling)|Photons:phoAnyPFIsoWithEA1(F_phoAnyPFIsoWithEA1)|Photons:hasPixelSeed(b_hasPixelSeed)|Photons:passElectronVeto(b_passElectronVeto)|Photons:photonIso(F_photonIso)|Photons:neutralHadIso(F_neutralHadIso)|Photons:chargedHadIso(F_chargedHadIso)|Photons:puChargedHadIso(F_puChargedHadIso)|Photons:sigmaIetaIeta(F_sigmaIetaIeta)'] ) # photon information on various variables

    from SemiLeptonicWVA.TreeMaker.treeMaker import TreeMaker
    process.TreeMaker2 = TreeMaker.clone(
    	TreeName          = cms.string("PreSelection"),
    	VarsRecoCand = RecoCandVector,
    	VarsDouble  	  = cms.vstring('WeightProducer:weight(Weight)','MHT','MET:Pt(METPt)','MET:Phi(METPhi)','MET:PtRaw(METPtRaw)','MET:PhiRaw(METPhiRaw)','MET:CaloMetPt(CaloMetPt)','MET:CaloMetPhi(CaloMetPhi)','HT','DeltaPhi:DeltaPhi1(DeltaPhi1)','DeltaPhi:DeltaPhi2(DeltaPhi2)','DeltaPhi:DeltaPhi3(DeltaPhi3)','GenEventInfo:genEventWeight(genEventWeight)','GenEventInfo:PUWeight(PUWeight)','GenEventInfo:originalWeight(originalWeight)'),
    	VarsInt = cms.vstring('NJets','BTags','NVtx','GenEventInfo:npT(npT)','FilterProducer:passFilterHBHE(passFilterHBHE)','FilterProducer:passFilterHBHEIso(passFilterHBHEIso)','FilterProducer:passFilterCSCHalo(passFilterCSCHalo)','FilterProducer:passFilterGoodVtx(passFilterGoodVtx)','FilterProducer:passFilterEEBadSC(passFilterEEBadSC)','FilterProducer:passFilterHBHELooseRerun(passFilterHBHELooseRerun)','FilterProducer:passFilterHBHETightRerun(passFilterHBHETightRerun)','FilterProducer:passFilterHBHEIsoRerun(passFilterHBHEIsoRerun)'),
        debug = debug,
    	)

    process.TreeMaker2.VarsDouble.extend(['MET:PtDefault(METPtDefault)','MET:PhiDefault(METPhiDefault)','MET:PtType1(METPtType1)','MET:PhiType1(METPhiType1)','MET:PtType1XYSmear(METPtType1XYSmear)','MET:PhiType1XYSmear(METPhiType1XYSmear)','MET:PtType1Smear(METPtType1Smear)','MET:PhiType1Smear(METPhiType1Smear)','MET:PtType1XY(METPtType1XY)','MET:PhiType1XY(METPhiType1XY)'])
    process.TreeMaker2.VectorBool.extend(['TriggerProducer:TriggerPass'])
    process.TreeMaker2.VectorInt.extend(['TriggerProducer:TriggerPrescales'])
    process.TreeMaker2.VectorDouble.extend(['GenEventInfo:AQGCweights'])
    process.TreeMaker2.VectorString.extend(['TriggerProducer:TriggerNames'])

    ## --- Final paths ----------------------------------------------------
    process.out = cms.OutputModule("PoolOutputModule",
                                   fileName = cms.untracked.string("output.root"),
                                   )
        
    process.dump = cms.EDAnalyzer("EventContentAnalyzer")
    process.WriteTree = cms.Path(
      process.TriggerProducer*
      ### MET Filter Bits
      process.HBHENoiseFilterResultProducer*
      process.FilterProducer* #this now contains all the met filters
      ### rest of ntupling starts after here
      process.filterSeq *
      process.GenEventInfo *
      process.Muons *
      process.egmGsfElectronIDSequence*
      process.Electrons *
      process.egmPhotonIDSequence *
      process.Photons *
      process.WeightProducer *
      process.IsolatedTracks *
      process.substructureSequenceGen *
      process.softdropGen_onMiniAOD *
      process.pruningGen_onMiniAOD *
      process.redoGenJets*
      process.GenJetsAK8 *
      process.puppi_onMiniAOD *
      process.substructureSequence *
      process.softdrop_onMiniAOD *
      process.pruning_onMiniAOD *
      process.redoPatJets*
      process.redoPuppiJets*
      process.HTJets *
      process.HT *
      process.NJets *
      process.BTags *
      process.MHTJets *
      process.MHTJetsProperties *
      process.JetsProperties *
      process.MHTJetsAK8 *
      process.MHTJetsPropertiesAK8 *
      process.JetsPropertiesAK8 *
      process.MHT *
      process.MET *
      process.DeltaPhi *
      process.NVtx *
      process.GenLeptons *
      process.GenJets *
      process.TreeMaker2

        )
コード例 #40
0
ファイル: RecoGenJets_cff.py プロジェクト: hroskes/cmssw
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
from RecoJets.JetProducers.ak8GenJets_cfi import ak8GenJets

from RecoHI.HiJetAlgos.HiGenJets_cff import *


ak4GenJetsNoNu = ak4GenJets.clone( src = cms.InputTag("genParticlesForJetsNoNu") )
ak8GenJetsNoNu = ak8GenJets.clone( src = cms.InputTag("genParticlesForJetsNoNu") )

ak4GenJetsNoMuNoNu = ak4GenJets.clone( src = cms.InputTag("genParticlesForJetsNoMuNoNu") )
ak8GenJetsNoMuNoNu = ak8GenJets.clone( src = cms.InputTag("genParticlesForJetsNoMuNoNu") )

recoGenJetsTask = cms.Task(ak4GenJets,
                           ak8GenJets,
                           ak4GenJetsNoNu,
                           ak8GenJetsNoNu
                           )
recoGenJets  = cms.Sequence(recoGenJetsTask)

recoAllGenJets=cms.Sequence(ak4GenJets+
                            ak8GenJets)

recoAllGenJetsNoNu=cms.Sequence(ak4GenJetsNoNu+
                                ak8GenJetsNoNu)

recoAllGenJetsNoMuNoNu=cms.Sequence(ak4GenJetsNoMuNoNu+
                                    ak8GenJetsNoMuNoNu)
コード例 #41
0
ファイル: makeJets_cff.py プロジェクト: jingli90/JMEValidator
import FWCore.ParameterSet.Config as cms
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets

#PFCHS
pfCHS = cms.EDFilter("CandPtrSelector",
                     src=cms.InputTag("packedPFCandidates"),
                     cut=cms.string("fromPV"))

# make GEN jets
AK4GenJets = ak4GenJets.clone(rParam=0.4)
AK4GenJets.src = cms.InputTag('packedGenParticles')

AK8GenJets = ak4GenJets.clone(rParam=0.8)
AK8GenJets.src = cms.InputTag('packedGenParticles')

AK4PFchsJets = ak4PFJets.clone()
AK4PFchsJets.src = cms.InputTag('pfCHS', '', 'JRA')

AK8PFchsJets = ak4PFJets.clone(rParam=0.8)
AK8PFchsJets.src = cms.InputTag('pfCHS', '', 'JRA')

AK4PFJetsPuppi = ak4PFJetsPuppi.clone()
AK4PFJetsPuppi.src = cms.InputTag('puppi', '', 'JRA')  #PFJetParameters

AK8PFJetsPuppi = ak4PFJetsPuppi.clone(rParam=0.8)
AK8PFJetsPuppi.src = cms.InputTag('puppi', '', 'JRA')  #PFJetParameters
コード例 #42
0
ファイル: tools.py プロジェクト: smoortga/CATTools_KoreaBE
def genHFTool(process, useMiniAOD=True):
    # Setting input particle collections to be used by the tools
    genParticleCollection = ''
    genJetCollection = 'ak4GenJetsCustom'
    if useMiniAOD:
        genParticleCollection = 'prunedGenParticles'
        genJetCollection = 'slimmedGenJets'
    else:
        genParticleCollection = 'genParticles'
        ## producing a subset of genParticles to be used for jet reclustering
        from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu
        process.genParticlesForJetsCustom = genParticlesForJetsNoNu.clone(
            src=genParticleCollection)
        # Producing own jets for testing purposes
        from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
        process.ak4GenJetsCustom = ak4GenJets.clone(
            src='genParticlesForJetsCustom',
            rParam=cms.double(0.4),
            jetAlgorithm=cms.string("AntiKt"))

    # Supplies PDG ID to real name resolution of MC particles
    process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

    # Ghost particle collection used for Hadron-Jet association
    # MUST use proper input particle collection
    process.load("PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi")
    process.selectedHadronsAndPartons.particles = genParticleCollection

    ## Input particle collection for matching to gen jets (partons + leptons)
    # MUST use use proper input jet collection: the jets to which hadrons should be associated
    # rParam and jetAlgorithm MUST match those used for jets to be associated with hadrons
    # More details on the tool: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition
    from PhysicsTools.JetMCAlgos.AK4PFJetsMCFlavourInfos_cfi import ak4JetFlavourInfos
    process.genJetFlavourInfos = ak4JetFlavourInfos.clone(
        jets=genJetCollection)

    #for cmssw_7_6_X, not ready for 74x
    #process.load("PhysicsTools.JetMCAlgos.GenHFHadronMatcher_cff")
    #added the 3-lines instead of GenHFHadronMatcher_cff
    from PhysicsTools.JetMCAlgos.GenHFHadronMatcher_cfi import matchGenHFHadron
    process.matchGenBHadron = matchGenHFHadron.clone(flavour=5)
    process.matchGenCHadron = matchGenHFHadron.clone(flavour=4)
    ## Plugin for analysing B hadrons
    # MUST use the same particle collection as in selectedHadronsAndPartons
    process.matchGenBHadron.genParticles = genParticleCollection
    process.matchGenBHadron.jetFlavourInfos = "genJetFlavourInfos"
    ## Plugin for analysing C hadrons
    # MUST use the same particle collection as in selectedHadronsAndPartons
    process.matchGenCHadron.genParticles = genParticleCollection
    process.matchGenCHadron.jetFlavourInfos = "genJetFlavourInfos"

    process.load("TopQuarkAnalysis.TopTools.GenTtbarCategorizer_cfi")
    process.GenTtbarCategories = process.categorizeGenTtbar.clone(
        genJets=cms.InputTag(genJetCollection), genJetPtMin=cms.double(20.))
    process.GenTtbarCategories30 = process.categorizeGenTtbar.clone(
        genJets=cms.InputTag(genJetCollection), genJetPtMin=cms.double(30.))
    process.GenTtbarCategories40 = process.categorizeGenTtbar.clone(
        genJets=cms.InputTag(genJetCollection), genJetPtMin=cms.double(40.))

    process.catGenTops.genJetLabel = genJetCollection
    process.catGenTops.mcParticleLabel = genParticleCollection
コード例 #43
0
	process.updatedPatJetsTransientCorrectedDeepFlavour.addTagInfos = cms.bool(True) 
	process.updatedPatJetsTransientCorrectedDeepFlavour.addBTagInfo = cms.bool(True)
else:
	raise ValueError('I could not find updatedPatJetsTransientCorrectedDeepFlavour to embed the tagInfos, please check the cfg')


# QGLikelihood
process.load("DeepNTuples.DeepNtuplizer.QGLikelihood_cfi")
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource", "QGPoolDBESSource")
process.load('RecoJets.JetProducers.QGTagger_cfi')
process.QGTagger.srcJets   = cms.InputTag("selectedUpdatedPatJetsDeepFlavour")
process.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs')


from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsWithNu = ak4GenJets.clone(src = 'packedGenParticles')
 
 ## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedGenParticles"), cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
 ## Define GenJets
process.ak4GenJetsRecluster = ak4GenJets.clone(src = 'packedGenParticlesForJetsNoNu')
 
 
process.patGenJetMatchWithNu = cms.EDProducer("GenJetMatcher",  # cut on deltaR; pick best by deltaR           
    src         = cms.InputTag("selectedUpdatedPatJetsDeepFlavour"),      # RECO jets (any View<Jet> is ok) 
    matched     = cms.InputTag("ak4GenJetsWithNu"),        # GEN jets  (must be GenJetCollection)              
    mcPdgId     = cms.vint32(),                      # n/a   
    mcStatus    = cms.vint32(),                      # n/a   
    checkCharge = cms.bool(False),                   # n/a   
    maxDeltaR   = cms.double(0.4),                   # Minimum deltaR for the match   
    #maxDPtRel   = cms.double(3.0),                  # Minimum deltaPt/Pt for the match (not used in GenJetMatcher)                     
コード例 #44
0
ファイル: example_ei.py プロジェクト: yjcho10/cmssw
    veto=cms.InputTag("selectedElectrons"))

process.pfNoMuon = cms.EDProducer("CandPtrProjector",
                                  src=cms.InputTag("packedPFCandidates"),
                                  veto=cms.InputTag("selectedMuons"))
process.pfNoElectrons = cms.EDProducer("CandPtrProjector",
                                       src=cms.InputTag("pfNoMuon"),
                                       veto=cms.InputTag("selectedElectrons"))

process.ak4PFJets = ak4PFJets.clone(
    src='pfNoElectrons', doAreaFastjet=True
)  # no idea while doArea is false by default, but it's True in RECO so we have to set it
process.ak4PFJetsCHS = ak4PFJets.clone(
    src='pfNoElectronsCHS', doAreaFastjet=True
)  # no idea while doArea is false by default, but it's True in RECO so we have to set it
process.ak4GenJets = ak4GenJets.clone(src='packedGenParticles')

# The following is make patJets, but EI is done with the above
process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
process.load("Configuration.EventContent.EventContent_cff")
process.load('Configuration.StandardSequences.Geometry_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_cff')
process.load(
    'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'POSTLS172_V3::All'

from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
addJetCollection(process,
                 postfix="",
                 labelName='AK4PFCHS',
                 jetSource=cms.InputTag('ak4PFJetsCHS'),
コード例 #45
0
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
from RecoMET.METProducers.PFMET_cfi import pfMet

## --- Selection sequences ---------------------------------------------
# leptons
process.load("PhysicsTools.PatAlgos.selectionLayer1.muonCountFilter_cfi")
process.load("PhysicsTools.PatAlgos.selectionLayer1.electronCountFilter_cfi")

## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("packedGenParticles"),
    cut=cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
## Define GenJets
from RecoJets.JetProducers.ak5GenJets_cfi import ak5GenJets
process.ak4GenJetsNoNu = ak4GenJets.clone(src='packedGenParticlesForJetsNoNu')

#do projections
process.pfCHS = cms.EDFilter("CandPtrSelector",
                             src=cms.InputTag("packedPFCandidates"),
                             cut=cms.string("fromPV"))

process.ak4PFJetsCHS = ak4PFJets.clone(
    src='pfCHS', doAreaFastjet=True
)  # no idea while doArea is false by default, but it's True in RECO so we have to set it
process.ak4GenJets = ak4GenJets.clone(src='packedGenParticles', rParam=0.4)

process.pfMet = pfMet.clone(src="packedPFCandidates")
process.pfMet.calculateSignificance = False  # this can't be easily implemented on packed PF candidates at the moment

process.load("SusyAnaTools.SkimsAUX.prodMuons_cfi")
コード例 #46
0
#process.GlobalTag.ReconnectEachRun = cms.untracked.bool( False )
    
###
### AK8 jets with subjet b-tagging
###

## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", 
    src = cms.InputTag("packedGenParticles"), 
    cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
    )

## Fat GenJets
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak8GenJetsNoNu = ak4GenJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("packedGenParticlesForJetsNoNu")
    )

## Pruned fat GenJets (two jet collections are produced, fat jets and subjets)
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
process.ak8GenJetsNoNuPruned = ak4GenJets.clone(
   SubJetParameters,
   rParam = cms.double(0.8),
   src = cms.InputTag("packedGenParticlesForJetsNoNu"),
   usePruning = cms.bool(True),
   writeCompound = cms.bool(True),
   jetCollInstanceName=cms.string("SubJets")
   )

## Select charged hadron subtracted packed PF candidates
process.pfCHS = cms.EDFilter("CandPtrSelector", 
コード例 #47
0
process.task = cms.Task()

## Set input particle collections to be used by the tools
genParticleCollection = ''
genJetCollection = ''
if options.runOnAOD:
    genParticleCollection = 'genParticles'
    genJetCollection = 'ak4GenJetsCustom'
    ## producing a subset of genParticles to be used for jet clustering in AOD
    from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu
    process.genParticlesForJetsCustom = genParticlesForJetsNoNu.clone()
    process.task.add(process.genParticlesForJetsCustom)
    ## Produce own jets (re-clustering in miniAOD needed at present to avoid crash)
    from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
    process.ak4GenJetsCustom = ak4GenJets.clone(
        src='genParticlesForJetsCustom',
        rParam=cms.double(0.4),
        jetAlgorithm=cms.string("AntiKt"))
    process.task.add(process.ak4GenJetsCustom)
else:
    genParticleCollection = 'prunedGenParticles'
    genJetCollection = 'slimmedGenJets'

## Supplies PDG ID to real name resolution of MC particles
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

## Ghost particle collection used for Hadron-Jet association
# MUST use proper input particle collection
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons

process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
    particles=genParticleCollection)
コード例 #48
0
ファイル: ak8GenJets_cfi.py プロジェクト: ssanders50/MiniAOD
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

ak8GenJets = ak4GenJets.clone(rParam=cms.double(0.8))

ak8GenJetsSoftDrop = ak8GenJets.clone(
    useSoftDrop=cms.bool(True),
    zcut=cms.double(0.1),
    beta=cms.double(0.0),
    R0=cms.double(0.8),
    useExplicitGhosts=cms.bool(True),
    writeCompound=cms.bool(True),
    jetCollInstanceName=cms.string("SubJets"),
    jetPtMin=100.0)

ak8GenJetsConstituents = cms.EDProducer("GenJetConstituentSelector",
                                        src=cms.InputTag("ak8GenJets"),
                                        cut=cms.string("pt > 100.0"))
コード例 #49
0
   max(0.,pfIsolationVariables().sumNeutralHadronEt+
   pfIsolationVariables().sumPhotonEt-
   0.5*pfIsolationVariables().sumPUPt))/pt < 0.20'''))
process.selectedIDElectrons = cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedElectrons"), cut = cms.string('''abs(eta)<2.5 && pt>5. &&
   gsfTrack.isAvailable() &&
   gsfTrack.hitPattern().numberOfLostHits('MISSING_INNER_HITS')<2'''))

#do projections
process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))
process.pfNoMuonCHS =  cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHS"), veto = cms.InputTag("selectedMuons"))
process.pfNoElectronsCHS = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHS"), veto =  cms.InputTag("selectedElectrons"))

process.pfNoMuon =  cms.EDProducer("CandPtrProjector", src = cms.InputTag("packedPFCandidates"), veto = cms.InputTag("selectedMuons"))
process.pfNoElectrons = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuon"), veto =  cms.InputTag("selectedElectrons"))

process.ak4GenJets = ak4GenJets.clone(src = 'packedGenParticles', rParam = 0.4)

process.pfMet = pfMet.clone(src = "packedPFCandidates")
process.pfMet.calculateSignificance = False # this can't be easily implemented on packed PF candidates at the moment

#from PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi import patMETs
process.load('PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi')
#from JetMETCorrections.Type1MET.pfMETCorrections_cff import *
from JetMETCorrections.Type1MET.correctionTermsPfMetType1Type2_cff import *
from PhysicsTools.PatUtils.patPFMETCorrections_cff import patPFJetMETtype1p2Corr

process.patMETs.addGenMET = cms.bool(False)

#process.patpfType1CorrectedMet = pfType1CorrectedMet.clone(
#
#)
コード例 #50
0
## Details in: PhysicsTools/JetExamples/test/printJetFlavourInfo.cc, PhysicsTools/JetExamples/test/printJetFlavourInfo.py
## and in: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagMCTools#New_jet_flavour_definition

## Supply PDG ID to real name resolution of MC particles
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

## Input particles for gen jets (stable gen particles to be used in clustering, excluding electrons, muons and neutrinos from hard interaction)
from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJets
process.genParticlesForJetsNoNuNoLepton = genParticlesForJets.clone(
    src=genJetInputParticleCollection,
    excludeResonances=True,
    excludeFromResonancePids=[11, 12, 13, 14, 16],
)

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak4GenJetsNoNuNoLepton = ak4GenJets.clone(
    src="genParticlesForJetsNoNuNoLepton")

# Ghost particle collection for matching to gen jets (b/c hadrons + leptons)
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
    particles=genParticleCollection)

# Flavour info: jet collection with all associated ghosts
# For the moment leptons need to be specified explicitely here, until lepton access can be made more generic in miniAOD
# This is only needed as long as the jetConstituents are not accessible directly in miniAOD, then it should be fixed
# by using the leptons from the constituents, instead of feeding them as ghosts into the jets

from PhysicsTools.JetMCAlgos.AK4PFJetsMCFlavourInfos_cfi import ak4JetFlavourInfos
process.ak4GenJetFlavourPlusLeptonInfos = ak4JetFlavourInfos.clone(
    jets=genJetCollection,
    leptons=cms.InputTag("selectedHadronsAndPartons", "leptons"))
コード例 #51
0
process.GlobalTag.globaltag = options.globalTag

#################################################
## After 7.4.0, only need to make AK8 gen jets.
## The rest are stored by default in MiniAOD directly.
#################################################

## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter(
    "CandPtrSelector",
    src=cms.InputTag("packedGenParticles"),
    cut=cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
## Fat GenJets
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

process.ak8GenJetsNoNu = ak4GenJets.clone(
    rParam=cms.double(0.8), src=cms.InputTag("packedGenParticlesForJetsNoNu"))

## SoftDrop fat GenJets (two jet collections are produced, fat jets and subjets)
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

process.ak8GenJetsNoNuSoftDrop = ak4GenJets.clone(
    rParam=cms.double(0.8),
    src=cms.InputTag("packedGenParticlesForJetsNoNu"),
    useSoftDrop=cms.bool(True),
    zcut=cms.double(0.1),
    beta=cms.double(0.0),
    R0=cms.double(0.8),
    useExplicitGhosts=cms.bool(True),
    writeCompound=cms.bool(True),
    jetCollInstanceName=cms.string("SubJets"))
############## output  edm format ###############
process.out = cms.OutputModule(
    'PoolOutputModule',
    fileName=cms.untracked.string('jettoolbox.root'),
    outputCommands=cms.untracked.vstring([
        'keep *_slimmedJets_*_*',
        'keep *_slimmedJetsAK8_*_*',
    ]))

# Added 'vertexRef().isNonnull() &&' check for 80X data compatibility. Juska
process.chs = cms.EDFilter('CandPtrSelector',
                           src=cms.InputTag('packedPFCandidates'),
                           cut=cms.string(' fromPV'))

from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.slimmedGenJetsAK8 = ak4GenJets.clone(src='packedGenParticles',
                                             rParam=0.8)

#-------------------------------------------------------
# Gen Particles Pruner
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

process.prunedGenParticlesDijet = cms.EDProducer(
    'GenParticlePruner',
    src=cms.InputTag("prunedGenParticles"),
    select=cms.vstring(
        "drop  *  ",  # by default
        "keep ( status = 3 || (status>=21 && status<=29) )",  # keep hard process particles
    ))

#------------- Recluster Gen Jets to access the constituents -------
#already in toolbox, just add keep statements
コード例 #53
0
ファイル: tagFatJets.py プロジェクト: SiewYan/DMPD
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc') # + ('data' if options.runOnData else 'mc'))

process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("Configuration.Geometry.GeometryRecoDB_cff")


from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets

## Do projections
#process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))
process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedGenParticles"), cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
process.ak4GenJetsNoNu = ak4GenJets.clone(src = 'packedGenParticlesForJetsNoNu')


from PhysicsTools.PatAlgos.tools.jetTools import *
## Switch the default jet collection (done in order to use the above specified b-tag infos and discriminators)
switchJetCollection(
    process,
    jetSource = cms.InputTag(jetSource),
    pfCandidates = cms.InputTag(pfCandidates),
    pvSource = cms.InputTag(pvSource),
    svSource = cms.InputTag(svSource),
    #muSource = cms.InputTag(muSource),
    #elSource = cms.InputTag(elSource),
    btagInfos = bTagInfos,
    btagDiscriminators = bTagDiscriminators,
    jetCorrections = jetCorrectionsAK4,
コード例 #54
0
def makeFatJets(process, isData, pfCandidates, algoLabel, jetRadius):

    isMC = not isData
    postfix = 'PFlow'
    if pfCandidates == 'particleFlow':
        # mini aod needs a different config
        pfCandidates = 'pfCHS'

    if pfCandidates == 'pfCHS':
        puMethod = 'chs'
    else:
        puMethod = 'puppi'

    rLabel = algoLabel + str(int(jetRadius * 10))
    #customLabel = rLabel+puMethod
    customLabel = puMethod + rLabel

    if algoLabel == 'CA':
        jetAlgo = 'CambridgeAachen'
    else:
        jetAlgo = 'AntiKt'

    if jetRadius < 1:
        sdZcut = 0.1
        sdBeta = 0.0
    else:
        sdZcut = 0.15
        sdBeta = 1.0

    setattr(process, customLabel + 'Sequence', cms.Sequence())
    newSeq = getattr(process, customLabel + 'Sequence')

    ## Various collection names
    genParticles = 'prunedGenParticles'
    pvSource = 'offlineSlimmedPrimaryVertices'
    svSource = 'slimmedSecondaryVertices'
    muSource = 'slimmedMuons'
    elSource = 'slimmedElectrons'
    bTagInfos = [
        'pfImpactParameterTagInfos', 'pfSecondaryVertexTagInfos',
        'pfInclusiveSecondaryVertexFinderTagInfos', 'softPFMuonsTagInfos',
        'softPFElectronsTagInfos'
    ]
    ## b-tag discriminators
    bTagDiscriminators = [
        'pfCombinedSecondaryVertexV2BJetTags',
        'pfCombinedInclusiveSecondaryVertexV2BJetTags'
    ]

    bTagInfosSubjets = [
        'pfImpactParameterTagInfos', 'pfSecondaryVertexTagInfos',
        'pfInclusiveSecondaryVertexFinderTagInfos', 'softPFMuonsTagInfos',
        'softPFElectronsTagInfos'
    ]
    ## b-tag discriminators
    bTagDiscriminatorsSubjets = [
        'pfCombinedSecondaryVertexV2BJetTags',
        'pfCombinedInclusiveSecondaryVertexV2BJetTags'
    ]

    bTagInfosSubjets = ['None']
    bTagDiscriminatorsSubjets = ['None']

    ### jet clustering ###
    ########################################
    ##           REMAKE JETS              ##
    ########################################

    addingGenJets = False

    if not (hasattr(process, "genJetsNoNu" + rLabel)) and isMC:
        addingGenJets = True
        setattr(
            process, "genJetsNoNu" + rLabel,
            ak4GenJets.clone(
                jetAlgorithm=cms.string(jetAlgo),
                rParam=cms.double(jetRadius),
                src=cms.InputTag("packedGenParticlesForJetsNoNu")))
    setattr(
        process, "PFJets" + customLabel,
        ak4PFJets.clone(jetAlgorithm=cms.string(jetAlgo),
                        rParam=cms.double(jetRadius),
                        src=cms.InputTag(pfCandidates),
                        jetPtMin=cms.double(180)))
    if not (hasattr(process, "genJetsNoNuSoftDrop" + rLabel)) and isMC:
        addingGenJets = True
        setattr(
            process, "genJetsNoNuSoftDrop" + rLabel,
            getattr(process, 'genJetsNoNu' + rLabel).clone(
                R0=cms.double(jetRadius),
                useSoftDrop=cms.bool(True),
                zcut=cms.double(sdZcut),
                beta=cms.double(sdBeta),
                writeCompound=cms.bool(True),
                useExplicitGhosts=cms.bool(True),
                jetCollInstanceName=cms.string("SubJets")))
    setattr(
        process, "PFJets" + "SoftDrop" + customLabel,
        getattr(process, 'PFJets' + customLabel).clone(
            useSoftDrop=cms.bool(True),
            R0=cms.double(jetRadius),
            zcut=cms.double(sdZcut),
            beta=cms.double(sdBeta),
            writeCompound=cms.bool(True),
            useExplicitGhosts=cms.bool(True),
            jetCollInstanceName=cms.string("SubJets"),
            jetPtMin=cms.double(180)))
    process.dump = cms.EDAnalyzer("EventContentAnalyzer")
    if addingGenJets and not (isData):
        print 'addingGenJets', 'genJetsNoNu' + rLabel
        newSeq += getattr(process, 'genJetsNoNu' + rLabel)
        newSeq += getattr(process, 'genJetsNoNuSoftDrop' + rLabel)
    newSeq += getattr(process, 'PFJets' + customLabel)
    newSeq += getattr(process, 'PFJets' + "SoftDrop" + customLabel)

    ########################################
    ##           SUBSTRUCTURE             ##
    #######################################

    setattr(
        process, customLabel + 'Njettiness',
        Njettiness.clone(src=cms.InputTag('PFJets' + customLabel),
                         R0=cms.double(jetRadius),
                         Njets=cms.vuint32(1, 2, 3, 4)))

    setattr(
        process, customLabel + 'SDKinematics',
        cms.EDProducer(
            'RecoJetDeltaRValueMapProducer',
            src=cms.InputTag('PFJets' + customLabel),
            matched=cms.InputTag('PFJets' + "SoftDrop" + customLabel),
            distMax=cms.double(1.5),
            values=cms.vstring('mass'),
            valueLabels=cms.vstring('Mass'),
        ))

    newSeq += getattr(process, customLabel + 'SDKinematics')
    newSeq += getattr(process, customLabel + 'Njettiness')

    ### subjet qg-tagging ###

    setattr(
        process, customLabel + 'SubQGTag',
        QGTagger.clone(srcJets=cms.InputTag(
            'PFJets' + "SoftDrop" + customLabel, 'SubJets'),
                       jetsLabel=cms.string('QGL_AK4PFchs')))

    newSeq += getattr(process, customLabel + 'SubQGTag')

    ### subjet b-tagging ###

    setattr(
        process, customLabel + 'PFImpactParameterTagInfos',
        pfImpactParameterTagInfos.clone(
            jets=cms.InputTag('PFJets' + "SoftDrop" + customLabel, 'SubJets'),
            maxDeltaR=cms.double(0.4),
            primaryVertex=cms.InputTag('offlineSlimmedPrimaryVertices'),
            candidates=cms.InputTag('packedPFCandidates')))

    setattr(
        process, customLabel + 'PFInclusiveSecondaryVertexFinderTagInfos',
        pfInclusiveSecondaryVertexFinderTagInfos.clone(
            trackIPTagInfos=cms.InputTag(customLabel +
                                         'PFImpactParameterTagInfos'),
            extSVCollection=cms.InputTag('slimmedSecondaryVertices')))
    setattr(
        process, customLabel + 'PFCombinedInclusiveSecondaryVertexV2BJetTags',
        pfCombinedInclusiveSecondaryVertexV2BJetTags.clone(
            tagInfos=cms.VInputTag(
                cms.InputTag(customLabel + "PFImpactParameterTagInfos"),
                cms.InputTag(customLabel +
                             "PFInclusiveSecondaryVertexFinderTagInfos"))))
    newSeq += getattr(process, customLabel + 'PFImpactParameterTagInfos')
    newSeq += getattr(process,
                      customLabel + 'PFInclusiveSecondaryVertexFinderTagInfos')
    newSeq += getattr(
        process, customLabel + 'PFCombinedInclusiveSecondaryVertexV2BJetTags')

    bTagInfos = ['None']
    bTagDiscriminators = ['None']

    ########################################
    ##          MAKE PAT JETS             ##
    ########################################

    addJetCollection(
        process,
        labelName='PF' + customLabel,
        jetSource=cms.InputTag('PFJets' + customLabel),
        algo=algoLabel,  # needed for jet flavor clustering
        rParam=jetRadius,  # needed for jet flavor clustering
        pfCandidates=cms.InputTag('packedPFCandidates'),
        pvSource=cms.InputTag(pvSource),
        svSource=cms.InputTag(svSource),
        muSource=cms.InputTag(muSource),
        elSource=cms.InputTag(elSource),
        btagInfos=bTagInfos,
        btagDiscriminators=bTagDiscriminators,
        genJetCollection=cms.InputTag('genJetsNoNu' + rLabel),
        genParticles=cms.InputTag(genParticles),
        getJetMCFlavour=False,  # jet flavor disabled
    )
    getattr(process, 'selectedPatJetsPF' +
            customLabel).cut = cms.string("abs(eta) < " + str(2.5))
    ## SOFT DROP ##
    addJetCollection(
        process,
        labelName='SoftDropPF' + customLabel,
        jetSource=cms.InputTag('PFJets' + "SoftDrop" + customLabel),
        pfCandidates=cms.InputTag('packedPFCandidates'),
        algo=algoLabel,
        rParam=jetRadius,
        btagInfos=['None'],
        btagDiscriminators=['None'],
        genJetCollection=cms.InputTag('genJetsNoNu' + rLabel),
        genParticles=cms.InputTag(genParticles),
        getJetMCFlavour=False,  # jet flavor disabled
    )
    addJetCollection(
        process,
        labelName='SoftDropSubjetsPF' + customLabel,
        jetSource=cms.InputTag('PFJets' + "SoftDrop" + customLabel, 'SubJets'),
        algo=algoLabel,
        rParam=jetRadius,
        pfCandidates=cms.InputTag('packedPFCandidates'),
        pvSource=cms.InputTag(pvSource),
        svSource=cms.InputTag(svSource),
        muSource=cms.InputTag(muSource),
        elSource=cms.InputTag(elSource),
        btagInfos=bTagInfosSubjets,
        btagDiscriminators=bTagDiscriminatorsSubjets,
        genJetCollection=cms.InputTag('genJetsNoNuSoftDrop' + rLabel,
                                      'SubJets'),
        genParticles=cms.InputTag(genParticles),
        explicitJTA=True,  # needed for subjet b tagging
        svClustering=True,  # needed for subjet b tagging
        fatJets=cms.InputTag(
            'PFJets' + customLabel),  # needed for subjet flavor clustering
        groomedFatJets=cms.InputTag(
            'PFJets' + "SoftDrop" +
            customLabel),  # needed for subjet flavor clustering
        runIVF=False,
        getJetMCFlavour=False,  # jet flavor disabled
    )

    isMC = not (isData)
    if isMC:
        newSeq += getattr(process, 'patJetPartonMatchPF' + customLabel)
        newSeq += getattr(process, 'patJetGenJetMatchPF' + customLabel)
    newSeq += getattr(process, 'patJetsPF' + customLabel)
    newSeq += getattr(process, 'selectedPatJetsPF' + customLabel)

    if isMC:
        newSeq += getattr(process, 'patJetPartonMatchSoftDropPF' + customLabel)
        newSeq += getattr(process, 'patJetGenJetMatchSoftDropPF' + customLabel)
    newSeq += getattr(process, 'patJetsSoftDropPF' + customLabel)
    newSeq += getattr(process, 'selectedPatJetsSoftDropPF' + customLabel)

    if isMC:
        newSeq += getattr(process,
                          'patJetPartonMatchSoftDropSubjetsPF' + customLabel)
        newSeq += getattr(process,
                          'patJetGenJetMatchSoftDropSubjetsPF' + customLabel)
    newSeq += getattr(process, 'patJetsSoftDropSubjetsPF' + customLabel)
    newSeq += getattr(process,
                      'selectedPatJetsSoftDropSubjetsPF' + customLabel)

    setattr(
        process, "selectedPatJetsSoftDropPF" + "Packed" + customLabel,
        cms.EDProducer(
            "BoostedJetMerger",
            jetSrc=cms.InputTag("selectedPatJetsSoftDropPF" + customLabel),
            subjetSrc=cms.InputTag("selectedPatJetsSoftDropSubjetsPF" +
                                   customLabel)))
    ## PACK ##
    setattr(
        process, "packedPatJetsPF" + customLabel,
        cms.EDProducer("JetSubstructurePacker",
                       jetSrc=cms.InputTag('selectedPatJetsPF' + customLabel),
                       distMax=cms.double(jetRadius),
                       algoTags=cms.VInputTag(),
                       algoLabels=cms.vstring(),
                       fixDaughters=cms.bool(False)))
    getattr(process, "packedPatJetsPF" + customLabel).algoTags.append(
        cms.InputTag('selectedPatJetsSoftDropPF' + "Packed" + customLabel))
    getattr(process,
            "packedPatJetsPF" + customLabel).algoLabels.append('SoftDrop')
    getattr(process, 'patJetsPF' + customLabel).userData.userFloats.src += [
        customLabel + 'Njettiness:tau1'
    ]
    getattr(process, 'patJetsPF' + customLabel).userData.userFloats.src += [
        customLabel + 'Njettiness:tau2'
    ]
    getattr(process, 'patJetsPF' + customLabel).userData.userFloats.src += [
        customLabel + 'Njettiness:tau3'
    ]
    getattr(process, 'patJetsPF' + customLabel).userData.userFloats.src += [
        customLabel + 'Njettiness:tau4'
    ]
    getattr(process, 'patJetsPF' + customLabel).userData.userFloats.src += [
        customLabel + 'SDKinematics:Mass'
    ]

    for m in [
            'patJetsPF' + customLabel, 'patJetsSoftDropSubjetsPF' + customLabel
    ]:
        if hasattr(process, m) and getattr(getattr(process, m), 'addBTagInfo'):
            setattr(getattr(process, m), 'addTagInfos', cms.bool(True))
        #if hasattr(process,m):
        #  setattr( getattr(process,m), 'addJetFlavourInfo', cms.bool(True))

    newSeq += cms.Sequence(
        getattr(process, 'selectedPatJetsSoftDropPF' + "Packed" +
                customLabel) +
        getattr(process, 'packedPatJetsPF' + customLabel))

    #  if isData:
    #      toRemove = ['Photons', 'Electrons','Muons', 'Taus', 'Jets', 'METs', 'PFElectrons','PFTaus','PFMuons']
    #      removeMCMatching(process, toRemove, outputModules = [])
    return newSeq
コード例 #55
0
	gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
	(pfIsolationVariables().sumChargedHadronPt+
	max(0.,pfIsolationVariables().sumNeutralHadronEt+
	pfIsolationVariables().sumPhotonEt-
	0.5*pfIsolationVariables().sumPUPt))/pt < 0.15'''))

    ## Do projections
    process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))
    process.pfNoMuonCHS =  cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHS"), veto = cms.InputTag("selectedMuons"))
    process.pfNoElectronsCHS = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHS"), veto = cms.InputTag("selectedElectrons"))

    process.pfNoMuon =  cms.EDProducer("CandPtrProjector", src = cms.InputTag("packedPFCandidates"), veto = cms.InputTag("selectedMuons"))
    process.pfNoElectrons = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuon"), veto = cms.InputTag("selectedElectrons"))

    process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedGenParticles"), cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
    process.ak4GenJetsNoNu = ak4GenJets.clone(src = 'packedGenParticlesForJetsNoNu')

    if options.useTTbarFilter:
        if options.usePFchs:
            process.ak4PFJets = ak4PFJets.clone(src = 'pfCHS', doAreaFastjet = True)
        else:
            process.ak4PFJets = ak4PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True)
    else:
        if options.usePFchs:
            if options.useTopProjections:
                process.ak4PFJets = ak4PFJets.clone(src = 'pfNoElectronsCHS', doAreaFastjet = True)
            else:
                process.ak4PFJets = ak4PFJets.clone(src = 'pfCHS', doAreaFastjet = True)
        else:
            if options.useTopProjections:
                process.ak4PFJets = ak4PFJets.clone(src = 'pfNoElectrons', doAreaFastjet = True)