def addC8Jets(p, runOnMC):
    p2 = p.replace('AK5', 'CA8')

    ###############################
    ###### Bare CA 0.8 jets #######
    ###############################
    setattr(process, "ca8PFJets" + p2, ca4PFJets.clone(
            rParam = cms.double(0.8),
            src = cms.InputTag('pfNoElectron' + p),
            doAreaFastjet = cms.bool(True),
            doRhoFastjet = cms.bool(True),
            Rho_EtaMax = cms.double(6.0),
            Ghost_EtaMax = cms.double(7.0),
            srcPVs = cms.InputTag("goodOfflinePrimaryVertices")
            ))

    # Add ca8PFJets to the main process path
    getattr(process, "patPF2PATSequence" + p).replace(
            getattr(process, "pfNoElectron" + p), getattr(process, "pfNoElectron" + p) * getattr(process, "ca8PFJets" + p2)
            )

    addJetCollection(process, 
            cms.InputTag('ca8PFJets' + p2),
            'CA8', 'PFchs' if 'chs' in p else 'PF',
            doJTA = True,
            doBTagging = True,
            jetCorrLabel = ('AK7PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute']),
            doType1MET = True,
            doL1Cleaning = False,
            doL1Counters = False,
            genJetCollection = cms.InputTag("ca8GenJetsNoNu"),
            doJetID = True,
            )
    if not runOnMC:
      # Remove MC Matching
      removeMCMatching(process, names = ["All"])
    genJetCollection = cms.InputTag("ak5GenJets"),
    doJetID          = True
)





# for FatJets #

from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets

process.ca8PFJetsPFlow = ca4PFJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag('pfNoPileUp'),
    doAreaFastjet = cms.bool(True),
    doRhoFastjet = cms.bool(True),
    Rho_EtaMax = cms.double(4.4),  ## sure?
    Ghost_EtaMax = cms.double(5.0)  ## sure?
  )

addJetCollection(
    process,
    cms.InputTag('ca8PFJetsPFlow'), # Jet collection; must be already in the event when patLayer0 sequence is executed
    algoLabel     = "CA8",
    typeLabel     = "PF",
    doJTA         = True, # Run Jet-Track association & JetCharge
    doBTagging    = True, # Run b-tagging
    #jetCorrLabel  = ('AK7PF',myCorrLabels),
    jetCorrLabel  = ('AK7PF',emptyCorrLabels), # ---> no jet corrections
    doType1MET    = True,
    doL1Cleaning  = False,
    ),
)

from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
from RecoJets.JetProducers.PFJetParameters_cfi import *
from RecoJets.JetProducers.CaloJetParameters_cfi import *
from RecoJets.JetProducers.AnomalousCellParameters_cfi import *
from RecoJets.JetProducers.CATopJetParameters_cfi import *
from RecoJets.JetProducers.GenJetParameters_cfi import *

from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets

process.ca8PFJetsPFlow = ca4PFJets.clone(
    rParam=cms.double(0.8),
    src=cms.InputTag("particleFlow"),
    doAreaFastjet=cms.bool(True),
    doRhoFastjet=cms.bool(True),
    Rho_EtaMax=cms.double(6.0),
    Ghost_EtaMax=cms.double(7.0),
)

process.ca8PFJetsPFlowCHS = ca4PFJets.clone(
    rParam=cms.double(0.8),
    src=cms.InputTag("pfNoElectron"),
    doAreaFastjet=cms.bool(True),
    doRhoFastjet=cms.bool(True),
    Rho_EtaMax=cms.double(6.0),
    Ghost_EtaMax=cms.double(7.0),
)

from RecoJets.JetProducers.ak5PFJetsTrimmed_cfi import ak5PFJetsTrimmed
def createProcess(runOnMC, runCHS, correctMETWithT1, processCaloJets, processCA8Jets, globalTag):

  ## import skeleton process
  from PhysicsTools.PatAlgos.patTemplate_cfg import process

  # load the PAT config
  process.load("PhysicsTools.PatAlgos.patSequences_cff")
  process.load("JetMETCorrections.Configuration.JetCorrectionProducers_cff")

  # Do some CHS stuff
  process.ak5PFchsL1Fastjet  = process.ak5PFL1Fastjet.clone(algorithm = 'AK5PFchs')
  process.ak5PFchsL2Relative = process.ak5PFL2Relative.clone(algorithm = 'AK5PFchs')
  process.ak5PFchsL3Absolute = process.ak5PFL3Absolute.clone(algorithm = 'AK5PFchs')
  process.ak5PFchsResidual   = process.ak5PFResidual.clone(algorithm = 'AK5PFchs')
  process.ak5PFchsL1FastL2L3 = cms.ESProducer(
      'JetCorrectionESChain',
      correctors = cms.vstring('ak5PFchsL1Fastjet', 'ak5PFchsL2Relative','ak5PFchsL3Absolute')
      )


  from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector

  ## The good primary vertex filter ____________________________________________||
  ## This filter throw events with no primary vertex
  process.primaryVertexFilter = cms.EDFilter(
      "VertexSelector",
      src = cms.InputTag("offlinePrimaryVertices"),
      cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
      filter = cms.bool(True)
      )

  process.goodOfflinePrimaryVertices = cms.EDFilter("PrimaryVertexObjectFilter",
      filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ),
      src = cms.InputTag('offlinePrimaryVertices')
      )

  # Configure PAT to use PF2PAT instead of AOD sources
  # this function will modify the PAT sequences.
  from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects, removeMCMatching
  from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT, adaptPFIsoElectrons, adaptPVs, usePFIso
  #from PhysicsTools.PatAlgos.tools.metTools import *

  def usePF2PATForAnalysis(jetAlgo, postfix, useTypeIMET, usePFNoPU):

    # Jet corrections
    # No L2L3 Residual on purpose
    if usePFNoPU:
      jetCorrections = ("%sPFchs" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
      postfix += "chs"
    else:
      jetCorrections = ("%sPF" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])

    #if not runOnMC:
    #  jetCorrections[1].append('L2L3Residual')

    p = postfix

    usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=p, jetCorrections=jetCorrections, typeIMetCorrections = useTypeIMET)
    getattr(process, "pfPileUp" + p).Enable = True
    getattr(process, "pfPileUp" + p).Vertices = 'goodOfflinePrimaryVertices'
    getattr(process, "pfPileUp" + p).checkClosestZVertex = cms.bool(False)

    getattr(process, "pfJets" + p).doAreaFastjet = cms.bool(True)
    getattr(process, "pfJets" + p).doRhoFastjet = False
    getattr(process, 'patJetCorrFactors' + p).rho = cms.InputTag("kt6PFJets", "rho") # Do not use kt6PFJetsPFlowAK5, it's not ok for L1FastJet.

    # top projections in PF2PAT:
    getattr(process,"pfNoPileUp" + p).enable = cms.bool(usePFNoPU)
    getattr(process,"pfNoMuon" + p).enable = True
    getattr(process,"pfNoElectron" + p).enable = True
    getattr(process,"pfNoTau" + p).enable = True
    getattr(process,"pfNoJet" + p).enable = True

    getattr(process,"patElectrons" + p).embedTrack = True

    getattr(process,"patMuons" + p).embedTrack = True
    # enable delta beta correction for muon selection in PF2PAT?
    getattr(process,"pfIsolatedMuons" + p).doDeltaBetaCorrection = True

    getattr(process, "patJets" + p).embedPFCandidates = False
    # Keep only jets with pt > 2 Gev
    getattr(process, "selectedPatJets" + p).cut = "pt > 2";

    # Use a cone of 0.3 for photon isolation
    #adaptPFIsoPhotons(process, applyPostfix(process, "patPhotons", postfix), postfix, "03")

    # 2012 Photon ID

    # Electron conversion
    setattr(process, "patConversions" + p, cms.EDProducer("PATConversionProducer",
        # input collection
        electronSource = cms.InputTag("selectedPatElectrons" + p)
    ))

    # Switch electron isolation to dR = 0.3, for PF2PAT
    getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
    getattr(process, "pfIsolatedElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
    getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))

    getattr(process, "pfElectrons" + p).isolationValueMapsCharged  = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
    getattr(process, "pfElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
    getattr(process, "pfElectrons" + p).isolationValueMapsNeutral  = cms.VInputTag(cms.InputTag( "elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))

    # ... And for PAT
    adaptPFIsoElectrons(process, getattr(process, "pfElectrons" + p), p, "03")

    
    if runOnMC:
      cloneProcessingSnippet(process, getattr(process, "makePatMuons" + p), "Loose" + p, p)
      getattr(process, "muonMatchLoose" + p).src = cms.InputTag("pfMuons" + p)
      getattr(process, "patMuonsLoose" + p).pfMuonSource = cms.InputTag("pfMuons" + p)
      getattr(process, "patDefaultSequence" + p).replace(getattr(process, "makePatMuons" + p), getattr(process, "makePatMuons" + p) + getattr(process, "makePatMuonsLoose" + p))
    else:
      setattr(process, "patMuonsLoose" + p, getattr(process, "patMuons" + p).clone(
          pfMuonSource = cms.InputTag("pfMuons" + p)
        )
      )

    setattr(process, "selectedPatMuonsLoose" + p, getattr(process, "selectedPatMuons" + p).clone(
        src = cms.InputTag("patMuonsLoose" + p)
      )
    )
    sequence = getattr(process, "patDefaultSequence" + p)

    if not runOnMC:
      sequence += getattr(process, "patMuonsLoose" + p)

    sequence += (getattr(process, "selectedPatMuonsLoose" + p))

    setattr(process, "patElectronsLoose" + p, getattr(process, "patElectrons" + p).clone(
        pfElectronSource = cms.InputTag("pfElectrons" + p)
      )
    )
    setattr(process, "selectedPatElectronsLoose" + p, getattr(process, "selectedPatElectrons" + p).clone(
        src = cms.InputTag("patElectronsLoose" + p)
      )
    )
    adaptPFIsoElectrons(process, getattr(process, "patElectronsLoose" + p), postfix, "03")
    sequence = getattr(process, "patDefaultSequence" + p)
    sequence += (getattr(process, "patElectronsLoose" + p) * getattr(process, "selectedPatElectronsLoose" + p))


    #giulia turn off qg tagger
    ## Setup quark gluon tagger
    #process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
    #cloneProcessingSnippet(process, process.QuarkGluonTagger, p)
    #getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
    #getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
    #getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(usePFNoPU)

    ## Remove the processing of primary vertices, as it's already what we do here
    #getattr(process, 'QGTagger' + p).srcPV = cms.InputTag('goodOfflinePrimaryVertices')
    #getattr(process, 'QuarkGluonTagger' + p).remove(getattr(process, 'goodOfflinePrimaryVerticesQG' + p))

    if not runOnMC:
      if 'L2L3Residual' in jetCorrections:
        getattr(process, 'patPFJetMETtype1p2Corr' + p).jetCorrLabel = 'L2L3Residual'
      getattr(process, 'patPFMet' + p).addGenMET = cms.bool(False)

    names = ["Taus"]
    #if jetAlgo != "AK5":
      #names += ["Electrons", "Muons"]
    if len(names) > 0:
      removeSpecificPATObjects(process, names = names, outputModules = ['out'], postfix = p) 

    adaptPVs(process, pvCollection = cms.InputTag("goodOfflinePrimaryVertices"), postfix = p)

    getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatElectrons" + p), getattr(process, "selectedPatElectrons" + p) + getattr(process, "patConversions" + p))

    #getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatJets" + p), getattr(process, "selectedPatJets" + p) + getattr(process, "QuarkGluonTagger" + p))

    return getattr(process, "patPF2PATSequence" + p)

  if correctMETWithT1:
    process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
    
  from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet

  print "##########################"
  print "PF jets with PF2PAT"
  print "Using Type I met" if correctMETWithT1 else "NOT using Type I met"
  print "##########################"

  #runCHS = False

  postfixes = {'PFlowAK5': 'AK5'}
  #postfixes = {'PFlowAK5': 'AK5', 'PFlowAK7': 'AK7', 'PFlowCA8': 'CA8'}
  #postfixes = {'PFlowCA8': 'CA8'}

  ##giulia turn off qg tagger
  ## Setup quark gluon tagger
  #process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')

  process.sequence_chs = cms.Sequence()
  process.sequence_nochs = cms.Sequence()
  for p, algo in postfixes.items():
    process.sequence_nochs += usePF2PATForAnalysis(jetAlgo=algo, postfix=p, usePFNoPU=False, useTypeIMET=correctMETWithT1)
    if runCHS:
      process.sequence_chs   += usePF2PATForAnalysis(jetAlgo=algo, postfix=p, usePFNoPU=True, useTypeIMET=correctMETWithT1)

  #  setattr(process, 'QGTagger' + p, process.QGTagger.clone())
  #  getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
  #  getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
  #  getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(False)
  #
  #  process.QuarkGluonTagger.replace(process.QGTagger, getattr(process, 'QGTagger' + p))

    if runCHS:
      chsP = p + "chs"
  
  #    setattr(process, 'QGTagger' + chsP, process.QGTagger.clone())
  #    getattr(process, "QGTagger" + chsP).srcJets = cms.InputTag("selectedPatJets" + chsP)
  #    getattr(process, "QGTagger" + chsP).isPatJet = cms.untracked.bool(True)
  #    getattr(process, "QGTagger" + chsP).useCHS = cms.untracked.bool(True)
  
  #    process.QuarkGluonTagger.replace(getattr(process, 'QGTagger' + p), getattr(process, 'QGTagger' + p) + getattr(process, 'QGTagger' + chsP))
  
  print "##########################"
  print "Calo jets" if processCaloJets else "No processing of calo jets"
  print "##########################"

  usePFIso(process, "")
  #adaptPFIsoPhotons(process,  process.patPhotons, "", "03")

  # chiara init ----------------------------------
  print "##########################"
  print "CA8 Jets" if processCA8Jets else "No processing of CA8 jets collection"
  print "##########################"

  if processCA8Jets:

    from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection

    # Reco CA 0.8 jets 
    # non sapendo quali parametri usare esattamente lascerei i default della reco per ora.
    # Per doAreaFastjet e doRhoFastjet per il momento usiamo quanto e' ridefinito sopra
    from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
    process.ca8PFJetsPFlow = ca4PFJets.clone(
      rParam = cms.double(0.8)
      # src = cms.InputTag('pfNoElectron'+postfix),    
      # doAreaFastjet = cms.bool(True),   
      # doRhoFastjet = cms.bool(True),    
      # Rho_EtaMax = cms.double(6.0),    
      # Ghost_EtaMax = cms.double(7.0)   
      )

    # Gen CA 0.8 jets
    from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
    process.ca8GenJetsNoNu = ca4GenJets.clone(
      rParam = cms.double(0.8),
      src = cms.InputTag("genParticlesForJetsNoNu")
      )
  # chiara end ----------------------------------

  
  if processCaloJets:

    # No L2L3 Residual on purpose
    jetCorrections = ('AK5Calo', ['L1Offset', 'L2Relative', 'L3Absolute'])

    addJetCollection(process, cms.InputTag('ak7CaloJets'),
        'AK7',
        'Calo',
        doJTA            = True,
        doBTagging       = True,
        jetCorrLabel     = jetCorrections,
        doType1MET       = correctMETWithT1,
        doL1Cleaning     = False,
        doL1Counters     = False,
        genJetCollection = cms.InputTag("ak7GenJets"),
        doJetID          = True,
        jetIdLabel       = "ak7"
        )



    switchJetCollection(process, cms.InputTag('ak5CaloJets'),
        doJTA            = True,
        doBTagging       = True,
        jetCorrLabel     = jetCorrections,
        doType1MET       = correctMETWithT1,
        genJetCollection = cms.InputTag("ak5GenJets"),
        doJetID          = True,
        jetIdLabel       = "ak5"
        )

    process.selectedPatJets.cut = "pt > 2"
    process.selectedPatJetsAK7Calo.cut = "pt > 2"

  else:
    removeSpecificPATObjects(process, names = ['Jets', 'METs'])

  if not runOnMC:
    # Remove MC Matching
    removeMCMatching(process, names = ["All"])

  removeSpecificPATObjects(process, names = ['Electrons', 'Muons', 'Taus'])

  if runCHS:
    print "##########################"
    print "Running CHS sequence"
    print "##########################"

  process.analysisSequence = cms.Sequence()

  process.analysisSequence *= process.sequence_nochs
  #if runCHS:
  #  process.analysisSequence *= process.sequence_chs

  # chiara init ----------------------------------
  if processCA8Jets:
    process.analysisSequence *= process.ca8PFJetsPFlow
    print("done process.ca8PFJetsPFlow")
    process.analysisSequence *= process.ca8GenJetsNoNu
    print("done process.ca8GenJetsNoNu")

    # nuovo


  # chiara end ----------------------------------


  #GIULIA
  # Quark Gluon tagging
  #process.analysisSequence *= process.QuarkGluonTagger

  # Add default pat sequence to our path
  # This brings to life TcMET, Calo jets and Photons
  ########process.analysisSequence *= process.patDefaultSequence

  # Add our PhotonIsolationProducer to the analysisSequence. This producer compute pf isolations
  # for our photons
  process.photonPFIsolation = cms.EDProducer("PhotonIsolationProducer",
      src = cms.InputTag("selectedPatPhotons")
      )

  ##########process.analysisSequence *= process.photonPFIsolation

  # Filtering

  # require physics declared
  process.load('HLTrigger.special.hltPhysicsDeclared_cfi')
  process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis'

  # require scraping filter
  process.scrapingVeto = cms.EDFilter("FilterOutScraping",
      applyfilter = cms.untracked.bool(True),
      debugOn = cms.untracked.bool(False),
      numtrack = cms.untracked.uint32(10),
      thresh = cms.untracked.double(0.25)
      )

  # Count events
  process.nEventsTotal    = cms.EDProducer("EventCountProducer")
  process.nEventsFiltered = cms.EDProducer("EventCountProducer")

  # MET Filters
  process.load("RecoMET.METFilters.metFilters_cff")

  # HCAL Laser filter : work only on Winter13 rereco
  process.load("EventFilter.HcalRawToDigi.hcallaserFilterFromTriggerResult_cff")

  # Let it run
  process.p = cms.Path(
      process.nEventsTotal +

      # Filters
      process.hcalfilter +
      process.primaryVertexFilter +
      process.scrapingVeto +
      process.metFilters +

      process.goodOfflinePrimaryVertices +

      # Physics
      process.analysisSequence +

      process.nEventsFiltered
      )

  if runOnMC:
    process.p.remove(process.hcalfilter)
    process.p.remove(process.scrapingVeto)

  # Add PF2PAT output to the created file
  from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning
  #process.load("CommonTools.ParticleFlow.PF2PAT_EventContent_cff")
  process.out.outputCommands = cms.untracked.vstring('drop *',    
                                                     #process.out.outputCommands = cms.untracked.vstring('keep *')   #'drop *',
                                                     'keep *_*_*_SIM',
                                                     'keep *_*_*_HLT',
                                                     'keep *_*_*_RECO',
                                                     'keep *_*ca8*_*_PAT')
      #'keep *_photonCore_*_*',
      #'keep double_kt6*Jets*_rho_*',
      #'keep *_goodOfflinePrimaryVertices_*_*',
      #'keep recoPFCandidates_particleFlow_*_*',

      # Content of *patEventContentNoCleaning
      #'keep *_selectedPatPhotons*_*_*', 'keep *_selectedPatElectrons*_*_*', 'keep *_selectedPatMuons*_*_*', 'keep *_selectedPatTaus*_*_*', 'keep *_selectedPatJets*_*_*', 'drop *_selectedPatJets_pfCandidates_*', 'drop *_*PF_caloTowers_*', 'drop *_*JPT_pfCandidates_*', 'drop *_*Calo_pfCandidates_*', 'keep *_patMETs*_*_*', 'keep *_selectedPatPFParticles*_*_*', 'keep *_selectedPatTrackCands*_*_*',
      #'keep *_cleanPatPhotons*_*_*', 'keep *_cleanPatElectrons*_*_*', 'keep *_cleanPatMuons*_*_*', 'keep *_cleanPatTaus*_*_*',
      #'keep *_cleanPatJets*_*_*', 'keep *_cleanPatHemispheres*_*_*', 'keep *_cleanPatPFParticles*_*_*',
      #'keep *_cleanPatTrackCands*_*_*',
      #'drop *_*PFlow_caloTowers_*',
                                                     
      # Type I residual
      #'drop *_selectedPatJetsForMET*_*_PAT',
      #'keep *_patPFMet*_*_PAT', # Keep raw met

      # Trigger
      #'keep *_TriggerResults_*_HLT',

      # Debug
      #'keep *_pf*_*_PAT'

      # Photon ID
      #'keep *_patConversions*_*_*',
      #'keep *_photonPFIsolation*_*_*',

      # Quark Gluon tagging
      #'keep *_QGTagger*_*_*',
      #'drop *_kt6PFJetsIsoQG_*_PAT',
      #'drop *_kt6PFJetsQG_*_PAT',
      # MC truth
      #'keep *_genParticles_*_*'
      #)

  if runOnMC:
    process.out.outputCommands.extend(['keep *_addPileupInfo_*_*', 'keep *_generator_*_*'])

  # switch on PAT trigger
  # from PhysicsTools.PatAlgos.tools.trigTools import switchOnTrigger
  # switchOnTrigger( process )

  ## ------------------------------------------------------
  #  In addition you usually want to change the following
  #  parameters:
  ## ------------------------------------------------------
  #
  process.GlobalTag.globaltag = "%s::All" % (globalTag) ##  (according to https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions)
  #                                         ##
  #process.source.fileNames =  cms.untracked.vstring('file:input_data.root')  ##  (e.g. 'file:AOD.root')
  #                                         ##
  #process.maxEvents.input = 2500
  process.maxEvents.input = 5000
  #                                         ##
  #   process.out.outputCommands = [ ... ]  ##  (e.g. taken from PhysicsTools/PatAlgos/python/patEventContent_cff.py)
  #                                         ##
  process.options.wantSummary = False   ##  (to suppress the long output at the end of the job)
  process.MessageLogger.cerr.FwkReport.reportEvery = 1000

  # Remove annoying ecalLaser messages
  process.MessageLogger.suppressError = cms.untracked.vstring ('ecalLaserCorrFilter')

  return process
Example #5
0
process.printEventAK8PFJets = cms.EDAnalyzer("printJetFlavourInfo",
    jetFlavourInfos    = cms.InputTag("jetFlavourInfosAK8PFJets"),
    subjetFlavourInfos = cms.InputTag("jetFlavourInfosAK8PFJets","SubJets"),
    groomedJets        = cms.InputTag("ak8PFJetsPruned"),
)
#-------------------------------------------------------------------------
# CA15 fat jets and HEPTopTagger fat jets and subjets
#-------------------------------------------------------------------------
from RecoJets.JetProducers.AnomalousCellParameters_cfi import *
from RecoJets.JetProducers.CATopJetParameters_cfi import *
from RecoJets.JetProducers.PFJetParameters_cfi import *

from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca15PFJets = ca4PFJets.clone(
    rParam   = cms.double(1.5),
    src      = cms.InputTag("particleFlow"),
    jetPtMin = cms.double(100.0)
)

process.caHEPTopTagJets = cms.EDProducer(
    "CATopJetProducer",
    PFJetParameters.clone( src = cms.InputTag("particleFlow"),
                           doAreaFastjet = cms.bool(False),
                           doRhoFastjet = cms.bool(False),
                           jetPtMin = cms.double(100.0)
                           ),
    AnomalousCellParameters,
    CATopJetParameters.clone( tagAlgo = cms.int32(2) ),
    jetAlgorithm = cms.string("CambridgeAachen"),
    rParam = cms.double(1.5),
    muCut = cms.double(0.8),
process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff")
#-------------------------------------

#-------------------------------------
# CA8 jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNu = ca4GenJets.clone(
    rParam=cms.double(0.8),
    src=cms.InputTag("genParticlesForJetsNoNu" + postfix))

from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca8PFJets = ca4PFJets.clone(rParam=cms.double(0.8),
                                    src=getattr(process,
                                                "pfJets" + postfix).src,
                                    srcPVs=getattr(process,
                                                   "pfJets" + postfix).srcPVs,
                                    doAreaFastjet=cms.bool(True),
                                    jetPtMin=cms.double(options.fatJetPtMin))

## CA8 pruned jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
process.ca8GenJetsNoNuPruned = ca4GenJets.clone(
    SubJetParameters,
    rParam=cms.double(0.8),
    src=cms.InputTag("genParticlesForJetsNoNu" + postfix),
    usePruning=cms.bool(True),
    writeCompound=cms.bool(True),
    jetCollInstanceName=cms.string("SubJets"))
from RecoJets.JetProducers.ak5PFJetsPruned_cfi import ak5PFJetsPruned
Example #7
0
ak5PrunedPFlow = ak5PFJetsPruned.clone(doAreaFastjet=cms.bool(True))

from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsFiltered
ak5FilteredPFlow = ak5PFJetsFiltered.clone(doAreaFastjet=cms.bool(True))

from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsMassDropFiltered
ak5MassDropFilteredPFlow = ak5PFJetsMassDropFiltered.clone(
    doAreaFastjet=cms.bool(True))

#process.ca12GenJetsNoNu = ca4GenJets.clone( rParam = cms.double(1.2),src = cms.InputTag("genParticlesForJetsNoNu"))
process.ca12GenJets = ca4GenJets.clone(rParam=cms.double(1.2),
                                       src=cms.InputTag("genParticlesForJets"))
process.ca12PFJetsPFlow = ca4PFJets.clone(rParam=cms.double(1.2),
                                          src=cms.InputTag("pfNoElectron" +
                                                           postfix),
                                          doAreaFastjet=cms.bool(True),
                                          doRhoFastjet=cms.bool(True),
                                          Rho_EtaMax=cms.double(6.0),
                                          Ghost_EtaMax=cms.double(7.0))
## this thing produces subjets by default
process.ca12PFJetsPrunedPFlow = ak5PrunedPFlow.clone(
    src=cms.InputTag("pfNoElectron" + postfix),
    doAreaFastjet=cms.bool(True),
    rParam=cms.double(1.2),
    jetAlgorithm=cms.string("CambridgeAachen"),
    #writeCompound = cms.bool(True), # this is used by default
    #jetCollInstanceName = cms.string("SubJets"), # this is used by default
)
## this thing produces subjets by default
process.ca12PFJetsFilteredPFlow = ak5FilteredPFlow.clone(
    src=cms.InputTag("pfNoElectron" + postfix),
Example #8
0
)
#-------------------------------------

#-------------------------------------
# CA8 jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNu = ca4GenJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("genParticlesForJetsNoNu")
)

from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca8PFJets = ca4PFJets.clone(
    rParam = cms.double(0.8),
    src = getattr(process,"pfJets"+postfix).src,
    srcPVs = getattr(process,"pfJets"+postfix).srcPVs,
    doAreaFastjet = cms.bool(True),
    jetPtMin = cms.double(options.fatJetPtMin)
)

## CA8 pruned jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
process.ca8GenJetsNoNuPruned = ca4GenJets.clone(
    SubJetParameters,
    rParam = cms.double(0.8),
    src = cms.InputTag("genParticlesForJetsNoNu"),
    usePruning = cms.bool(True),
    writeCompound = cms.bool(True),
    jetCollInstanceName=cms.string("SubJets")
)
Example #9
0
getattr(process,"pfNoElectron"+postfix).enable = True
getattr(process,"pfNoTau"+postfix).enable = False
getattr(process,"pfNoJet"+postfix).enable = True

#-------------------------------------
## CA8 jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNu = ca4GenJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("genParticlesForJetsNoNu")
)
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca8PFJetsCHS = ca4PFJets.clone(
    rParam = cms.double(0.8),
    src = getattr(process,"pfJets"+postfix).src,
    srcPVs = getattr(process,"pfJets"+postfix).srcPVs,
    doAreaFastjet = getattr(process,"pfJets"+postfix).doAreaFastjet,
    jetPtMin = cms.double(20.)
)

## CA8 filtered jets (Gen and Reco) (each module produces two jet collections, fat jets and subjets)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNuFiltered = ca4GenJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("genParticlesForJetsNoNu"),
    useFiltering = cms.bool(True),
    nFilt = cms.int32(3),
    rFilt = cms.double(0.3),
    writeCompound = cms.bool(True),
    jetCollInstanceName=cms.string("SubJets")
)
       '/store/mc/Summer12_DR53X/GluGluToHToBB_M-125_8TeV-powheg-pythia8/AODSIM/PU_S10_START53_V7C-v1/10000/B4B64DF3-4BA1-E211-9CCB-0026189438FD.root',
       '/store/mc/Summer12_DR53X/GluGluToHToBB_M-125_8TeV-powheg-pythia8/AODSIM/PU_S10_START53_V7C-v1/10000/BA86FB89-4AA1-E211-A55C-003048678B34.root',
       '/store/mc/Summer12_DR53X/GluGluToHToBB_M-125_8TeV-powheg-pythia8/AODSIM/PU_S10_START53_V7C-v1/10000/C85DC6B2-49A1-E211-8F8D-002354EF3BE6.root',
       '/store/mc/Summer12_DR53X/GluGluToHToBB_M-125_8TeV-powheg-pythia8/AODSIM/PU_S10_START53_V7C-v1/10000/CCB0A5A6-47A1-E211-9936-00248C0BE014.root',
       '/store/mc/Summer12_DR53X/GluGluToHToBB_M-125_8TeV-powheg-pythia8/AODSIM/PU_S10_START53_V7C-v1/10000/D4BD03FB-43A1-E211-8997-00248C0BE018.root',

       # /TT_CT10_AUET2_8TeV-powheg-herwig/Summer12_DR53X-PU_S10_START53_V19-v1/AODSIM
       # '/store/mc/Summer12_DR53X/TT_CT10_AUET2_8TeV-powheg-herwig/AODSIM/PU_S10_START53_V19-v1/10000/08183209-09CB-E211-AB1E-003048FFD79C.root',
       # '/store/mc/Summer12_DR53X/TT_CT10_AUET2_8TeV-powheg-herwig/AODSIM/PU_S10_START53_V19-v1/10000/081ADBBC-F0CA-E211-A893-002618943962.root',
       # '/store/mc/Summer12_DR53X/TT_CT10_AUET2_8TeV-powheg-herwig/AODSIM/PU_S10_START53_V19-v1/10000/08372094-D0CA-E211-BBAA-0025905938D4.root',
    )
)

#to get ca4PFJets
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca4PFJets = ca4PFJets.clone()

process.selectedHadronsAndPartons = cms.EDProducer('HadronAndPartonSelector',
           src = cms.InputTag("generator"),
           particles = cms.InputTag("genParticles"),
           partonMode = cms.string("Auto")
)
process.jetFlavourInfosAK5 = cms.EDProducer("JetFlavourClustering",
      jets                     = cms.InputTag("ak5PFJets"),
      bHadrons                 = cms.InputTag("selectedHadronsAndPartons","bHadrons"),
      cHadrons                 = cms.InputTag("selectedHadronsAndPartons","cHadrons"),
      partons                  = cms.InputTag("selectedHadronsAndPartons","partons"),
      jetAlgorithm             = cms.string("AntiKt"),
      rParam                   = cms.double(0.5),
      ghostRescaling           = cms.double(1e-18),
      hadronFlavourHasPriority = cms.bool(False)
Example #11
0
from RecoJets.JetProducers.ic5PFJets_cfi import iterativeCone5PFJets
from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets
from RecoJets.JetProducers.ak5PFJetsTrimmed_cfi import ak5PFJetsTrimmed
from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsFiltered, ak5PFJetsMassDropFiltered
from RecoJets.JetProducers.ak5PFJetsPruned_cfi import ak5PFJetsPruned
from RecoJets.JetProducers.gk5PFJets_cfi import gk5PFJets
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
from RecoJets.JetProducers.fixedGridRhoProducer_cfi import fixedGridRhoAll
from RecoJets.JetProducers.fixedGridRhoProducerFastjet_cfi import fixedGridRhoFastjetAll

sisCone7PFJets = sisCone5PFJets.clone(rParam=0.7)
ak7PFJets = ak5PFJets.clone(rParam=0.7)
gk7PFJets = gk5PFJets.clone(rParam=0.7)
kt6PFJets = kt4PFJets.clone(rParam=0.6)
ca6PFJets = ca4PFJets.clone(rParam=0.6)

#compute areas for Fastjet PU subtraction
kt6PFJets.doRhoFastjet = True
kt6PFJets.doAreaFastjet = True
#use active areas and not Voronoi tessellation for the moment
kt6PFJets.voronoiRfact = 0.9
ak5PFJets.doAreaFastjet = True
ak5PFJetsTrimmed.doAreaFastjet = True
ak7PFJets.doAreaFastjet = True

kt6PFJetsCentralChargedPileUp = kt6PFJets.clone(
    src=cms.InputTag("pfPileUpAllChargedParticles"),
    Ghost_EtaMax=cms.double(3.1),
    Rho_EtaMax=cms.double(2.5))
Example #12
0
from RecoJets.JetProducers.ic5PFJets_cfi import iterativeCone5PFJets
from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets
from RecoJets.JetProducers.ak5PFJetsTrimmed_cfi import ak5PFJetsTrimmed
from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsFiltered, ak5PFJetsMassDropFiltered
from RecoJets.JetProducers.ak5PFJetsPruned_cfi import ak5PFJetsPruned
from RecoJets.JetProducers.gk5PFJets_cfi import gk5PFJets
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
from RecoJets.JetProducers.fixedGridRhoProducer_cfi import fixedGridRhoAll
from RecoJets.JetProducers.fixedGridRhoProducerFastjet_cfi import fixedGridRhoFastjetAll

sisCone7PFJets = sisCone5PFJets.clone(rParam=0.7)
ak7PFJets = ak5PFJets.clone(rParam=0.7)
gk7PFJets = gk5PFJets.clone(rParam=0.7)
kt6PFJets = kt4PFJets.clone(rParam=0.6)
ca6PFJets = ca4PFJets.clone(rParam=0.6)

# compute areas for Fastjet PU subtraction
kt6PFJets.doRhoFastjet = True
kt6PFJets.doAreaFastjet = True
# use active areas and not Voronoi tessellation for the moment
kt6PFJets.voronoiRfact = 0.9
ak5PFJets.doAreaFastjet = True
ak5PFJetsTrimmed.doAreaFastjet = True
ak7PFJets.doAreaFastjet = True


kt6PFJetsCentralChargedPileUp = kt6PFJets.clone(
    src=cms.InputTag("pfPileUpAllChargedParticles"), Ghost_EtaMax=cms.double(3.1), Rho_EtaMax=cms.double(2.5)
)
process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff")
#-------------------------------------

#-------------------------------------
## CA8 jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNu = ca4GenJets.clone(
    rParam = cms.double(0.8),
    src = (cms.InputTag("packedGenParticlesForJetsNoNu") if options.miniAOD else cms.InputTag("genParticlesForJetsNoNu"+postfix))
)

from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca8PFJets = ca4PFJets.clone(
    rParam = cms.double(0.8),
    src = (getattr(process,"ak4PFJets").src if options.miniAOD else getattr(process,"pfJets"+postfix).src),
    srcPVs = (getattr(process,"ak4PFJets").srcPVs if options.miniAOD else getattr(process,"pfJets"+postfix).srcPVs),
    doAreaFastjet = cms.bool(True),
    jetPtMin = cms.double(options.fatJetPtMin)
)

## CA8 pruned jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
process.ca8GenJetsNoNuPruned = ca4GenJets.clone(
    SubJetParameters,
    rParam = cms.double(0.8),
    src = (cms.InputTag("packedGenParticlesForJetsNoNu") if options.miniAOD else cms.InputTag("genParticlesForJetsNoNu"+postfix)),
    usePruning = cms.bool(True),
    writeCompound = cms.bool(True),
    jetCollInstanceName=cms.string("SubJets")
)
    doJetID          = True
)




if doFatJet :

    # for FatJets #

    from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets

    process.ca8PFJetsPFlow = ca4PFJets.clone(
        rParam = cms.double(0.8),
        src = cms.InputTag('pfNoPileUp'),
        doAreaFastjet = cms.bool(True),
        doRhoFastjet = cms.bool(True),
        Rho_EtaMax = cms.double(4.4),  ## sure?
        Ghost_EtaMax = cms.double(5.0)  ## sure?
      )

    addJetCollection(
        process,
        cms.InputTag('ca8PFJetsPFlow'), # Jet collection; must be already in the event when patLayer0 sequence is executed
        algoLabel     = "CA8",
        typeLabel     = "PF",
        doJTA         = True, # Run Jet-Track association & JetCharge
        doBTagging    = True, # Run b-tagging
        #jetCorrLabel  = ('AK7PF',myCorrLabels),
        jetCorrLabel  = ('AK7PF',emptyCorrLabels), # ---> no jet corrections
        doType1MET    = True,
        doL1Cleaning  = False,
Example #15
0
process.printEventAK8PFJets = cms.EDAnalyzer(
    "printJetFlavourInfo",
    jetFlavourInfos=cms.InputTag("jetFlavourInfosAK8PFJets"),
    subjetFlavourInfos=cms.InputTag("jetFlavourInfosAK8PFJets", "SubJets"),
    groomedJets=cms.InputTag("ak8PFJetsPruned"),
)
#-------------------------------------------------------------------------
# CA15 fat jets and HEPTopTagger fat jets and subjets
#-------------------------------------------------------------------------
from RecoJets.JetProducers.AnomalousCellParameters_cfi import *
from RecoJets.JetProducers.CATopJetParameters_cfi import *
from RecoJets.JetProducers.PFJetParameters_cfi import *

from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca15PFJets = ca4PFJets.clone(rParam=cms.double(1.5),
                                     src=cms.InputTag("particleFlow"),
                                     jetPtMin=cms.double(100.0))

process.caHEPTopTagJets = cms.EDProducer(
    "CATopJetProducer",
    PFJetParameters.clone(src=cms.InputTag("particleFlow"),
                          doAreaFastjet=cms.bool(False),
                          doRhoFastjet=cms.bool(False),
                          jetPtMin=cms.double(100.0)),
    AnomalousCellParameters,
    CATopJetParameters.clone(tagAlgo=cms.int32(2)),
    jetAlgorithm=cms.string("CambridgeAachen"),
    rParam=cms.double(1.5),
    muCut=cms.double(0.8),
    maxSubjetMass=cms.double(30.0),
    useSubjetMass=cms.bool(False),
Example #16
0
from RecoJets.JetProducers.fixedGridRhoProducer_cfi import fixedGridRhoAll
from RecoJets.JetProducers.fixedGridRhoProducerFastjet_cfi import fixedGridRhoFastjetAll
from RecoJets.JetProducers.caTopTaggers_cff import *
from RecoJets.JetProducers.ak8PFJetsCHS_groomingValueMaps_cfi import ak8PFJetsCHSPrunedLinks, ak8PFJetsCHSFilteredLinks, ak8PFJetsCHSTrimmedLinks, ak8PFJetsCHSSoftDropLinks
from RecoJets.JetProducers.ca8PFJetsCHS_groomingValueMaps_cfi import ca8PFJetsCHSPrunedLinks, ca8PFJetsCHSFilteredLinks, ca8PFJetsCHSTrimmedLinks, ca8PFJetsCHSSoftDropLinks
from CommonTools.PileupAlgos.Puppi_cff import puppi
from CommonTools.PileupAlgos.softKiller_cfi import softKiller
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK

sisCone7PFJets = sisCone5PFJets.clone( rParam = 0.7 )
ak7PFJets = ak5PFJets.clone( rParam = 0.7 )
ak8PFJets = ak5PFJets.clone( rParam = 0.8 )
gk7PFJets = gk5PFJets.clone( rParam = 0.7 )
kt6PFJets = kt4PFJets.clone( rParam = 0.6 )
ca8PFJets = ca4PFJets.clone( rParam = 0.8 )

#compute areas for Fastjet PU subtraction  
kt6PFJets.doRhoFastjet = True
kt6PFJets.doAreaFastjet = True
#use active areas and not Voronoi tessellation for the moment
kt6PFJets.voronoiRfact = 0.9
ak4PFJets.doAreaFastjet = True
ak5PFJets.doAreaFastjet = True
ak5PFJetsTrimmed.doAreaFastjet = True
ak7PFJets.doAreaFastjet = True
ak8PFJets.doAreaFastjet = True
ak4PFJetsSK.doAreaFastjet = True

kt6PFJetsCentralChargedPileUp = kt6PFJets.clone(
    src = cms.InputTag("pfPileUpAllChargedParticles"),
process.HEPTopSelTag2Jets = HEPTopTagJets.clone(
	rParam = cms.double(2.0),
    useSelTag = cms.bool(True)
    )
process.HEPTopSelTag2Infos = HEPTopTagInfos.clone(
	src = cms.InputTag("HEPTopSelTag2Jets")
	)


from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets

process.ca125PFJetsPFlow = ca4PFJets.clone(
	rParam = cms.double(1.25),
	src = cms.InputTag('particleFlow'),
	doAreaFastjet = cms.bool(True),
	doRhoFastjet = cms.bool(True),
	Rho_EtaMax = cms.double(6.0),
	Ghost_EtaMax = cms.double(7.0)
	)


process.ca15PFJetsPFlow = ca4PFJets.clone(
	rParam = cms.double(1.5),
	src = cms.InputTag('particleFlow'),
	doAreaFastjet = cms.bool(True),
	doRhoFastjet = cms.bool(True),
	Rho_EtaMax = cms.double(6.0),
	Ghost_EtaMax = cms.double(7.0)
	)
process.ca2PFJetsPFlow = ca4PFJets.clone(
	rParam = cms.double(2.0),
Example #18
0
from RecoJets.JetProducers.ak5PFJetsPruned_cfi import ak5PFJetsPruned
ak5PrunedPFlow = ak5PFJetsPruned.clone(doAreaFastjet = cms.bool(True))

from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsFiltered
ak5FilteredPFlow = ak5PFJetsFiltered.clone(doAreaFastjet = cms.bool(True))

from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsMassDropFiltered
ak5MassDropFilteredPFlow = ak5PFJetsMassDropFiltered.clone(doAreaFastjet = cms.bool(True))

#process.ca12GenJetsNoNu = ca4GenJets.clone( rParam = cms.double(1.2),src = cms.InputTag("genParticlesForJetsNoNu"))
process.ca12GenJets = ca4GenJets.clone( rParam = cms.double(1.2),src = cms.InputTag("genParticlesForJets"))
process.ca12PFJetsPFlow = ca4PFJets.clone(
    rParam = cms.double(1.2),
    src = cms.InputTag("pfNoElectron"+postfix),
    doAreaFastjet = cms.bool(True),
    doRhoFastjet = cms.bool(True),
    Rho_EtaMax = cms.double(6.0),
    Ghost_EtaMax = cms.double(7.0)
    )
## this thing produces subjets by default
process.ca12PFJetsPrunedPFlow = ak5PrunedPFlow.clone(
    src = cms.InputTag("pfNoElectron"+postfix),
    doAreaFastjet = cms.bool(True),
    rParam = cms.double(1.2),
    jetAlgorithm = cms.string("CambridgeAachen"),
    #writeCompound = cms.bool(True), # this is used by default
    #jetCollInstanceName = cms.string("SubJets"), # this is used by default
    )
## this thing produces subjets by default
process.ca12PFJetsFilteredPFlow = ak5FilteredPFlow.clone(
    src = cms.InputTag("pfNoElectron"+postfix),
Example #19
0
#-------------------------------------

#-------------------------------------
## Fat jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.genJetsNoNu = ca4GenJets.clone(
    jetAlgorithm = cms.string(options.jetAlgo),
    rParam = cms.double(options.jetRadius),
    src = (cms.InputTag("packedGenParticlesForJetsNoNu") if options.miniAOD else cms.InputTag("genParticlesForJetsNoNu"+postfix))
)
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.PFJetsCHS = ca4PFJets.clone(
    jetAlgorithm = cms.string(options.jetAlgo),
    rParam = cms.double(options.jetRadius),
    src = (getattr(process,"ak4PFJets").src if options.miniAOD else getattr(process,"pfJetsPFBRECO"+postfix).src),
    srcPVs = (getattr(process,"ak4PFJets").srcPVs if options.miniAOD else getattr(process,"pfJetsPFBRECO"+postfix).srcPVs),
    doAreaFastjet = cms.bool(True),
    jetPtMin = cms.double(options.fatJetPtMin)
)
## Pruned fat jets (Gen and Reco) (each module produces two jet collections, fat jets and subjets)
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
process.genJetsNoNuPruned = ca4GenJets.clone(
    SubJetParameters,
    jetAlgorithm = cms.string(options.jetAlgo),
    rParam = cms.double(options.jetRadius),
    src = (cms.InputTag("packedGenParticlesForJetsNoNu") if options.miniAOD else cms.InputTag("genParticlesForJetsNoNu"+postfix)),
    usePruning = cms.bool(True),
    writeCompound = cms.bool(True),
    jetCollInstanceName=cms.string("SubJets")
)
from RecoJets.JetProducers.ak5PFJetsPruned_cfi import ak5PFJetsPruned
Example #20
0
######## JETS  CA8 ----------------------------
import FWCore.ParameterSet.Config as cms
from miniPAT.miniSubsPAT.PAT_goodPV_cff import *

############################################## NO GROOMING
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
ca8PFJetsCHS = ca4PFJets.clone(
  src = 'pfNoPileUp',
  jetPtMin = cms.double(20.0),
  doAreaFastjet = cms.bool(True),
  rParam = cms.double(0.8),
)
jetSource = 'ca8PFJetsCHS'

#### Adding corrections 
from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import *
patJetCorrFactorsCA8CHS = patJetCorrFactors.clone()
patJetCorrFactorsCA8CHS.src = jetSource
# will need to add L2L3 corrections in the cfg
patJetCorrFactorsCA8CHS.levels = ['L1FastJet', 'L2Relative', 'L3Absolute']
patJetCorrFactorsCA8CHS.payload = 'AK7PFchs'
patJetCorrFactorsCA8CHS.useRho = True

from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import *
patJetsCA8CHS = patJets.clone()
patJetsCA8CHS.jetSource = jetSource
patJetsCA8CHS.addJetCharge = False
patJetsCA8CHS.embedCaloTowers = False
patJetsCA8CHS.embedPFCandidates = False
patJetsCA8CHS.addAssociatedTracks = False
patJetsCA8CHS.addBTagInfo = False
    # unpack the list of commands 'patEventContent'
    outputCommands = cms.untracked.vstring('drop *', *patEventContent)
)

#-------------------------------------
## CA8 jets (Gen and Reco)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNu = ca4GenJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("genParticlesForJetsNoNu")
)
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca8PFJetsCHS = ca4PFJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("pfNoElectronPFlow"),
    srcPVs = cms.InputTag("goodOfflinePrimaryVertices"),
    doAreaFastjet = cms.bool(True),
    jetPtMin = cms.double(20.)
)
## CA8 filtered jets (Gen and Reco) (each module produces two jet collections, fat jets and subjets)
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNuFiltered = ca4GenJets.clone(
    rParam = cms.double(0.8),
    src = cms.InputTag("genParticlesForJetsNoNu"),
    useFiltering = cms.bool(True),
    nFilt = cms.int32(3),
    rFilt = cms.double(0.3),
    writeCompound = cms.bool(True),
    jetCollInstanceName=cms.string("SubJets")
)
from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsFiltered