예제 #1
0
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.PFJetParameters_cfi import *
from RecoJets.JetProducers.AnomalousCellParameters_cfi import *
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi

ak8PFJetsPuppi = ak4PFJetsPuppi.clone(
    rParam = 0.8    
    )

예제 #2
0
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
예제 #3
0
def jetToolbox( proc, jetType, jetSequence, outputFile, 
		PUMethod='CHS',                    #### Options: Puppi, CS, SK, Plain
		JETCorrPayload='None', JETCorrLevels = [ 'None' ],
		subJETCorrPayload='None', subJETCorrLevels = [ 'None' ],
		miniAOD=True,
		Cut = '', 
		addPruning=False, zCut=0.1, rCut=0.5, addPrunedSubjets=False,
		addSoftDrop=False, betaCut=0.0,  zCutSD=0.1, addSoftDropSubjets=False,
		addTrimming=False, rFiltTrim=0.2, ptFrac=0.03,
		addFiltering=False, rfilt=0.3, nfilt=3,
		addCMSTopTagger=False,
		addMassDrop=False,
		addHEPTopTagger=False,
		addNsub=False, maxTau=4, 
		addQJets=False 
		):
	
	###############################################################################
	#######  Verifying some inputs and defining variables
	###############################################################################
	print '|---- jetToolbox: Initialyzing...'
	supportedJetAlgos = { 'ak': 'AntiKt', 'ca' : 'CambridgeAachen', 'kt' : 'Kt' }
	recommendedJetAlgos = [ 'ak4', 'ak8', 'ca4', 'ca8', 'ca10' ]
	payloadList = [ 'AK1PFchs', 'AK2PFchs', 'AK3PFchs', 'AK4PFchs', 'AK5PFchs', 'AK6PFchs', 'AK7PFchs', 'AK8PFchs', 'AK9PFchs', 'AK10PFchs' ]
	JECLevels = [ 'L1Offset', 'L1FastJet', 'L1JPTOffset', 'L2Relative', 'L3Absolute', 'L5Falvour', 'L7Parton' ]
	jetAlgo = ''
	algorithm = ''
	size = ''
	for type, tmpAlgo in supportedJetAlgos.iteritems(): 
		if type in jetType.lower():
			jetAlgo = type
			algorithm = tmpAlgo
			size = jetType.replace( type, '' )

	jetSize = 0.
	if int(size) in range(0, 20): jetSize = int(size)/10.
	else: print '|---- jetToolBox: jetSize has not a valid value. Insert a number between 1 and 20 after algorithm, like: AK8'
	### Trick for uppercase/lowercase algo name
	jetALGO = jetAlgo.upper()+size
	jetalgo = jetAlgo.lower()+size
	if jetalgo not in recommendedJetAlgos: print '|---- jetToolBox: CMS recommends the following jet algoritms: '+' '.join(recommendedJetAlgos)+'. You are using', jetalgo,'.'

	if JETCorrPayload not in payloadList:
		if( int(size) > 10 ): 
			size = '10' 
			print '|---- jetToolbox: For jets bigger than 1.0, the jet corrections are AK10PFchs.'
		if not 'None' in JETCorrPayload: print '|---- jetToolBox: Payload given for Jet corrections ('+JETCorrPayload+') is not correct. Using a default AK'+size+'PFchs instead.'
		JETCorrPayload = 'AK'+size+'PFchs'
	else: print '|---- jetToolBox: Using '+JETCorrPayload+' payload for jet corrections.'

	if not set(JETCorrLevels).issubset(set(JECLevels)) :
		if not 'None' in JETCorrLevels: print '|---- jetToolbox: JEC levels given ( '+' '.join(JETCorrLevels)+' ) are incorrect. Using the default levels: L1FastJet, L2Relative, L3Absolute.'
		JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
	
	print '|---- jetToolBox: Applying these jet corrections: ( '+JETCorrPayload+', '+' '.join(JETCorrLevels)+' )'
	JEC = ( JETCorrPayload, JETCorrLevels , 'None')

	if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger:
		if subJETCorrPayload not in payloadList: 
			if not 'None' in subJETCorrPayload: print '|---- jetToolBox: Payload given for subjet corrections ('+JETCorrPayload+') is not correct. Using default AK4PFchs instead.'
			subJETCorrPayload = 'AK4PFchs'
		if not set(subJETCorrLevels).issubset(set(JECLevels)) or not subJETCorrLevels:
			if not 'None' in subJETCorrLevels: print '|---- jetToolbox: Subjet JEC levels given ( '+' '.join(subJETCorrLevels)+' ) are incorrect. Using the default levels: L1FastJet, L2Relative, L3Absolute.'
			subJETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
		print '|---- jetToolBox: Applying these subjet corrections: ( '+subJETCorrPayload+', '+' '.join(subJETCorrLevels)+' )'
		subJEC = ( subJETCorrPayload, subJETCorrLevels , 'None')


	#################################################################################
	####### Toolbox start 
	#################################################################################

	elemToKeep = []
	jetSeq = cms.Sequence()
	genParticlesLabel = ''
	pvLabel = ''
	tvLabel = ''
	toolsUsed = []

	#### For MiniAOD
	if miniAOD:

		print '|---- jetToolBox: JETTOOLBOX RUNNING ON MiniAOD FOR '+jetALGO+' JETS USING '+PUMethod

		genParticlesLabel = 'prunedGenParticles'
		pvLabel = 'offlineSlimmedPrimaryVertices'
		svLabel = 'slimmedSecondaryVertices'
		tvLabel = 'unpackedTracksAndVertices'
		pfCand = 'packedPFCandidates'

		setattr( proc, 'chs', cms.EDFilter('CandPtrSelector', src = cms.InputTag('packedPFCandidates'), cut = cms.string('fromPV')) )
		jetSeq += getattr(proc, 'chs')


		## Filter out neutrinos from packed GenParticles
		setattr( proc, 'packedGenParticlesForJetsNoNu', 
				cms.EDFilter("CandPtrSelector", 
					src = cms.InputTag("packedGenParticles"), 
					cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
					))
		jetSeq += getattr(proc, 'packedGenParticlesForJetsNoNu' )
		    
		setattr( proc, jetalgo+'GenJetsNoNu', 
				ak4GenJets.clone( src = 'packedGenParticlesForJetsNoNu', 
					rParam = jetSize, 
					jetAlgorithm = algorithm ) ) 
		jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )
		#fixedGridRhoFastjetAll.pfCandidatesTag = 'packedPFCandidates'

		#for Inclusive Vertex Finder
		proc.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')

	#### For AOD
	else:
		print '|---- jetToolBox: JETTOOLBOX RUNNING ON AOD FOR '+jetALGO+' JETS USING '+PUMethod

		genParticlesLabel = 'genParticles'
		pvLabel = 'offlinePrimaryVertices'
		tvLabel = 'generalTracks'
		pfCand = 'particleFlow'
		svLabel = 'inclusiveSecondaryVertices'

		proc.load('RecoJets.Configuration.GenJetParticles_cff')
		proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
		setattr( proc, jetalgo+'GenJetsNoNu', ak4GenJets.clone( src = 'genParticlesForJetsNoNu', rParam = jetSize, jetAlgorithm = algorithm ) ) 
		jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )
		
		

	## b-tag discriminators
	bTagDiscriminators = [
			'pfTrackCountingHighEffBJetTags',
			'pfTrackCountingHighPurBJetTags',
			'pfJetProbabilityBJetTags',
			'pfJetBProbabilityBJetTags',
			'pfSimpleSecondaryVertexHighEffBJetTags',
			'pfSimpleSecondaryVertexHighPurBJetTags',
			'pfCombinedSecondaryVertexBJetTags',
			'pfCombinedInclusiveSecondaryVertexV2BJetTags'
	    ]

	####  Creating PATjets
	if 'Puppi' in PUMethod:

		proc.load('CommonTools.PileupAlgos.Puppi_cff')
		from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
		setattr( proc, jetalgo+'PFJetsPuppi', 
				ak4PFJetsPuppi.clone( doAreaFastjet = True, 
					rParam = jetSize, 
					jetAlgorithm = algorithm ) )  
		if miniAOD:
			puppi.candName = cms.InputTag('packedPFCandidates')
			puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
		jetSeq += getattr(proc, 'puppi' )
		jetSeq += getattr(proc, jetalgo+'PFJetsPuppi' )

	elif 'CS' in PUMethod:

		from RecoJets.JetProducers.ak4PFJetsCS_cfi import ak4PFJetsCS
		setattr( proc, jetalgo+'PFJetsCS', 
				ak4PFJetsCS.clone( doAreaFastjet = True, 
					csRParam = cms.double(jetSize),
					jetAlgorithm = algorithm ) ) 
		if miniAOD: getattr( proc, jetalgo+'PFJetsCS').src = 'chs'
		jetSeq += getattr(proc, jetalgo+'PFJetsCS' )

		#setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
		jetSeq += getattr(proc, jetalgo+'PFJetsCS' )

	elif 'SK' in PUMethod:

		proc.load('CommonTools.PileupAlgos.softKiller_cfi')
		from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK
		setattr( proc, jetalgo+'PFJetsSK', 
				ak4PFJetsSK.clone( rParam = jetSize, 
					jetAlgorithm = algorithm ) ) 
		if miniAOD: getattr( proc, 'softKiller' ).PFCandidates = cms.InputTag('packedPFCandidates')
		jetSeq += getattr(proc, 'softKiller' )
		jetSeq += getattr(proc, jetalgo+'PFJetsSK' )
	
	elif 'CHS' in PUMethod: 
		setattr( proc, jetalgo+'PFJetsCHS', 
				ak4PFJetsCHS.clone( 
					doAreaFastjet = True, 
					rParam = jetSize, 
					jetAlgorithm = algorithm ) ) 
		if miniAOD: getattr( proc, jetalgo+'PFJetsCHS').src = 'chs'
		jetSeq += getattr(proc, jetalgo+'PFJetsCHS' )
	else: 
		PUMethod = ''
		setattr( proc, jetalgo+'PFJets', 
				ak4PFJets.clone( 
					doAreaFastjet = True, 
					rParam = jetSize, 
					jetAlgorithm = algorithm ) ) 
		if miniAOD: getattr( proc, jetalgo+'PFJets').src = 'packedPFCandidates'
		jetSeq += getattr(proc, jetalgo+'PFJets' )

	#if miniAOD: setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', cms.EDFilter("MiniAODJetConstituentSelector", src = cms.InputTag( jetalgo+'PFJets'+PUMethod ), cut = cms.string( 'pt > 100.0 ' ) ))
	#else: setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', cms.EDFilter("PFJetConstituentSelector", src = cms.InputTag( jetalgo+'PFJets'+PUMethod ), cut = cms.string( Cut ) ))
	#jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Constituents' )

	addJetCollection(
			proc,
			labelName = jetALGO+'PF'+PUMethod,
			jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod),
			algo = jetalgo,
			rParam = jetSize,
			jetCorrections = JEC, #( 'AK'+size+'PFchs', cms.vstring( ['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
			pfCandidates = cms.InputTag( pfCand ),  #'packedPFCandidates'),
			svSource = cms.InputTag( svLabel ),   #'slimmedSecondaryVertices'),
			genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
			pvSource = cms.InputTag( pvLabel ), #'offlineSlimmedPrimaryVertices'),
			btagDiscriminators = bTagDiscriminators,
			outputModules = ['outputFile']
			) 

	getattr( proc, 'patJetCorrFactors'+jetALGO+'PF'+PUMethod ).primaryVertices = pvLabel  #'offlineSlimmedPrimaryVertices' 
	getattr( proc, 'jetTracksAssociatorAtVertex'+jetALGO+'PF'+PUMethod ).tracks = tvLabel  # 'unpackedTracksAndVertices'

	if 'CS' in PUMethod: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod ).getJetMCFlavour = False  
	else: getattr(proc,'patJetPartons').particles = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
	getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod).matched = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
	if miniAOD:
		if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod):
			    getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod).extSVCollection = cms.InputTag( svLabel ) #'slimmedSecondaryVertices')
		getattr(proc,'patJets'+jetALGO+'PF'+PUMethod).addAssociatedTracks = cms.bool(False) # needs to be disabled since there is no track collection present in MiniAOD
		getattr(proc,'patJets'+jetALGO+'PF'+PUMethod).addJetCharge = cms.bool(False)        # needs to be disabled since there is no track collection present in MiniAOD
	

	if addSoftDrop or addSoftDropSubjets: 

		setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDrop', 
			ak8PFJetsCHSSoftDrop.clone( 
				rParam = jetSize, 
				jetAlgorithm = algorithm, 
				useExplicitGhosts=True,
				zcut=zCutSD, 
				beta=betaCut,
				writeCompound = cms.bool(True),
				jetCollInstanceName=cms.string('SubJets') ) )
		if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDrop').src = 'chs'
		setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDropLinks', 
			ak8PFJetsCHSSoftDropLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop'), 
				distMax = cms.double( jetSize ) ) )

		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'SoftDropLinks_*_*'] 
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDrop' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDropLinks' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'SoftDropLinks']
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'SoftDropLinks' )

		if addSoftDropSubjets:

			setattr( proc, jetalgo+'GenJetsNoNuSoftDrop',
					ak4GenJets.clone(
						SubJetParameters,
						useSoftDrop = cms.bool(True),
						rParam = jetSize, 
						jetAlgorithm = algorithm, 
						useExplicitGhosts=cms.bool(True),
						#zcut=cms.double(zCutSD), 
						beta=cms.double(betaCut),
						writeCompound = cms.bool(True),
						jetCollInstanceName=cms.string('SubJets')
						))
			if miniAOD: getattr( proc, jetalgo+'GenJetsNoNuSoftDrop' ).src = 'packedGenParticlesForJetsNoNu'
			jetSeq += getattr(proc, jetalgo+'GenJetsNoNuSoftDrop' )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'SoftDrop',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop'),
					algo = jetalgo,
					rParam = jetSize,
					jetCorrections = JEC,
					btagDiscriminators = ['None'],
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
					getJetMCFlavour = False,
					outputModules = ['outputFile']
					) 
			getattr( proc, 'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'SoftDrop' ).primaryVertices = pvLabel  #'offlineSlimmedPrimaryVertices' 
			getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'SoftDrop').matched = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDrop', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'SoftDrop', cut = Cut ) )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'SoftDropSubjets',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop', 'SubJets'),
					algo = jetalgo,  # needed for subjet b tagging
					rParam = jetSize,  # needed for subjet b tagging
					jetCorrections = subJEC, 
					pfCandidates = cms.InputTag( pfCand ), 
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ),  
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuSoftDrop','SubJets'),
					getJetMCFlavour = False,
					explicitJTA = True,  # needed for subjet b tagging
					svClustering = True, # needed for subjet b tagging
					fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod),             # needed for subjet flavor clustering
					groomedFatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod+'SoftDrop'), # needed for subjet flavor clustering
					outputModules = ['outputFile']
					) 

			if miniAOD:
				getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').addAssociatedTracks = cms.bool(False) 
				getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').addJetCharge = cms.bool(False) 
				if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'SoftDropSubjets'):
					    getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').extSVCollection = cms.InputTag( svLabel ) 
			getattr(proc,'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'SoftDropSubjets' ).primaryVertices = pvLabel 
			getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').matched = cms.InputTag( genParticlesLabel ) 
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets', cut = Cut ))

			## Establish references between PATified fat jets and subjets using the BoostedJetMerger
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked', 
					cms.EDProducer("BoostedJetMerger",
						jetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDrop'),
						subjetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets')
						))
			jetSeq += getattr(proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked' )
			elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked_*_*' ]
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked' )
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets' )

	if addPruning or addPrunedSubjets: 

		setattr( proc, jetalgo+'PFJets'+PUMethod+'Pruned', 
			ak8PFJetsCHSPruned.clone( 
				rParam = jetSize, 
				jetAlgorithm = algorithm, 
				zcut=zCut, 
				rcut_factor=rCut,
				writeCompound = cms.bool(True),
				doAreaFastjet = cms.bool(True),
				jetCollInstanceName=cms.string('SubJets') ) )
		if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'Pruned').src = 'chs'
		setattr( proc, jetalgo+'PFJets'+PUMethod+'PrunedLinks', 
			ak8PFJetsCHSPrunedLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned'), 
				distMax = cms.double( jetSize ) ) )

		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Pruned' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'PrunedLinks' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'PrunedLinks']
		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'PrunedLinks_*_*'] 
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'PrunedLinks' )

		if addPrunedSubjets:
			setattr( proc, jetalgo+'GenJetsNoNuPruned',
					ak4GenJets.clone(
						SubJetParameters,
						rParam = jetSize,
						usePruning = cms.bool(True),
						writeCompound = cms.bool(True),
						jetCollInstanceName=cms.string('SubJets')
						))
			if miniAOD: getattr( proc, jetalgo+'GenJetsNoNuPruned' ).src = 'packedGenParticlesForJetsNoNu'
			jetSeq += getattr(proc, jetalgo+'GenJetsNoNuPruned' )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'Pruned',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned'),
					algo = jetalgo,
					rParam = jetSize,
					jetCorrections = JEC,
					btagDiscriminators = ['None'],
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
					getJetMCFlavour = False,
					outputModules = ['outputFile']
					) 
			getattr( proc, 'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'Pruned' ).primaryVertices = pvLabel  
			getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'Pruned').matched = cms.InputTag( genParticlesLabel ) 
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'Pruned', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'Pruned', cut = Cut ) )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'PrunedSubjets',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned', 'SubJets'),
					algo = jetalgo,  # needed for subjet b tagging
					rParam = jetSize,  # needed for subjet b tagging
					jetCorrections = subJEC,
					pfCandidates = cms.InputTag( pfCand ),  
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ), 
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuPruned','SubJets'),
					getJetMCFlavour = False,
					explicitJTA = True,  # needed for subjet b tagging
					svClustering = True, # needed for subjet b tagging
					fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod),             # needed for subjet flavor clustering
					groomedFatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod+'Pruned'), # needed for subjet flavor clustering
					outputModules = ['outputFile']
					) 

			getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'PrunedSubjets').matched = cms.InputTag( genParticlesLabel ) 
			getattr(proc,'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'PrunedSubjets' ).primaryVertices = pvLabel  
			if miniAOD:
				if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'PrunedSubjets'):
					getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'PrunedSubjets').extSVCollection = cms.InputTag( svLabel ) 
				getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets').addAssociatedTracks = cms.bool(False)
				getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets').addJetCharge = cms.bool(False) 
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets', cut = Cut ) )

			## Establish references between PATified fat jets and subjets using the BoostedJetMerger
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked', 
					cms.EDProducer("BoostedJetMerger",
						jetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'Pruned'),
						subjetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets')
						))
			jetSeq += getattr(proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked' )
			elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked_*_*' ]
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked' )
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets' )


	if addTrimming:

		setattr( proc, jetalgo+'PFJets'+PUMethod+'Trimmed', 
				ak8PFJetsCHSTrimmed.clone( #src = 'chs',
					rParam = jetSize, 
					jetAlgorithm = algorithm,
					rFilt= rFiltTrim,
					trimPtFracMin= ptFrac) ) 
		if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'Trimmed').src = 'chs'
		setattr( proc, jetalgo+'PFJets'+PUMethod+'TrimmedLinks', 
				ak8PFJetsCHSTrimmedLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
					matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Trimmed'), 
					distMax = cms.double( jetSize ) ) )

		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'TrimmedLinks_*_*'] 
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Trimmed' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'TrimmedLinks' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'TrimmedLinks']
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'TrimmedLinks' )

	if addFiltering:

		setattr( proc, jetalgo+'PFJets'+PUMethod+'Filtered', 
				ak8PFJetsCHSFiltered.clone( #src = 'chs', 
					rParam = jetSize, 
					jetAlgorithm = algorithm,
					rFilt= rfilt,
					nFilt= nfilt ) ) 
		if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'Filtered').src = 'chs'
		setattr( proc, jetalgo+'PFJets'+PUMethod+'FilteredLinks', 
				ak8PFJetsCHSFilteredLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
					matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Filtered'), 
					distMax = cms.double( jetSize ) ) )
		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'FilteredLinks_*_*'] 
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Filtered' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'FilteredLinks' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'FilteredLinks']
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'FilteredLinks' )

	if addCMSTopTagger :

		if 'CA' in jetALGO : 

			setattr( proc, 'cmsTopTagPFJets'+PUMethod,  
					cms.EDProducer("CATopJetProducer",
						PFJetParameters.clone( #src = cms.InputTag("chs"), #ak8PFJetsCHSConstituents", "constituents"),
							doAreaFastjet = cms.bool(True),
							doRhoFastjet = cms.bool(False),
							jetPtMin = cms.double(100.0)
							),
						AnomalousCellParameters,
						CATopJetParameters.clone( jetCollInstanceName = cms.string("SubJets"),
							verbose = cms.bool(False),
							algorithm = cms.int32(1), # 0 = KT, 1 = CA, 2 = anti-KT
							tagAlgo = cms.int32(0), #0=legacy top
							useAdjacency = cms.int32(2), # modified adjacency
							centralEtaCut = cms.double(2.5), # eta for defining "central" jets
							sumEtBins = cms.vdouble(0,1600,2600), # sumEt bins over which cuts vary. vector={bin 0 lower bound, bin 1 lower bound, ...}
							rBins = cms.vdouble(0.8,0.8,0.8), # Jet distance paramter R. R values depend on sumEt bins.
							ptFracBins = cms.vdouble(0.05,0.05,0.05), # minimum fraction of central jet pt for subjets (deltap)
							deltarBins = cms.vdouble(0.19,0.19,0.19), # Applicable only if useAdjacency=1. deltar adjacency values for each sumEtBin
							nCellBins = cms.vdouble(1.9,1.9,1.9),
							),
						jetAlgorithm = cms.string("CambridgeAachen"),
						rParam = cms.double(jetSize),
						writeCompound = cms.bool(True)
						)
					)
			if miniAOD: getattr( proc, 'cmsTopTagPFJets'+PUMethod ).src = 'chs'
			
			setattr( proc, "CATopTagInfos", 
					cms.EDProducer("CATopJetTagger",
						src = cms.InputTag('cmsTopTagPFJets'+PUMethod),
						TopMass = cms.double(171),
						TopMassMin = cms.double(0.),
						TopMassMax = cms.double(250.),
						WMass = cms.double(80.4),
						WMassMin = cms.double(0.0),
						WMassMax = cms.double(200.0),
						MinMassMin = cms.double(0.0),
						MinMassMax = cms.double(200.0),
						verbose = cms.bool(False)
						)
					)
			addJetCollection(
					proc,
					labelName = 'CMSTopTag'+PUMethod,
					jetSource = cms.InputTag('cmsTopTagPFJets'+PUMethod),
					jetCorrections = JEC,
					pfCandidates = cms.InputTag( pfCand ),  
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ), 
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag(jetalgo+'GenJetsNoNu'),
					getJetMCFlavour = False
					)
			getattr(proc,'patJetPartonMatchCMSTopTag'+PUMethod).matched = cms.InputTag( genParticlesLabel ) 
			if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod):
				getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod).extSVCollection = cms.InputTag( svLabel ) 
			getattr(proc,'patJetsCMSTopTag'+PUMethod).addTagInfos = True
			getattr(proc,'patJetsCMSTopTag'+PUMethod).tagInfoSources = cms.VInputTag( cms.InputTag('CATopTagInfos'))
			getattr(proc,'patJetCorrFactorsCMSTopTag'+PUMethod ).primaryVertices = pvLabel  
			getattr(proc,'patJetsCMSTopTag'+PUMethod).addAssociatedTracks = cms.bool(False)
			getattr(proc,'patJetsCMSTopTag'+PUMethod).addJetCharge = cms.bool(False)      
			setattr( proc, 'selectedPatJetsCMSTopTag'+PUMethod, selectedPatJets.clone( src = 'patJetsCMSTopTag'+PUMethod, cut = Cut ) )

			addJetCollection(
					proc,
					labelName = 'CMSTopTag'+PUMethod+'Subjets',
					jetSource = cms.InputTag('cmsTopTagPFJets'+PUMethod, 'SubJets'),
					algo = jetalgo,  # needed for subjet b tagging
					rParam = jetSize,  # needed for subjet b tagging
					jetCorrections = subJEC,
					pfCandidates = cms.InputTag( pfCand ),  
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ), 
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
					#getJetMCFlavour = False,
					explicitJTA = True,  # needed for subjet b tagging
					svClustering = True, # needed for subjet b tagging
					fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod),             # needed for subjet flavor clustering
					groomedFatJets=cms.InputTag('patJetsCMSTopTag'+PUMethod), # needed for subjet flavor clustering
					)

			getattr(proc,'patJetPartonMatchCMSTopTag'+PUMethod+'Subjets').matched = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
			if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod+'Subjets'):
				getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod+'Subjets').extSVCollection = cms.InputTag(svLabel) 
			getattr(proc,'patJetCorrFactorsCMSTopTag'+PUMethod+'Subjets' ).primaryVertices = pvLabel  
			getattr(proc,'patJetsCMSTopTag'+PUMethod+'Subjets').addAssociatedTracks = cms.bool(False)
			getattr(proc,'patJetsCMSTopTag'+PUMethod+'Subjets').addJetCharge = cms.bool(False)      
			setattr( proc, 'selectedPatJetsCMSTopTag'+PUMethod+'Subjets', selectedPatJets.clone( src = 'patJetsCMSTopTag'+PUMethod+'Subjets', cut = Cut ) )

			setattr( proc, 'patJetsCMSTopTag'+PUMethod+'Packed', 
					cms.EDProducer("BoostedJetMerger",
						jetSrc=cms.InputTag('patJetsCMSTopTag'+PUMethod ),
						subjetSrc=cms.InputTag('patJetsCMSTopTag'+PUMethod+'Subjets')
						))
			jetSeq += getattr(proc, 'patJetsCMSTopTag'+PUMethod+'Packed' )
			elemToKeep += [ 'keep *_patJetsCMSTopTag'+PUMethod+'Packed_*_*' ]
			toolsUsed.append( 'patJetsCMSTopTag'+PUMethod+'Packed' )

		else: print '|----- CMS recommends CambridgeAachen for CMS Top Tagger, you are using '+algorithm+'. JetToolbox will not run CMS Top Tagger.'

	if addMassDrop :

		if 'CA' in jetALGO : 
			setattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered', ca15PFJetsCHSMassDropFiltered.clone( rParam = jetSize ) )
			if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered').src = 'chs'
			setattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks', ak8PFJetsCHSPrunedLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag(jetalgo+'PFJets'+PUMethod+'MassDropFiltered'), distMax = cms.double( jetSize ) ) )
			elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks_*_*' ]
			getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks' ]
			jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered' )
			jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks' )
		else: print '|----- CMS recommends CambridgeAachen for Mass Drop, you are using '+algorithm+'. JetToolbox will not run Mass Drop.'
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks' )

	if addHEPTopTagger: 
		if ( jetSize >= 1. ) and ( 'CA' in jetALGO ): 

			if miniAOD: setattr( proc, 'hepTopTagPFJets'+PUMethod, hepTopTagPFJetsCHS.clone( src = 'chs' ) )
			else: 
				setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', ak8PFJetsCHSConstituents.clone( src = jetalgo+'PFJets'+PUMethod ) )
				setattr( proc, 'hepTopTagPFJets'+PUMethod, hepTopTagPFJetsCHS.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ) ) )
			setattr( proc, 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO, ak8PFJetsCHSPrunedLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag("hepTopTagPFJets"+PUMethod), distMax = cms.double( jetSize ) ) )
			elemToKeep += [ 'keep *_hepTopTagPFJets'+PUMethod+'Links'+jetALGO+'_*_*' ]
			getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO ]
			jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod )
			jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO )
			toolsUsed.append( 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO )
		else: print '|----- CMS recommends CambridgeAachen for HEPTopTagger, you are using '+algorithm+', and a jet cone size bigger than 1. JetToolbox will not run HEP TopTagger.'

	####### Nsubjettiness
	if addNsub:
		from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness

		rangeTau = range(1,maxTau+1)
		setattr( proc, 'Njettiness'+jetALGO+PUMethod, 
				Njettiness.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
					Njets=cms.vuint32(rangeTau),         # 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( jetSize ),              # 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

		elemToKeep += [ 'keep *_Njettiness'+jetALGO+PUMethod+'_*_*' ]
		for tau in rangeTau: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['Njettiness'+jetALGO+PUMethod+':tau'+str(tau) ] 
		jetSeq += getattr(proc, 'Njettiness'+jetALGO+PUMethod )
		toolsUsed.append( 'Njettiness'+jetALGO+PUMethod )

	###### QJetsAdder
	if addQJets:
		#This is the old way before 731
		### there must be a better way to do this random number introduction
		setattr( proc, 'RandomNumberGeneratorService', cms.Service("RandomNumberGeneratorService", 
							QJetsAdderCA8 = cms.PSet(initialSeed = cms.untracked.uint32(7)),
							QJetsAdderAK8 = cms.PSet(initialSeed = cms.untracked.uint32(31)),
							QJetsAdderCA15 = cms.PSet(initialSeed = cms.untracked.uint32(76)), ) )

		from RecoJets.JetProducers.qjetsadder_cfi import QJetsAdder
		setattr( proc, 'QJetsAdder'+jetALGO, 
				QJetsAdder.clone( src = cms.InputTag(jetalgo+'PFJets'+PUMethod), 
					jetRad = cms.double( jetSize ), 
					jetAlgo = cms.string( jetALGO[0:2] )))
		elemToKeep += [ 'keep *_QJetsAdder'+jetALGO+'_*_*' ]
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QJetsAdder'+jetALGO+':QjetsVolatility']  
		jetSeq += getattr(proc, 'QJetsAdder'+jetALGO )
		toolsUsed.append( 'QJetsAdder'+jetALGO )
		'''
		### This is for 731 or higher
		if 'ak4' in jetalgo:
			proc.load('RecoJets.JetProducers.QGTagger_cfi')
			proc.QGTagger.srcJets = cms.InputTag(jetalgo+'PFJets'+PUMethod)    # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
			proc.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs')        # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
			elemToKeep += [ 'keep *_QGTagger_*_*' ]
			getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QJetsAdder'+jetALGO+':qgLikelihood']  
			jetSeq += getattr(proc, 'QGTagger' )
		else:
			'QGTagger is optimized for ak4 jets.'
		'''

	setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod, selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod, cut = Cut ) )
	elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_*_*' ]
	elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_calo*_*' ]
	elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_tagInfos_*' ]

	print '|---- jetToolBox: Running '+', '.join(toolsUsed)+'.'

	### "return"
	setattr(proc, jetSequence, jetSeq)
	if hasattr(proc, outputFile): getattr(proc, outputFile).outputCommands += elemToKeep
	else: setattr( proc, outputFile, 
			cms.OutputModule('PoolOutputModule', 
				fileName = cms.untracked.string('jettoolbox.root'), 
				outputCommands = cms.untracked.vstring( elemToKeep ) ) )
예제 #4
0
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
예제 #5
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

        )
예제 #6
0
def jetToolbox( proc, jetType, jetSequence, outputFile, 
		newPFCollection=False, nameNewPFCollection = '',	
		PUMethod='CHS',                    #### Options: Puppi, CS, SK, Plain
		miniAOD=True,
		runOnMC=True,
		JETCorrPayload='', JETCorrLevels = [ 'None' ], GetJetMCFlavour=True,
		Cut = '', 
		bTagDiscriminators = None, 
		subJETCorrPayload='', subJETCorrLevels = [ 'None' ], GetSubjetMCFlavour=False,
		CutSubjet = '', 
		addPruning=False, zCut=0.1, rCut=0.5, addPrunedSubjets=False,
		addSoftDrop=False, betaCut=0.0,  zCutSD=0.1, addSoftDropSubjets=False,
		addTrimming=False, rFiltTrim=0.2, ptFrac=0.03,
		addFiltering=False, rfilt=0.3, nfilt=3,
		addCMSTopTagger=False,
		addMassDrop=False,
		addHEPTopTagger=False,
		addNsub=False, maxTau=4,
		addPUJetID=False,
		addQJets=False,
		addQGTagger=False, QGjetsLabel='chs',
		addEnergyCorrFunc=False, ecfBeta = 1.0, maxECF=3,
		):

	runOnData = not runOnMC
	if runOnData:
		GetJetMCFlavour = False
		GetSubjetMCFlavour = False
	
	###############################################################################
	#######  Verifying some inputs and defining variables
	###############################################################################
	print '|---- jetToolbox: Initialyzing collection...'
	if newPFCollection: print '|---- jetToolBox: Using '+ nameNewPFCollection +' as PFCandidates collection'
	supportedJetAlgos = { 'ak': 'AntiKt', 'ca' : 'CambridgeAachen', 'kt' : 'Kt' }
	recommendedJetAlgos = [ 'ak4', 'ak8', 'ca4', 'ca8', 'ca10' ]
	payloadList = [ 'None',
			'AK1PFchs', 'AK2PFchs', 'AK3PFchs', 'AK4PFchs', 'AK5PFchs', 'AK6PFchs', 'AK7PFchs', 'AK8PFchs', 'AK9PFchs', 'AK10PFchs',
			'AK1PFPUPPI', 'AK2PFPUPPI', 'AK3PFPUPPI', 'AK4PFPUPPI', 'AK5PFPUPPI', 'AK6PFPUPPI', 'AK7PFPUPPI', 'AK8PFPUPPI', 'AK9PFPUPPI', 'AK10PFPUPPI',  
			'AK1PFSK', 'AK2PFSK', 'AK3PFSK', 'AK4PFSK', 'AK5PFSK', 'AK6PFSK', 'AK7PFSK', 'AK8PFSK', 'AK9PFSK', 'AK10PFSK',  
			'AK1PF', 'AK2PF', 'AK3PF', 'AK4PF', 'AK5PF', 'AK6PF', 'AK7PF', 'AK8PF', 'AK9PF', 'AK10PF' ]
	JECLevels = [ 'L1Offset', 'L1FastJet', 'L1JPTOffset', 'L2Relative', 'L3Absolute', 'L5Falvour', 'L7Parton' ]
	if runOnData:
		JECLevels += ['L2L3Residual']
	jetAlgo = ''
	algorithm = ''
	size = ''
	for type, tmpAlgo in supportedJetAlgos.iteritems(): 
		if type in jetType.lower():
			jetAlgo = type
			algorithm = tmpAlgo
			size = jetType.replace( type, '' )

	jetSize = 0.
	if int(size) in range(0, 20): jetSize = int(size)/10.
	else: print '|---- jetToolBox: jetSize has not a valid value. Insert a number between 1 and 20 after algorithm, like: AK8'
	### Trick for uppercase/lowercase algo name
	jetALGO = jetAlgo.upper()+size
	jetalgo = jetAlgo.lower()+size
	if jetalgo not in recommendedJetAlgos: print '|---- jetToolBox: CMS recommends the following jet algoritms: '+' '.join(recommendedJetAlgos)+'. You are using', jetalgo,'.'


	#################################################################################
	####### Toolbox start 
	#################################################################################

	elemToKeep = []
	jetSeq = cms.Sequence()
	genParticlesLabel = ''
	pvLabel = ''
	tvLabel = ''
	toolsUsed = []

	#### For MiniAOD
	if miniAOD:

		print '|---- jetToolBox: JETTOOLBOX RUNNING ON MiniAOD FOR '+jetALGO+' JETS USING '+PUMethod

		genParticlesLabel = 'prunedGenParticles'
		pvLabel = 'offlineSlimmedPrimaryVertices'
		svLabel = 'slimmedSecondaryVertices'
		tvLabel = 'unpackedTracksAndVertices'
		pfCand = nameNewPFCollection if newPFCollection else 'packedPFCandidates'

		if runOnMC:
			## Filter out neutrinos from packed GenParticles
			setattr( proc, 'packedGenParticlesForJetsNoNu', 
					cms.EDFilter("CandPtrSelector", 
						src = cms.InputTag("packedGenParticles"), 
						cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
						))
			jetSeq += getattr(proc, 'packedGenParticlesForJetsNoNu' )

			setattr( proc, jetalgo+'GenJetsNoNu', 
					ak4GenJets.clone( src = 'packedGenParticlesForJetsNoNu', 
						rParam = jetSize, 
						jetAlgorithm = algorithm ) ) 
			jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )

		#for Inclusive Vertex Finder
		proc.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')

	#### For AOD
	else:
		print '|---- jetToolBox: JETTOOLBOX RUNNING ON AOD FOR '+jetALGO+' JETS USING '+PUMethod

		genParticlesLabel = 'genParticles'
		pvLabel = 'offlinePrimaryVertices'
		tvLabel = 'generalTracks'
		pfCand =  nameNewPFCollection if newPFCollection else 'particleFlow'
		svLabel = 'inclusiveCandidateSecondaryVertices'

		if runOnMC:
			proc.load('RecoJets.Configuration.GenJetParticles_cff')
			setattr( proc, jetalgo+'GenJetsNoNu', ak4GenJets.clone( src = 'genParticlesForJetsNoNu', rParam = jetSize, jetAlgorithm = algorithm ) ) 
			jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )
		
		

	## b-tag discriminators
	if bTagDiscriminators is None:
		bTagDiscriminators = [
				'pfTrackCountingHighEffBJetTags',
				'pfTrackCountingHighPurBJetTags',
				'pfJetProbabilityBJetTags',
				'pfJetBProbabilityBJetTags',
				'pfSimpleSecondaryVertexHighEffBJetTags',
				'pfSimpleSecondaryVertexHighPurBJetTags',
				'pfCombinedSecondaryVertexV2BJetTags',
				'pfCombinedInclusiveSecondaryVertexV2BJetTags'
	    	]

	### Jet Corrections
	if not set(JETCorrLevels).issubset(set(JECLevels)): 
		if ( 'CHS' in PUMethod ) or  ( 'Plain' in PUMethod ): JETCorrLevels = ['L1FastJet','L2Relative', 'L3Absolute']
		else: JETCorrLevels = [ 'L2Relative', 'L3Absolute']
		if runOnData: JETCorrLevels.append('L2L3Residual')
	if not set(subJETCorrLevels).issubset(set(JECLevels)): 
		if ( 'CHS' in PUMethod ) or  ( 'Plain' in PUMethod ): subJETCorrLevels = ['L1FastJet','L2Relative', 'L3Absolute']
		else: subJETCorrLevels = [ 'L2Relative', 'L3Absolute']
		if runOnData: subJETCorrLevels.append('L2L3Residual')

	####  Creating PATjets
	tmpPfCandName = pfCand.lower()
	if 'Puppi' in PUMethod:
		if ('puppi' in tmpPfCandName): 
			srcForPFJets = pfCand
			print '|---- jetToolBox: Not running puppi algorithm because keyword puppi was specified in nameNewPFCollection, but applying puppi corrections.' 
		else: 
			proc.load('CommonTools.PileupAlgos.Puppi_cff')
			puppi.candName = cms.InputTag( pfCand ) 
			if miniAOD: puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
			jetSeq += getattr(proc, 'puppi' )
			srcForPFJets = 'puppi'
		from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
		setattr( proc, jetalgo+'PFJetsPuppi', 
				ak4PFJetsPuppi.clone( src = cms.InputTag( srcForPFJets ),
					doAreaFastjet = True, 
					rParam = jetSize, 
					jetAlgorithm = algorithm ) )  
		jetSeq += getattr(proc, jetalgo+'PFJetsPuppi' )
		if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFPuppi'
		if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFPuppi'

	elif 'CS' in PUMethod:

		from RecoJets.JetProducers.ak4PFJetsCS_cfi import ak4PFJetsCS
		setattr( proc, jetalgo+'PFJetsCS', 
				ak4PFJetsCS.clone( doAreaFastjet = True, 
					csRParam = cms.double(jetSize),
					jetAlgorithm = algorithm ) ) 
		if miniAOD: getattr( proc, jetalgo+'PFJetsCS').src = pfCand
		#setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
		jetSeq += getattr(proc, jetalgo+'PFJetsCS' )

		#setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
		jetSeq += getattr(proc, jetalgo+'PFJetsCS' )
		if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFCS'
		if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFCS'

	elif 'SK' in PUMethod:

		if ('sk' in tmpPfCandName): 
			srcForPFJets = pfCand
			print '|---- jetToolBox: Not running softkiller algorithm because keyword SK was specified in nameNewPFCollection, but applying SK corrections.' 
		else:
			proc.load('CommonTools.PileupAlgos.softKiller_cfi')
			getattr( proc, 'softKiller' ).PFCandidates = cms.InputTag( pfCand ) 
			jetSeq += getattr(proc, 'softKiller' )
			srcForPFJets = 'softKiller'
		from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK
		setattr( proc, jetalgo+'PFJetsSK', 
				ak4PFJetsSK.clone(  src = cms.InputTag( srcForPFJets ),
					rParam = jetSize, 
					jetAlgorithm = algorithm ) ) 
		jetSeq += getattr(proc, jetalgo+'PFJetsSK' )
		if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFSK'
		if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFSK'
	
	elif 'CHS' in PUMethod: 
		
		if miniAOD:
			if ('chs' in tmpPfCandName): 
				srcForPFJets = pfCand
				print '|---- jetToolBox: Not running CHS algorithm because keyword CHS was specified in nameNewPFCollection, but applying CHS corrections.' 
			else: 
				setattr( proc, 'chs', cms.EDFilter('CandPtrSelector', src = cms.InputTag( pfCand ), cut = cms.string('fromPV')) )
				jetSeq += getattr(proc, 'chs')
				srcForPFJets = 'chs'
		else:
			if ( pfCand == 'particleFlow' ):
				from RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi import particleFlowTmpPtrs
				setattr( proc, 'newParticleFlowTmpPtrs', particleFlowTmpPtrs.clone( src = pfCand ) )
				jetSeq += getattr(proc, 'newParticleFlowTmpPtrs')
				from CommonTools.ParticleFlow.pfNoPileUpJME_cff import pfPileUpJME, pfNoPileUpJME
				proc.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi')
				setattr( proc, 'newPfPileUpJME', pfPileUpJME.clone( PFCandidates= 'newParticleFlowTmpPtrs' ) )
				jetSeq += getattr(proc, 'newPfPileUpJME')
				setattr( proc, 'newPfNoPileUpJME', pfNoPileUpJME.clone( topCollection='newPfPileUpJME', bottomCollection= 'newParticleFlowTmpPtrs' ) )
				jetSeq += getattr(proc, 'newPfNoPileUpJME')
				srcForPFJets = 'newPfNoPileUpJME'
			else: 
				proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
				srcForPFJets = 'pfNoPileUpJME'
			

		setattr( proc, jetalgo+'PFJetsCHS', 
				ak4PFJetsCHS.clone( src = cms.InputTag( srcForPFJets ), 
					doAreaFastjet = True, 
					rParam = jetSize, 
					jetAlgorithm = algorithm ) ) 
		jetSeq += getattr(proc, jetalgo+'PFJetsCHS' )
		if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFchs'
		if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFchs'

	else: 
		PUMethod = ''
		setattr( proc, jetalgo+'PFJets', 
				ak4PFJets.clone( 
					doAreaFastjet = True, 
					rParam = jetSize, 
					jetAlgorithm = algorithm ) ) 
		if miniAOD: getattr( proc, jetalgo+'PFJets').src = pfCand
		jetSeq += getattr(proc, jetalgo+'PFJets' )
		if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PF'
		if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PF'

	if 'None' in JETCorrPayload: JEC = None
	else: JEC = ( JETCorrPayload.replace('CS','chs').replace('SK','chs') , JETCorrLevels, 'None' )   ### temporary
	#else: JEC = ( JETCorrPayload., JETCorrLevels, 'None' ) 
	print '|---- jetToolBox: Applying this corrections: '+str(JEC)

	if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger:
		if 'None' in subJETCorrPayload: subJEC = None
		else: subJEC = ( subJETCorrPayload.replace('CS','chs').replace('SK','chs') , subJETCorrLevels, 'None' )   ### temporary


	if ( 'CHS' in PUMethod ) and miniAOD: setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', cms.EDFilter("MiniAODJetConstituentSelector", src = cms.InputTag( jetalgo+'PFJets'+PUMethod ), cut = cms.string( Cut ) ))
	else: setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', cms.EDFilter("PFJetConstituentSelector", src = cms.InputTag( jetalgo+'PFJets'+PUMethod ), cut = cms.string( Cut ) ))
	jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Constituents' )

	addJetCollection(
			proc,
			labelName = jetALGO+'PF'+PUMethod,
			jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod),
			algo = jetalgo,
			rParam = jetSize,
			jetCorrections = JEC if JEC is not None else None, 
			pfCandidates = cms.InputTag( pfCand ),  
			svSource = cms.InputTag( svLabel ),  
			genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
			pvSource = cms.InputTag( pvLabel ), 
			btagDiscriminators = bTagDiscriminators,
			getJetMCFlavour = GetJetMCFlavour,
			genParticles = cms.InputTag(genParticlesLabel),
			outputModules = ['outputFile']
			) 


	if 'CS' in PUMethod: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod ).getJetMCFlavour = False  # CS jets cannot be re-clustered from their constituents
	
	#### Groomers
	if addSoftDrop or addSoftDropSubjets: 

		setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDrop', 
			ak8PFJetsCHSSoftDrop.clone( 
				src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
				rParam = jetSize, 
				jetAlgorithm = algorithm, 
				useExplicitGhosts=True,
				R0= cms.double(jetSize),
				#zcut=zCutSD, 
				beta=betaCut,
				writeCompound = cms.bool(True),
				jetCollInstanceName=cms.string('SubJets') ) )
		setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDropMass', 
			ak8PFJetsCHSSoftDropMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop'), 
				distMax = cms.double( jetSize ) ) )

		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'SoftDropMass_*_*'] 
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDrop' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDropMass' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'SoftDropMass']
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'SoftDropMass' )

		if addSoftDropSubjets:

			if runOnMC:
				setattr( proc, jetalgo+'GenJetsNoNuSoftDrop',
						ak4GenJets.clone(
							SubJetParameters,
							useSoftDrop = cms.bool(True),
							rParam = jetSize, 
							jetAlgorithm = algorithm, 
							useExplicitGhosts=cms.bool(True),
							#zcut=cms.double(zCutSD), 
							R0= cms.double(jetSize),
							beta=cms.double(betaCut),
							writeCompound = cms.bool(True),
							jetCollInstanceName=cms.string('SubJets')
							))
				if miniAOD: getattr( proc, jetalgo+'GenJetsNoNuSoftDrop' ).src = 'packedGenParticlesForJetsNoNu'
				jetSeq += getattr(proc, jetalgo+'GenJetsNoNuSoftDrop' )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'SoftDrop',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop'),
					algo = jetalgo,
					rParam = jetSize,
					jetCorrections = JEC if JEC is not None else None, 
					pvSource = cms.InputTag( pvLabel ),
					btagDiscriminators = ['None'],
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
					getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
					genParticles = cms.InputTag(genParticlesLabel),
					outputModules = ['outputFile']
					) 

			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDrop', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'SoftDrop', cut = Cut ) )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'SoftDropSubjets',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop', 'SubJets'),
					algo = jetalgo,  # needed for subjet b tagging
					rParam = jetSize,  # needed for subjet b tagging
					jetCorrections = subJEC if subJEC is not None else None, 
					pfCandidates = cms.InputTag( pfCand ), 
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ),  
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuSoftDrop','SubJets'),
					getJetMCFlavour = GetSubjetMCFlavour,
					genParticles = cms.InputTag(genParticlesLabel),
					explicitJTA = True,  # needed for subjet b tagging
					svClustering = True, # needed for subjet b tagging
					fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod),             # needed for subjet flavor clustering
					groomedFatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod+'SoftDrop'), # needed for subjet flavor clustering
					outputModules = ['outputFile']
					) 

			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets', cut = Cut ))

			## Establish references between PATified fat jets and subjets using the BoostedJetMerger
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked', 
					cms.EDProducer("BoostedJetMerger",
						jetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDrop'),
						subjetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets')
						))
			jetSeq += getattr(proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked' )
			elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked_*_*' ]
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked' )
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets' )

	if addPruning or addPrunedSubjets: 

		setattr( proc, jetalgo+'PFJets'+PUMethod+'Pruned', 
			ak8PFJetsCHSPruned.clone( 
				src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
				rParam = jetSize, 
				jetAlgorithm = algorithm, 
				zcut=zCut, 
				rcut_factor=rCut,
				writeCompound = cms.bool(True),
				doAreaFastjet = cms.bool(True),
				jetCollInstanceName=cms.string('SubJets') ) )
		setattr( proc, jetalgo+'PFJets'+PUMethod+'PrunedMass', 
			ak8PFJetsCHSPrunedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned'), 
				distMax = cms.double( jetSize ) ) )

		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Pruned' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'PrunedMass' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'PrunedMass']
		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'PrunedMass_*_*'] 
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'PrunedMass' )

		if addPrunedSubjets:
			if runOnMC:
				setattr( proc, jetalgo+'GenJetsNoNuPruned',
						ak4GenJets.clone(
							SubJetParameters,
							rParam = jetSize,
							usePruning = cms.bool(True),
							writeCompound = cms.bool(True),
							jetCollInstanceName=cms.string('SubJets')
							))
				if miniAOD: getattr( proc, jetalgo+'GenJetsNoNuPruned' ).src = 'packedGenParticlesForJetsNoNu'
				jetSeq += getattr(proc, jetalgo+'GenJetsNoNuPruned' )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'Pruned',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned'),
					algo = jetalgo,
					rParam = jetSize,
					jetCorrections = JEC if JEC is not None else None, 
					pvSource = cms.InputTag( pvLabel ),
					btagDiscriminators = ['None'],
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
					getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
					genParticles = cms.InputTag(genParticlesLabel),
					outputModules = ['outputFile']
					) 

			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'Pruned', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'Pruned', cut = Cut ) )

			addJetCollection(
					proc,
					labelName = jetALGO+'PF'+PUMethod+'PrunedSubjets',
					jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned', 'SubJets'),
					algo = jetalgo,  # needed for subjet b tagging
					rParam = jetSize,  # needed for subjet b tagging
					jetCorrections = subJEC if subJEC is not None else None, 
					pfCandidates = cms.InputTag( pfCand ),  
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ), 
					getJetMCFlavour = GetSubjetMCFlavour,
					genParticles = cms.InputTag(genParticlesLabel),
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuPruned','SubJets'),
					explicitJTA = True,  # needed for subjet b tagging
					svClustering = True, # needed for subjet b tagging
					fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod),             # needed for subjet flavor clustering
					groomedFatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod+'Pruned'), # needed for subjet flavor clustering
					outputModules = ['outputFile']
					) 

			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets', cut = Cut ) )

			## Establish references between PATified fat jets and subjets using the BoostedJetMerger
			setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked', 
					cms.EDProducer("BoostedJetMerger",
						jetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'Pruned'),
						subjetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets')
						))
			jetSeq += getattr(proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked' )
			elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked_*_*' ]
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked' )
			toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets' )


	if addTrimming:

		setattr( proc, jetalgo+'PFJets'+PUMethod+'Trimmed', 
				ak8PFJetsCHSTrimmed.clone( 
					rParam = jetSize, 
					src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents'),
					jetAlgorithm = algorithm,
					rFilt= rFiltTrim,
					trimPtFracMin= ptFrac) ) 
		setattr( proc, jetalgo+'PFJets'+PUMethod+'TrimmedMass', 
				ak8PFJetsCHSTrimmedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
					matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Trimmed'), 
					distMax = cms.double( jetSize ) ) )

		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'TrimmedMass_*_*'] 
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Trimmed' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'TrimmedMass' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'TrimmedMass']
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'TrimmedMass' )

	if addFiltering:

		setattr( proc, jetalgo+'PFJets'+PUMethod+'Filtered', 
				ak8PFJetsCHSFiltered.clone( 
					src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
					rParam = jetSize, 
					jetAlgorithm = algorithm,
					rFilt= rfilt,
					nFilt= nfilt ) ) 
		setattr( proc, jetalgo+'PFJets'+PUMethod+'FilteredMass', 
				ak8PFJetsCHSFilteredMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
					matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Filtered'), 
					distMax = cms.double( jetSize ) ) )
		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'FilteredMass_*_*'] 
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Filtered' )
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'FilteredMass' )
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'FilteredMass']
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'FilteredMass' )

	if addCMSTopTagger :

		if 'CA' in jetALGO : 

			setattr( proc, 'cmsTopTagPFJets'+PUMethod,  
					cms.EDProducer("CATopJetProducer",
						PFJetParameters.clone( 
							src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
							doAreaFastjet = cms.bool(True),
							doRhoFastjet = cms.bool(False),
							jetPtMin = cms.double(100.0)
							),
						AnomalousCellParameters,
						CATopJetParameters.clone( jetCollInstanceName = cms.string("SubJets"),
							verbose = cms.bool(False),
							algorithm = cms.int32(1), # 0 = KT, 1 = CA, 2 = anti-KT
							tagAlgo = cms.int32(0), #0=legacy top
							useAdjacency = cms.int32(2), # modified adjacency
							centralEtaCut = cms.double(2.5), # eta for defining "central" jets
							sumEtBins = cms.vdouble(0,1600,2600), # sumEt bins over which cuts vary. vector={bin 0 lower bound, bin 1 lower bound, ...}
							rBins = cms.vdouble(0.8,0.8,0.8), # Jet distance paramter R. R values depend on sumEt bins.
							ptFracBins = cms.vdouble(0.05,0.05,0.05), # minimum fraction of central jet pt for subjets (deltap)
							deltarBins = cms.vdouble(0.19,0.19,0.19), # Applicable only if useAdjacency=1. deltar adjacency values for each sumEtBin
							nCellBins = cms.vdouble(1.9,1.9,1.9),
							),
						jetAlgorithm = cms.string("CambridgeAachen"),
						rParam = cms.double(jetSize),
						writeCompound = cms.bool(True)
						)
					)
			
			setattr( proc, "CATopTagInfos", 
					cms.EDProducer("CATopJetTagger",
						src = cms.InputTag('cmsTopTagPFJets'+PUMethod),
						TopMass = cms.double(171),
						TopMassMin = cms.double(0.),
						TopMassMax = cms.double(250.),
						WMass = cms.double(80.4),
						WMassMin = cms.double(0.0),
						WMassMax = cms.double(200.0),
						MinMassMin = cms.double(0.0),
						MinMassMax = cms.double(200.0),
						verbose = cms.bool(False)
						)
					)
			addJetCollection(
					proc,
					labelName = 'CMSTopTag'+PUMethod,
					jetSource = cms.InputTag('cmsTopTagPFJets'+PUMethod),
					jetCorrections = JEC if JEC is not None else None, 
					pfCandidates = cms.InputTag( pfCand ),  
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ), 
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag(jetalgo+'GenJetsNoNu'),
					getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
					genParticles = cms.InputTag(genParticlesLabel)
					)
			getattr(proc,'patJetsCMSTopTag'+PUMethod).addTagInfos = True
			getattr(proc,'patJetsCMSTopTag'+PUMethod).tagInfoSources = cms.VInputTag( cms.InputTag('CATopTagInfos'))
			setattr( proc, 'selectedPatJetsCMSTopTag'+PUMethod, selectedPatJets.clone( src = 'patJetsCMSTopTag'+PUMethod, cut = Cut ) )

			addJetCollection(
					proc,
					labelName = 'CMSTopTag'+PUMethod+'Subjets',
					jetSource = cms.InputTag('cmsTopTagPFJets'+PUMethod, 'SubJets'),
					algo = jetalgo,  # needed for subjet b tagging
					rParam = jetSize,  # needed for subjet b tagging
					jetCorrections = subJEC if subJEC is not None else None, 
					pfCandidates = cms.InputTag( pfCand ),  
					pvSource = cms.InputTag( pvLabel), 
					svSource = cms.InputTag( svLabel ), 
					btagDiscriminators = bTagDiscriminators,
					genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
					getJetMCFlavour = GetSubjetMCFlavour,
					explicitJTA = True,  # needed for subjet b tagging
					svClustering = True, # needed for subjet b tagging
					fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod),             # needed for subjet flavor clustering
					groomedFatJets=cms.InputTag('patJetsCMSTopTag'+PUMethod), # needed for subjet flavor clustering
					genParticles = cms.InputTag(genParticlesLabel)
					)

			setattr( proc, 'selectedPatJetsCMSTopTag'+PUMethod+'Subjets', selectedPatJets.clone( src = 'patJetsCMSTopTag'+PUMethod+'Subjets', cut = Cut ) )

			setattr( proc, 'patJetsCMSTopTag'+PUMethod+'Packed', 
					cms.EDProducer("BoostedJetMerger",
						jetSrc=cms.InputTag('patJetsCMSTopTag'+PUMethod ),
						subjetSrc=cms.InputTag('patJetsCMSTopTag'+PUMethod+'Subjets')
						))
			jetSeq += getattr(proc, 'patJetsCMSTopTag'+PUMethod+'Packed' )
			elemToKeep += [ 'keep *_patJetsCMSTopTag'+PUMethod+'Packed_*_*' ]
			toolsUsed.append( 'patJetsCMSTopTag'+PUMethod+'Packed' )

		else: print '|---- jetToolBox: CMS recommends CambridgeAachen for CMS Top Tagger, you are using '+algorithm+'. JetToolbox will not run CMS Top Tagger.'

	if addMassDrop :

		if 'CA' in jetALGO : 
			setattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered', 
					ca15PFJetsCHSMassDropFiltered.clone( 
						rParam = jetSize,
						src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
						) )
			setattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass', ak8PFJetsCHSPrunedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag(jetalgo+'PFJets'+PUMethod+'MassDropFiltered'), distMax = cms.double( jetSize ) ) )
			elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass_*_*' ]
			getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass' ]
			jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered' )
			jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass' )
		else: print '|---- jetToolBox: CMS recommends CambridgeAachen for Mass Drop, you are using '+algorithm+'. JetToolbox will not run Mass Drop.'
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass' )

	if addHEPTopTagger: 
		if ( jetSize >= 1. ) and ( 'CA' in jetALGO ): 

			setattr( proc, 'hepTopTagPFJets'+PUMethod, hepTopTagPFJetsCHS.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ) ) )
			setattr( proc, 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO, ak8PFJetsCHSPrunedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
				matched = cms.InputTag("hepTopTagPFJets"+PUMethod), distMax = cms.double( jetSize ) ) )
			elemToKeep += [ 'keep *_hepTopTagPFJets'+PUMethod+'Mass'+jetALGO+'_*_*' ]
			getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO ]
			jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod )
			jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO )
			toolsUsed.append( 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO )
		else: print '|---- jetToolBox: CMS recommends CambridgeAachen for HEPTopTagger, you are using '+algorithm+', and a jet cone size bigger than 1. JetToolbox will not run HEP TopTagger.'

	####### Nsubjettiness
	if addNsub:
		from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness

		rangeTau = range(1,maxTau+1)
		setattr( proc, 'Njettiness'+jetALGO+PUMethod, 
				Njettiness.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod), 
					Njets=cms.vuint32(rangeTau),         # 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( jetSize ),              # 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

		elemToKeep += [ 'keep *_Njettiness'+jetALGO+PUMethod+'_*_*' ]
		for tau in rangeTau: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['Njettiness'+jetALGO+PUMethod+':tau'+str(tau) ] 
		jetSeq += getattr(proc, 'Njettiness'+jetALGO+PUMethod )
		toolsUsed.append( 'Njettiness'+jetALGO+PUMethod )

	###### QJetsAdder
	'''
	if addQJets:
		### there must be a better way to do this random number introduction
		setattr( proc, 'RandomNumberGeneratorService', cms.Service("RandomNumberGeneratorService", 
							QJetsAdderCA8 = cms.PSet(initialSeed = cms.untracked.uint32(7)),
							QJetsAdderAK8 = cms.PSet(initialSeed = cms.untracked.uint32(31)),
							QJetsAdderCA15 = cms.PSet(initialSeed = cms.untracked.uint32(76)), ) )

		from RecoJets.JetProducers.qjetsadder_cfi import QJetsAdder
		setattr( proc, 'QJetsAdder'+jetALGO, 
				QJetsAdder.clone( src = cms.InputTag(jetalgo+'PFJets'+PUMethod), 
					jetRad = cms.double( jetSize ), 
					jetAlgo = cms.string( jetALGO[0:2] )))
		elemToKeep += [ 'keep *_QJetsAdder'+jetALGO+'_*_*' ]
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QJetsAdder'+jetALGO+':QjetsVolatility']  
		jetSeq += getattr(proc, 'QJetsAdder'+jetALGO )
		toolsUsed.append( 'QJetsAdder'+jetALGO )
	'''

	###### QGTagger
	if addQGTagger:
		if ( 'ak4' in jetalgo ) and ( PUMethod not in ['Puppi','CS','SK'] ) :
			from RecoJets.JetProducers.QGTagger_cfi import QGTagger
			proc.load('RecoJets.JetProducers.QGTagger_cfi') 	## In 74X you need to run some stuff before.
			setattr( proc, 'QGTagger'+jetALGO+'PF'+PUMethod, 
					QGTagger.clone(
						srcJets = cms.InputTag(jetalgo+'PFJets'+PUMethod),    # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
						jetsLabel = cms.string('QGL_AK4PF'+QGjetsLabel)        # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
						)
					)
			elemToKeep += [ 'keep *_QGTagger'+jetALGO+'PF'+PUMethod+'_*_*' ]
			getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QGTagger'+jetALGO+'PF'+PUMethod+':qgLikelihood']  
			jetSeq += getattr(proc, 'QGTagger'+jetALGO+'PF'+PUMethod )

                        toolsUsed.append( 'QGTagger'+jetALGO+'PF'+PUMethod )
		else:
			print '|---- jetToolBox: QGTagger is optimized for ak4 jets with CHS. NOT running QGTagger'

			
	####### Pileup JetID
        if addPUJetID:
                if ( 'ak4' in jetalgo ) and ( 'CHS' in PUMethod ):
                        from RecoJets.JetProducers.pileupjetidproducer_cfi import pileupJetIdCalculator,pileupJetIdEvaluator

			setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdCalculator',
					pileupJetIdCalculator.clone(
						jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
						rho = cms.InputTag("fixedGridRhoFastjetAll"),
						vertexes = cms.InputTag(pvLabel),
						applyJec = cms.bool(True),
						inputIsCorrected = cms.bool(False)
						))

			setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator',
					pileupJetIdEvaluator.clone(
						jetids = cms.InputTag(jetALGO+'PF'+PUMethod+'pileupJetIdCalculator'),
						jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
						rho = cms.InputTag("fixedGridRhoFastjetAll"),
						vertexes = cms.InputTag(pvLabel)
						)
					)

                        getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullDiscriminant']
                        getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userInts.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:cutbasedId',jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullId']
                        elemToKeep += ['keep *_'+jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator_*_*']
                        toolsUsed.append( jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator' )
		else:
                        print '|---- jetToolBox: PUJetID is optimized for ak4 PFjets with CHS. NOT running PUJetID.'

	###### Energy Correlation Functions
	if addEnergyCorrFunc:
		from RecoJets.JetProducers.ECF_cfi import ECF 
		rangeECF = range(1,maxECF+1)
		setattr( proc, jetalgo+'PFJets'+PUMethod+'ECF', ECF.clone(
				src = cms.InputTag(jetalgo+'PFJets'+PUMethod),
				Njets = cms.vuint32( rangeECF ),
				beta = cms.double( ecfBeta ) 
				))

		elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'ECF_*_*'] 
		for ecf in rangeECF: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'ECF:ecf'+str(ecf) ]
		jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'ECF' )
		toolsUsed.append( jetalgo+'PFJets'+PUMethod+'ECF' )
	
	if hasattr(proc, 'patJetPartons'): proc.patJetPartons.particles = genParticlesLabel


	setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod, selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod, cut = Cut ) )
	elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_*_*' ]
	elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_calo*_*' ]
	elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_tagInfos_*' ]


	if len(toolsUsed) > 0 : print '|---- jetToolBox: Running '+', '.join(toolsUsed)+'.'
	print '|---- jetToolBox: Creating selectedPatJets'+jetALGO+'PF'+PUMethod+' collection.'

	### "return"
	setattr(proc, jetSequence, jetSeq)
	if hasattr(proc, outputFile): getattr(proc, outputFile).outputCommands += elemToKeep
	else: setattr( proc, outputFile, 
			cms.OutputModule('PoolOutputModule', 
				fileName = cms.untracked.string('jettoolbox.root'), 
				outputCommands = cms.untracked.vstring( elemToKeep ) ) )

	if runOnData:
		from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching
		removeMCMatching(proc, names=['Jets'], outputModules=[outputFile])
예제 #7
0
## PUPPI AK8
## Pre-requisites: re-build puppi jets

###Robin's way:

process.load('CommonTools/PileupAlgos/Puppi_cff')
## e.g. to run on miniAOD
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.puppi.clonePackedCands = cms.bool(True)
process.puppi.useExistingWeights = cms.bool(True)

from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
process.ak8PFJetsPuppi = ak4PFJetsPuppi.clone(rParam=0.8,
                                              doAreaFastjet=True,
                                              jetPtMin=fatjet_ptmin)

## Softdrop AK8 with Puppi
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsPuppiSoftDrop
process.ak8PFJetsPuppiSoftDrop = ak8PFJetsPuppiSoftDrop.clone(
    jetPtMin=fatjet_ptmin)

###PERRCHE NON CONOSCE PIU' PACKED PF CANDIDATES??????????????
##print process.packedPFCandidates
#################
### Tentative n.2: association track-vtx
'''
It says that 
Looking for type: std::vector<reco::Track>
Looking for module label: generalTracks
예제 #8
0
def JetSubstructure(process,
                    isMC,
                    coneSize=0.8,
                    algo="AK",
                    pileupMethod="chs",
                    selection="pt > 175 && abs(eta) < 2.5",
                    addPruning=True,
                    addPrunedSubjets=True,
                    addSoftDrop=True,
                    addSoftDropSubjets=True,
                    addTrimming=False,
                    addTrimmedSubjets=False,
                    addFiltering=False,
                    addFilteredSubjets=False,
                    addNsubjettiness=True,
                    addEnergyCorrelation=True,
                    addQJets=False,
                    addQGLikelihood=True):

    print "############################"
    print "add substructure information"
    print "isMC             = ", isMC
    print "coneSize         = ", coneSize
    print "algo             = ", algo
    print "pileupMethod     = ", pileupMethod
    print "selection        = ", selection
    print "addPruning       = ", addPruning
    print "addPrunedSubjets = ", addPrunedSubjets
    print "addSoftDrop      = ", addSoftDrop
    print "addSoftDropSubjets = ", addSoftDropSubjets
    print "addTrimming        = ", addTrimming
    print "addTrimmedSubjets  = ", addTrimmedSubjets
    print "addFiltering       = ", addFiltering
    print "addFilteredSubjets = ", addFilteredSubjets
    print "addNsubjettiness   = ", addNsubjettiness
    print "addEnergyCorrelation = ", addEnergyCorrelation
    print "addQJets             = ", addQJets
    print "addQGLikelihood      = ", addQGLikelihood
    print "############################"

    ## build jet algo name for jet clustering
    coneSizeStr = str(coneSize).replace("0", "").replace(".", "")
    jetAlgo = algo + coneSizeStr
    if algo == "AK":
        ALGO = "AntiKt"
    elif algo == "CA":
        ALGO = "CambridgeAachen"

    if isMC:
        ## run gen jet clustering from genParticles
        if not hasattr(process, "genParticlesForJetsNoNu"):
            setattr(
                process, 'genParticlesForJetsNoNu',
                cms.EDFilter(
                    "CandPtrSelector",
                    src=cms.InputTag("packedGenParticles"),
                    cut=cms.string(
                        "abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16 && abs(pdgId) != 1000022 && abs(pdgId) != 1000012 &&"
                        +
                        "abs(pdgId) != 1000014 && abs(pdgId) != 1000016 && abs(pdgId) != 2000012 && abs(pdgId) != 2000014 &&"
                        +
                        "abs(pdgId) != 2000016 && abs(pdgId) != 1000039 && abs(pdgId) != 5100039 && abs(pdgId) != 4000012 &&"
                        +
                        "abs(pdgId) != 4000014 && abs(pdgId) != 4000016 && abs(pdgId) != 9900012 && abs(pdgId) != 9900014 &&"
                        +
                        "abs(pdgId) != 9900016 && abs(pdgId) != 39 && abs(pdgId) != 9100012"
                    )))  ## skip all the possible invisible particles

        if not hasattr(process, "genJets" + jetAlgo):
            setattr(
                process, "genJets" + jetAlgo,
                ak4GenJets.clone(src='genParticlesForJetsNoNu',
                                 rParam=coneSize,
                                 jetAlgorithm=ALGO,
                                 jetPtMin=cms.double(50.))
            )  ## fix a lower reasonable threshold give the jet response

        ## filter only hadronically decaying W/Z and Higgs at generator level
        if not hasattr(process, "genBosons"):
            setattr(
                process, "genBosons",
                cms.EDFilter(
                    "CandPtrSelector",
                    src=cms.InputTag("prunedGenParticles"),
                    cut=cms.string(
                        "(abs(pdgId) == 23 || abs(pdgId) == 24 || abs(pdgId) == 25) &&"
                        +
                        "numberOfDaughters > 1 && abs(daughter(0).pdgId) <= 5 && abs(daughter(1).pdgId) <= 5"
                    )))

    ## b-tag discriminators to be considered
    bTagDiscriminators = [
        #'pfCombinedInclusiveSecondaryVertexV2BJetTags', ## don't run b-tagging on the whole large cone jet
        'pfBoostedDoubleSecondaryVertexAK8BJetTags'  ## new tag for Boosted double b-tagging
    ]

    ## jet energy corrections already loaded in JECLevels
    if pileupMethod != "chs" and pileupMethod != "Puppi" and pileupMethod != "":
        sys.exit(
            "Invalid pileupMethod setup --> only recognized options are 'chs' and 'Puppi'"
        )

    ## JEC
    JECLevel = copy.deepcopy(process.JECLevels.labels)
    payloadName = ""
    payloadNameSubJet = ""
    jetCollection = ""
    pfCand = ""

    ## in case of CHS select particles and re-cluster jets
    if pileupMethod == "chs":
        ## obtain chs candidates
        if not hasattr(process, "chs"):
            setattr(
                process, 'chs',
                cms.EDFilter('CandPtrSelector',
                             src=cms.InputTag("packedPFCandidates"),
                             cut=cms.string('fromPV')))
        ## cluster basic jets given rParameter and algorithm
        if not hasattr(process, jetAlgo + 'PFJets' + pileupMethod.upper()):
            setattr(
                process, jetAlgo + 'PFJets' + pileupMethod.upper(),
                ak4PFJetsCHS.clone(src=cms.InputTag('chs'),
                                   doAreaFastjet=True,
                                   rParam=coneSize,
                                   jetAlgorithm=ALGO))

        payloadName = jetAlgo + 'PF' + pileupMethod
        payloadNameSubjet = 'AK4PF' + pileupMethod
        jetCollection = jetAlgo + 'PFJets' + pileupMethod.upper()
        pfCand = "chs"

    ## for puppi jets
    elif pileupMethod == "Puppi":
        ### re-run optimal puppi weights
        if not hasattr(process, "puppi"):
            from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD
            makePuppiesFromMiniAOD(process, False)
            process.puppi.useExistingWeights = cms.bool(False)
            process.puppiNoLep.useExistingWeights = cms.bool(False)

        ## cluster puppi jets given rParameter and algorithm
        if not hasattr(process, jetAlgo + 'PFJets' + pileupMethod):
            setattr(
                process, jetAlgo + 'PFJets' + pileupMethod,
                ak4PFJetsPuppi.clone(src=cms.InputTag('puppi'),
                                     doAreaFastjet=True,
                                     rParam=coneSize,
                                     jetAlgorithm=ALGO))

        payloadName = jetAlgo + 'PF' + pileupMethod
        payloadNameSubjet = 'AK4PF' + pileupMethod
        jetCollection = jetAlgo + 'PFJets' + pileupMethod
        pfCand = "puppi"

    ## standard PF jets
    elif pileupMethod == "":
        ## no pileup mitigation
        if not hasattr(process, jetAlgo + 'PFJets'):
            setattr(
                process, jetAlgo + 'PFJets',
                ak4PFJetsPuppi.clone(src=cms.InputTag('packedPFCandidates'),
                                     doAreaFastjet=True,
                                     rParam=coneSize,
                                     jetAlgorithm=ALGO))
        payloadName = jetAlgo + 'PF'
        payloadNameSubjet = 'AK4PF'
        jetCollection = jetAlgo + 'PFJets'
        pfCand = "packedPFCandidates"

    ## apply selection and produce a restricted set of consituents only for jets passig the selection
    if not hasattr(process, jetCollection + "Reduced"):
        setattr(
            process, jetCollection + "Reduced",
            cms.EDFilter("MiniAODJetConstituentSelector",
                         src=cms.InputTag(jetCollection),
                         cut=cms.string("pt > 100 && abs(eta) < 2.5")))

    ## build pat-jets from this skimmed collection: example
    if not hasattr(process, "patJets" + jetCollection):

        addJetCollection(
            process,
            labelName=jetCollection,
            jetSource=cms.InputTag(jetCollection + "Reduced"),
            algo=algo,
            rParam=coneSize,
            pfCandidates=cms.InputTag(pfCand),
            jetCorrections=(payloadName, JECLevel, 'None'),
            svSource=cms.InputTag('slimmedSecondaryVertices'),
            genJetCollection=cms.InputTag("genJets" + jetAlgo),
            pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
            btagDiscriminators=bTagDiscriminators,
            getJetMCFlavour=isMC,
            genParticles=cms.InputTag("prunedGenParticles"),
        )

        ### special jec set for pruned/sof-drop mass correction --> to be taken from the EDAnalyzer
        if hasattr(process, "patJetCorrFactors" + jetCollection):
            if isMC:
                setattr(
                    process, "patJetCorrFactors" + jetCollection + "v2",
                    getattr(
                        process, "patJetCorrFactors" + jetCollection).clone(
                            levels=cms.vstring('L2Relative', 'L3Absolute')))
            else:
                setattr(
                    process, "patJetCorrFactors" + jetCollection + "v2",
                    getattr(process, "patJetCorrFactors" +
                            jetCollection).clone(levels=cms.vstring(
                                'L2Relative', 'L3Absolute', 'L2L3Residual')))

            getattr(process, "patJets" +
                    jetCollection).jetCorrFactorsSource = cms.VInputTag(
                        cms.InputTag("patJetCorrFactors" + jetCollection),
                        cms.InputTag("patJetCorrFactors" + jetCollection +
                                     "v2"))

        if hasattr(process, "selectedPatJets" + jetCollection):
            getattr(process, "selectedPatJets" +
                    jetCollection).cut = cms.string(selection)

    ## match reco-jets with hadronically decaying genBosons (W,Z,H)
    if isMC:
        if not hasattr(process, jetCollection + 'GenBosonMatched'):
            setattr(
                process,
                jetCollection + 'GenBosonMatched',
                cms.EDProducer(
                    "RecoJetCandDeltaRValueMapProducer",
                    ## basic reco::jet ungroomed
                    src=cms.InputTag(jetCollection + "Reduced"),
                    ## mathched groomed pat jet
                    matched=cms.InputTag('genBosons'),
                    distMax=cms.double(coneSize),
                    values=cms.vstring("pt", "eta", "phi", "mass"),
                    valueLabels=cms.vstring("pt", "eta", "phi", "mass")))

            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        jetCollection + 'GenBosonMatched:pt'
                    ]
            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        jetCollection + 'GenBosonMatched:eta'
                    ]
            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        jetCollection + 'GenBosonMatched:phi'
                    ]
            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        jetCollection + 'GenBosonMatched:mass'
                    ]

    ## add QGLikelihood on fat jet
    if addQGLikelihood:
        if not hasattr(process, jetCollection + "QGL"):
            setattr(
                process, jetCollection + "QGL",
                QGTagger.clone(srcJets=cms.InputTag(jetCollection + "Reduced"),
                               jetsLabel=cms.string('QGL_AK4PFchs'),
                               srcVertexCollection=cms.InputTag(
                                   'offlineSlimmedPrimaryVertices')))
            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        jetCollection + 'QGL:qgLikelihood'
                    ]

    ## addNsubjettiness
    if addNsubjettiness:
        if not hasattr(process, 'Njettiness' + jetCollection):
            setattr(
                process, 'Njettiness' + jetCollection,
                Njettiness.clone(src=cms.InputTag(jetCollection + "Reduced"),
                                 cone=cms.double(coneSize)))

            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        'Njettiness' + jetCollection + ':tau1',
                        'Njettiness' + jetCollection + ':tau2',
                        'Njettiness' + jetCollection + ':tau3',
                        'Njettiness' + jetCollection + ':tau4'
                    ]

        ## on gen jets
        if isMC:
            if not hasattr(process, "NjettinessGenJets" + jetAlgo):
                setattr(
                    process, "NjettinessGenJets" + jetAlgo,
                    Njettiness.clone(src=cms.InputTag("genJets" + jetAlgo),
                                     cone=cms.double(coneSize)))

                ## pattify gen jets --> temp
                if not hasattr(process, 'patGenJets' + jetAlgo):
                    setattr(
                        process, 'patGenJets' + jetAlgo,
                        patJets.clone(
                            jetSource=cms.InputTag("genJets" + jetAlgo),
                            addJetCorrFactors=cms.bool(False),
                            addBTagInfo=cms.bool(False),
                            addDiscriminators=cms.bool(False),
                            discriminatorSources=cms.VInputTag('None'),
                            addAssociatedTracks=cms.bool(False),
                            addJetCharge=cms.bool(False),
                            addGenPartonMatch=cms.bool(False),
                            embedGenPartonMatch=cms.bool(False),
                            addGenJetMatch=cms.bool(False),
                            embedGenJetMatch=cms.bool(False),
                            getJetMCFlavour=cms.bool(False),
                            addJetFlavourInfo=cms.bool(False)))

                    getattr(process, 'patGenJets' +
                            jetAlgo).userData.userFloats.src += [
                                "NjettinessGenJets" + jetAlgo + ':tau1'
                            ]
                    getattr(process, 'patGenJets' +
                            jetAlgo).userData.userFloats.src += [
                                "NjettinessGenJets" + jetAlgo + ':tau2'
                            ]
                    getattr(process, 'patGenJets' +
                            jetAlgo).userData.userFloats.src += [
                                "NjettinessGenJets" + jetAlgo + ':tau3'
                            ]
                    getattr(process, 'patGenJets' +
                            jetAlgo).userData.userFloats.src += [
                                "NjettinessGenJets" + jetAlgo + ':tau4'
                            ]

            if not hasattr(process, jetCollection + 'GenNjettinessMatched'):
                setattr(
                    process,
                    jetCollection + 'GenNjettinessMatched',
                    cms.EDProducer(
                        "RecoPATJetDeltaRValueMapProducer",
                        ## basic reco::jet ungroomed
                        src=cms.InputTag(jetCollection + "Reduced"),
                        ## mathched groomed pat jet
                        matched=cms.InputTag('patGenJets' + jetAlgo),
                        distMax=cms.double(coneSize),
                        values=cms.vstring(
                            "userFloat('NjettinessGenJets" + jetAlgo +
                            ":tau1')", "userFloat('NjettinessGenJets" +
                            jetAlgo + ":tau2')",
                            "userFloat('NjettinessGenJets" + jetAlgo +
                            ":tau3')", "userFloat('NjettinessGenJets" +
                            jetAlgo + ":tau4')"),
                        valueLabels=cms.vstring("tau1", "tau2", "tau3",
                                                "tau4")))

                getattr(process,
                        'patJets' + jetCollection).userData.userFloats.src += [
                            jetCollection + 'GenNjettinessMatched:tau1',
                            jetCollection + 'GenNjettinessMatched:tau2',
                            jetCollection + 'GenNjettinessMatched:tau3',
                            jetCollection + 'GenNjettinessMatched:tau4'
                        ]

    ## add ECF
    if addEnergyCorrelation:
        if not hasattr(process, 'ecf' + jetCollection):
            setattr(
                process, 'ecf' + jetCollection,
                ECF.clone(src=cms.InputTag(jetCollection + "Reduced"),
                          Njets=cms.vuint32(1, 2, 3)))

            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        'ecf' + jetCollection + ':ecf1'
                    ]
            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        'ecf' + jetCollection + ':ecf2'
                    ]
            getattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        'ecf' + jetCollection + ':ecf3'
                    ]

    ## add QJets
    if addQJets:
        if not hasattr(process, "qjets" + jetCollection):
            setattr(
                process, "qjets" + jetCollection,
                QJetsAdder.clone(src=cms.InputTag(jetCollection + "Reduced"),
                                 jeRad=cms.double(coneSize),
                                 jetAlgo=cms.string(algo)))

            setattr(process,
                    'patJets' + jetCollection).userData.userFloats.src += [
                        "qjets" + jetCollection + ":QjetsVolatility"
                    ]

    ### start with substructure: Pruning (run it on both reco and gen jets):
    Tags = []
    Labels = []
    JECLevelTemp = copy.deepcopy(JECLevel)
    if 'L1FastJet' in JECLevelTemp:
        JECLevelTemp.remove(
            'L1FastJet')  ## in any case groomers are removing already pileup

    if addPruning:
        runGroomedMethod(process,
                         isMC=isMC,
                         jetCollection=jetCollection,
                         coneSize=coneSize,
                         algo=algo,
                         payloadName=payloadName,
                         payloadNameSubjet=payloadNameSubjet,
                         JECLevel=JECLevelTemp,
                         pfCand=pfCand,
                         btagDiscriminators=bTagDiscriminators,
                         addSubJets=addPrunedSubjets,
                         addQGLikelihood=addQGLikelihood,
                         isPruning=True,
                         isSoftDrop=False,
                         isTrimming=False,
                         isFiltering=False)

        if addPrunedSubjets:
            Tags += ['patJets' + jetCollection + 'PrunedPacked']
            Labels += ['Pruned']

    if addSoftDrop:
        runGroomedMethod(process,
                         isMC=isMC,
                         jetCollection=jetCollection,
                         coneSize=coneSize,
                         algo=algo,
                         payloadName=payloadName,
                         payloadNameSubjet=payloadNameSubjet,
                         JECLevel=JECLevelTemp,
                         pfCand=pfCand,
                         btagDiscriminators=bTagDiscriminators,
                         addSubJets=addSoftDropSubjets,
                         addQGLikelihood=addQGLikelihood,
                         isPruning=False,
                         isSoftDrop=True,
                         isTrimming=False,
                         isFiltering=False)

        if addSoftDropSubjets:
            Tags += ['patJets' + jetCollection + 'SoftDropPacked']
            Labels += ['SoftDrop']

    if addTrimming:
        runGroomedMethod(process,
                         isMC=isMC,
                         jetCollection=jetCollection,
                         coneSize=coneSize,
                         algo=algo,
                         payloadName=payloadName,
                         payloadNameSubjet=payloadNameSubjet,
                         JECLevel=JECLevelTemp,
                         pfCand=pfCand,
                         btagDiscriminators=bTagDiscriminators,
                         addSubJets=addTrimmedSubjets,
                         addQGLikelihood=addQGLikelihood,
                         isPruning=False,
                         isSoftDrop=False,
                         isTrimming=True,
                         isFiltering=False)

        if addTrimmedSubjets:
            Tags += ['patJets' + jetCollection + 'TrimmedPacked']
            Labels += ['Trimmed']

    if addFiltering:
        runGroomedMethod(process,
                         isMC=isMC,
                         jetCollection=jetCollection,
                         coneSize=coneSize,
                         algo=algo,
                         payloadName=payloadName,
                         payloadNameSubjet=payloadNameSubjet,
                         JECLevel=JECLevelTemp,
                         pfCand=pfCand,
                         btagDiscriminators=bTagDiscriminators,
                         addSubJets=addFilteredSubjets,
                         addQGLikelihood=addQGLikelihood,
                         isPruning=False,
                         isSoftDrop=False,
                         isTrimming=False,
                         isFiltering=True)

        if addFilteredSubjets:
            Tags += ['patJets' + jetCollection + 'FilteredPacked']
            Labels += ['Filtered']

    ## finally fix the pat fat jet collection
    if not hasattr(process, "packedPatJets" + jetCollection):
        setattr(
            process, "packedPatJets" + jetCollection,
            cms.EDProducer("JetSubstructurePacker",
                           jetSrc=cms.InputTag("selectedPatJets" +
                                               jetCollection),
                           distMax=cms.double(coneSize),
                           fixDaughters=cms.bool(False),
                           algoTags=cms.VInputTag(),
                           algoLabels=cms.vstring()))

        getattr(process, "packedPatJets" + jetCollection).algoTags = Tags
        getattr(process, "packedPatJets" + jetCollection).algoLabels = Labels

    return "packedPatJets" + jetCollection
예제 #9
0
def makeJets(process, isData, label, candidates, suffix):
    """
    Light-weight version of pat addJetCollection.
    @labels: e.g. 'AK4PFPuppi'
    """

    sequence = cms.Sequence()

    addattr = AddAttr(process, sequence, suffix)

    ak4PFJets = addattr('ak4PFJets',
        ak4PFJetsPuppi.clone(
            src = candidates,
            doAreaFastjet = True
        )
    )

    jecLevels= ['L1FastJet',  'L2Relative', 'L3Absolute']
    if isData:
        jecLevels.append('L2L3Residual')

    jetCorrFactors = addattr('jetCorrFactors',
        patJetCorrFactors.clone(
            src = ak4PFJets,
            payload = label,
            levels = jecLevels,
            primaryVertices = pvSource
        )
    )

    # btag should always use standard PF collection
    sequence += initBTag(process, '', pfSource, pvSource)

    sequence += setupBTag(
        process,
        jetCollection = ak4PFJets,
        suffix = suffix,
        vsuffix = '',
        muons = muons,
        electrons = electrons,
        tags = ['pfCombinedInclusiveSecondaryVertexV2BJetTags']
    )

    if not isData:
        genJetMatch = addattr('genJetMatch',
            patJetGenJetMatch.clone(
                src = ak4PFJets,
                maxDeltaR = 0.4,
                matched = genJets
            )
        )

    allPatJets = addattr('patJets',
        patJets.clone(
            jetSource = ak4PFJets,
            addJetCorrFactors = True,
            jetCorrFactorsSource = [jetCorrFactors],
            addBTagInfo = True,
            discriminatorSources = [cms.InputTag('pfCombinedInclusiveSecondaryVertexV2BJetTags' + suffix)],
            addAssociatedTracks = False,
            addJetCharge = False,
            addGenPartonMatch = False,
            addGenJetMatch = (not isData),
            getJetMCFlavour = False,
            addJetFlavourInfo = False
        )
    )

    if not isData:
        addattr.last.genJetMatch = genJetMatch

    selectedJets = addattr('selectedJets',
        selectedPatJets.clone(
            src = allPatJets,
            cut = 'pt > 15'
        )
    )

    addattr('slimmedJets',
        slimmedJets.clone(
            src = selectedJets,
            rekeyDaughters = '0'
        )
    )

    return sequence
예제 #10
0
def jetToolbox(
    proc,
    jetType,
    jetSequence,
    outputFile,
    PUMethod="CHS",  #### Options: Puppi, CS, SK, Plain
    miniAOD=True,
    JETCorrPayload="None",
    JETCorrLevels=["None"],
    GetJetMCFlavour=True,
    Cut="",
    subJETCorrPayload="None",
    subJETCorrLevels=["None"],
    GetSubjetMCFlavour=False,
    CutSubjet="",
    addPruning=False,
    zCut=0.1,
    rCut=0.5,
    addPrunedSubjets=False,
    addSoftDrop=False,
    betaCut=0.0,
    zCutSD=0.1,
    addSoftDropSubjets=False,
    addTrimming=False,
    rFiltTrim=0.2,
    ptFrac=0.03,
    addFiltering=False,
    rfilt=0.3,
    nfilt=3,
    addCMSTopTagger=False,
    addMassDrop=False,
    addHEPTopTagger=False,
    addNsub=False,
    maxTau=4,
    addPUJetID=False,
    addQJets=False,
):

    ###############################################################################
    #######  Verifying some inputs and defining variables
    ###############################################################################
    print "|---- jetToolbox: Initialyzing collection..."
    supportedJetAlgos = {"ak": "AntiKt", "ca": "CambridgeAachen", "kt": "Kt"}
    recommendedJetAlgos = ["ak4", "ak8", "ca4", "ca8", "ca10"]
    payloadList = [
        "AK1PFchs",
        "AK2PFchs",
        "AK3PFchs",
        "AK4PFchs",
        "AK5PFchs",
        "AK6PFchs",
        "AK7PFchs",
        "AK8PFchs",
        "AK9PFchs",
        "AK10PFchs",
        "AK1PFPUPPI",
        "AK2PFPUPPI",
        "AK3PFPUPPI",
        "AK4PFPUPPI",
        "AK5PFPUPPI",
        "AK6PFPUPPI",
        "AK7PFPUPPI",
        "AK8PFPUPPI",
        "AK9PFPUPPI",
        "AK10PFPUPPI",
        "AK1PFSK",
        "AK2PFSK",
        "AK3PFSK",
        "AK4PFSK",
        "AK5PFSK",
        "AK6PFSK",
        "AK7PFSK",
        "AK8PFSK",
        "AK9PFSK",
        "AK10PFSK",
        "AK1PF",
        "AK2PF",
        "AK3PF",
        "AK4PF",
        "AK5PF",
        "AK6PF",
        "AK7PF",
        "AK8PF",
        "AK9PF",
        "AK10PF",
    ]
    JECLevels = ["L1Offset", "L1FastJet", "L1JPTOffset", "L2Relative", "L3Absolute", "L5Falvour", "L7Parton"]
    jetAlgo = ""
    algorithm = ""
    size = ""
    for type, tmpAlgo in supportedJetAlgos.iteritems():
        if type in jetType.lower():
            jetAlgo = type
            algorithm = tmpAlgo
            size = jetType.replace(type, "")

    jetSize = 0.0
    if int(size) in range(0, 20):
        jetSize = int(size) / 10.0
    else:
        print "|---- jetToolBox: jetSize has not a valid value. Insert a number between 1 and 20 after algorithm, like: AK8"
    ### Trick for uppercase/lowercase algo name
    jetALGO = jetAlgo.upper() + size
    jetalgo = jetAlgo.lower() + size
    if jetalgo not in recommendedJetAlgos:
        print "|---- jetToolBox: CMS recommends the following jet algoritms: " + " ".join(
            recommendedJetAlgos
        ) + ". You are using", jetalgo, "."

    #################################################################################
    ####### Toolbox start
    #################################################################################

    elemToKeep = []
    jetSeq = cms.Sequence()
    genParticlesLabel = ""
    pvLabel = ""
    tvLabel = ""
    toolsUsed = []

    #### For MiniAOD
    if miniAOD:

        print "|---- jetToolBox: JETTOOLBOX RUNNING ON MiniAOD FOR " + jetALGO + " JETS USING " + PUMethod

        genParticlesLabel = "prunedGenParticles"
        pvLabel = "offlineSlimmedPrimaryVertices"
        svLabel = "slimmedSecondaryVertices"
        tvLabel = "unpackedTracksAndVertices"
        pfCand = "packedPFCandidates"

        setattr(
            proc,
            "chs",
            cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV")),
        )
        jetSeq += getattr(proc, "chs")

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

        setattr(
            proc,
            jetalgo + "GenJetsNoNu",
            ak4GenJets.clone(src="packedGenParticlesForJetsNoNu", rParam=jetSize, jetAlgorithm=algorithm),
        )
        jetSeq += getattr(proc, jetalgo + "GenJetsNoNu")

        # for Inclusive Vertex Finder
        proc.load("PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi")

        #### For AOD
    else:
        print "|---- jetToolBox: JETTOOLBOX RUNNING ON AOD FOR " + jetALGO + " JETS USING " + PUMethod

        genParticlesLabel = "genParticles"
        pvLabel = "offlinePrimaryVertices"
        tvLabel = "generalTracks"
        pfCand = "particleFlow"
        svLabel = "inclusiveSecondaryVertices"

        proc.load("RecoJets.Configuration.GenJetParticles_cff")
        proc.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff")
        setattr(
            proc,
            jetalgo + "GenJetsNoNu",
            ak4GenJets.clone(src="genParticlesForJetsNoNu", rParam=jetSize, jetAlgorithm=algorithm),
        )
        jetSeq += getattr(proc, jetalgo + "GenJetsNoNu")

        ## b-tag discriminators
    bTagDiscriminators = [
        "pfTrackCountingHighEffBJetTags",
        "pfTrackCountingHighPurBJetTags",
        "pfJetProbabilityBJetTags",
        "pfJetBProbabilityBJetTags",
        "pfSimpleSecondaryVertexHighEffBJetTags",
        "pfSimpleSecondaryVertexHighPurBJetTags",
        "pfCombinedSecondaryVertexV2BJetTags",
        "pfCombinedSecondaryVertexBJetTags",
        #'pfcombinedInclusiveSecondaryVertexV2BJetTags',
        #'pfCombinedSecondaryVertexSoftLeptonBJetTags',
        #'pfCombinedMVABJetTags'
    ]

    ####  Creating PATjets
    if "Puppi" in PUMethod:

        proc.load("CommonTools.PileupAlgos.Puppi_cff")
        from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi

        setattr(
            proc,
            jetalgo + "PFJetsPuppi",
            ak4PFJetsPuppi.clone(doAreaFastjet=True, rParam=jetSize, jetAlgorithm=algorithm),
        )
        if miniAOD:
            puppi.candName = cms.InputTag("packedPFCandidates")
            puppi.vertexName = cms.InputTag("offlineSlimmedPrimaryVertices")
        jetSeq += getattr(proc, "puppi")
        jetSeq += getattr(proc, jetalgo + "PFJetsPuppi")

    elif "CS" in PUMethod:

        from RecoJets.JetProducers.ak4PFJetsCS_cfi import ak4PFJetsCS

        setattr(
            proc,
            jetalgo + "PFJetsCS",
            ak4PFJetsCS.clone(doAreaFastjet=True, csRParam=cms.double(jetSize), jetAlgorithm=algorithm),
        )
        # if miniAOD: getattr( proc, jetalgo+'PFJetsCS').src = 'chs'
        if miniAOD:
            getattr(proc, jetalgo + "PFJetsCS").src = "packedPFCandidates"
        # setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
        jetSeq += getattr(proc, jetalgo + "PFJetsCS")

        # setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
        jetSeq += getattr(proc, jetalgo + "PFJetsCS")

    elif "SK" in PUMethod:

        proc.load("CommonTools.PileupAlgos.softKiller_cfi")
        from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK

        setattr(proc, jetalgo + "PFJetsSK", ak4PFJetsSK.clone(rParam=jetSize, jetAlgorithm=algorithm))
        if miniAOD:
            getattr(proc, "softKiller").PFCandidates = cms.InputTag("packedPFCandidates")
        jetSeq += getattr(proc, "softKiller")
        jetSeq += getattr(proc, jetalgo + "PFJetsSK")

    elif "CHS" in PUMethod:
        setattr(
            proc, jetalgo + "PFJetsCHS", ak4PFJetsCHS.clone(doAreaFastjet=True, rParam=jetSize, jetAlgorithm=algorithm)
        )
        if miniAOD:
            getattr(proc, jetalgo + "PFJetsCHS").src = "chs"
        jetSeq += getattr(proc, jetalgo + "PFJetsCHS")

    else:
        PUMethod = ""
        setattr(proc, jetalgo + "PFJets", ak4PFJets.clone(doAreaFastjet=True, rParam=jetSize, jetAlgorithm=algorithm))
        if miniAOD:
            getattr(proc, jetalgo + "PFJets").src = "packedPFCandidates"
        jetSeq += getattr(proc, jetalgo + "PFJets")

    if miniAOD:
        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "Constituents",
            cms.EDFilter(
                "MiniAODJetConstituentSelector", src=cms.InputTag(jetalgo + "PFJets" + PUMethod), cut=cms.string(Cut)
            ),
        )
    else:
        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "Constituents",
            cms.EDFilter(
                "PFJetConstituentSelector", src=cms.InputTag(jetalgo + "PFJets" + PUMethod), cut=cms.string(Cut)
            ),
        )
    jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "Constituents")

    ### Jet Corrections
    if JETCorrPayload not in payloadList:
        if not set(JETCorrLevels).issubset(set(JECLevels)):
            if "CHS" in PUMethod:
                JEC = ("AK" + size + "PFchs", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
            elif "Plain" in PUMethod:
                JEC = ("AK" + size + "PF", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
            else:
                JEC = None
            if "None" in JETCorrPayload:
                print "|---- jetToolBox: No JEC provided, jetToolbox is using the recommended corrections for this PU method: " + str(
                    JEC
                )
            else:
                print '|---- jetToolBox: JEC payload provided ("' + JETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
                    JEC
                )
        else:
            if "CHS" in PUMethod:
                JEC = ("AK" + size + "PFchs", JETCorrLevels, "None")
            elif "Plain" in PUMethod:
                JEC = ("AK" + size + "PF", JETCorrLevels, "None")
            else:
                JEC = None
            if "None" in JETCorrPayload:
                print "|---- jetToolBox: No JEC payload provided, jetToolbox is using the recommended payload. Using JEC: " + str(
                    JEC
                )
            else:
                print '|---- jetToolBox: JEC payload provided ("' + JETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
                    JEC
                )
    else:
        if not set(JETCorrLevels).issubset(set(JECLevels)):
            if ("CHS" in PUMethod) or ("Plain" in PUMethod):
                JEC = (JETCorrPayload, ["L1FastJet", "L2Relative", "L3Absolute"], "None")
            else:
                JEC = None
            print "|---- jetToolBox: JEC levels are not provided or wrong, jetToolbox is using the recommended levels for this PU method: " + str(
                JEC
            )
        else:
            JEC = (JETCorrPayload, JETCorrLevels, "None")
            print "|---- jetToolBox: JEC payload and levels provided by user. Using JEC: " + str(JEC)

    if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger:
        if subJETCorrPayload not in payloadList:
            if not set(subJETCorrLevels).issubset(set(JECLevels)):
                if "CHS" in PUMethod:
                    subJEC = ("AK4PFchs", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
                elif "Plain" in PUMethod:
                    subJEC = ("AK4PF", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
                else:
                    subJEC = None
                if "None" in subJETCorrPayload:
                    print "|---- jetToolBox: No subJEC provided, jetToolbox is using the recommended corrections for this PU method: " + str(
                        subJEC
                    )
                else:
                    print '|---- jetToolBox: subJEC payload provided ("' + subJETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
                        subJEC
                    )
            else:
                if "CHS" in PUMethod:
                    subJEC = ("AK4PFchs", subJETCorrLevels, "None")
                elif "Plain" in PUMethod:
                    subJEC = ("AK4PF", subJETCorrLevels, "None")
                else:
                    subJEC = None
                if "None" in subJETCorrPayload:
                    print "|---- jetToolBox: No subJEC payload provided, jetToolbox is using the recommended payload. Using subJEC: " + str(
                        subJEC
                    )
                else:
                    print '|---- jetToolBox: subJEC payload provided ("' + subJETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
                        subJEC
                    )
        else:
            if not set(subJETCorrLevels).issubset(set(JECLevels)):
                if ("CHS" in PUMethod) or ("Plain" in PUMethod):
                    subJEC = (subJETCorrPayload, ["L1FastJet", "L2Relative", "L3Absolute"], "None")
                else:
                    subJEC = None
                print "|---- jetToolBox: subJEC levels are not provided or wrong, jetToolbox is using the recommended levels for this PU method: " + str(
                    subJEC
                )
            else:
                subJEC = (subJETCorrPayload, subJETCorrLevels, "None")
                print "|---- jetToolBox: subJEC payload and levels provided by user. Using subJEC: " + str(subJEC)

    addJetCollection(
        proc,
        labelName=jetALGO + "PF" + PUMethod,
        jetSource=cms.InputTag(jetalgo + "PFJets" + PUMethod),
        algo=jetalgo,
        rParam=jetSize,
        jetCorrections=JEC if JEC is not None else None,
        pfCandidates=cms.InputTag(pfCand),  #'packedPFCandidates'),
        svSource=cms.InputTag(svLabel),  #'slimmedSecondaryVertices'),
        genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
        pvSource=cms.InputTag(pvLabel),  #'offlineSlimmedPrimaryVertices'),
        btagDiscriminators=bTagDiscriminators,
        getJetMCFlavour=GetJetMCFlavour,
        outputModules=["outputFile"],
    )

    if JEC is not None:
        getattr(
            proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod
        ).primaryVertices = pvLabel  #'offlineSlimmedPrimaryVertices'

    if "CS" in PUMethod:
        getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).getJetMCFlavour = False
    else:
        getattr(proc, "patJetPartons").particles = cms.InputTag(genParticlesLabel)  #'prunedGenParticles')
    getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod).matched = cms.InputTag(
        genParticlesLabel
    )  #'prunedGenParticles')
    if miniAOD:
        if hasattr(proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod):
            getattr(
                proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod
            ).extSVCollection = cms.InputTag(
                svLabel
            )  #'slimmedSecondaryVertices')
        getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).addAssociatedTracks = cms.bool(
            False
        )  # needs to be disabled since there is no track collection present in MiniAOD
        getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).addJetCharge = cms.bool(
            False
        )  # needs to be disabled since there is no track collection present in MiniAOD

        #### Grommers
    if addSoftDrop or addSoftDropSubjets:

        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "SoftDrop",
            ak8PFJetsCHSSoftDrop.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Constituents"),
                rParam=jetSize,
                jetAlgorithm=algorithm,
                useExplicitGhosts=True,
                R0=cms.double(jetSize),
                # zcut=zCutSD,
                beta=betaCut,
                writeCompound=cms.bool(True),
                jetCollInstanceName=cms.string("SubJets"),
            ),
        )
        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "SoftDropMass",
            ak8PFJetsCHSSoftDropMass.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                matched=cms.InputTag(jetalgo + "PFJets" + PUMethod + "SoftDrop"),
                distMax=cms.double(jetSize),
            ),
        )

        elemToKeep += ["keep *_" + jetalgo + "PFJets" + PUMethod + "SoftDropMass_*_*"]
        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "SoftDrop")
        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "SoftDropMass")
        getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
            jetalgo + "PFJets" + PUMethod + "SoftDropMass"
        ]
        toolsUsed.append(jetalgo + "PFJets" + PUMethod + "SoftDropMass")

        if addSoftDropSubjets:

            setattr(
                proc,
                jetalgo + "GenJetsNoNuSoftDrop",
                ak4GenJets.clone(
                    SubJetParameters,
                    useSoftDrop=cms.bool(True),
                    rParam=jetSize,
                    jetAlgorithm=algorithm,
                    useExplicitGhosts=cms.bool(True),
                    # zcut=cms.double(zCutSD),
                    R0=cms.double(jetSize),
                    beta=cms.double(betaCut),
                    writeCompound=cms.bool(True),
                    jetCollInstanceName=cms.string("SubJets"),
                ),
            )
            if miniAOD:
                getattr(proc, jetalgo + "GenJetsNoNuSoftDrop").src = "packedGenParticlesForJetsNoNu"
            jetSeq += getattr(proc, jetalgo + "GenJetsNoNuSoftDrop")

            addJetCollection(
                proc,
                labelName=jetALGO + "PF" + PUMethod + "SoftDrop",
                jetSource=cms.InputTag(jetalgo + "PFJets" + PUMethod + "SoftDrop"),
                algo=jetalgo,
                rParam=jetSize,
                jetCorrections=JEC if JEC is not None else None,
                btagDiscriminators=["None"],
                genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
                getJetMCFlavour=GetJetMCFlavour,
                outputModules=["outputFile"],
            )

            if JEC is not None:
                getattr(proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "SoftDrop").primaryVertices = pvLabel
            getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "SoftDrop").matched = cms.InputTag(
                genParticlesLabel
            )  #'prunedGenParticles')
            setattr(
                proc,
                "selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDrop",
                selectedPatJets.clone(src="patJets" + jetALGO + "PF" + PUMethod + "SoftDrop", cut=Cut),
            )

            addJetCollection(
                proc,
                labelName=jetALGO + "PF" + PUMethod + "SoftDropSubjets",
                jetSource=cms.InputTag(jetalgo + "PFJets" + PUMethod + "SoftDrop", "SubJets"),
                algo=jetalgo,  # needed for subjet b tagging
                rParam=jetSize,  # needed for subjet b tagging
                jetCorrections=subJEC if subJEC is not None else None,
                pfCandidates=cms.InputTag(pfCand),
                pvSource=cms.InputTag(pvLabel),
                svSource=cms.InputTag(svLabel),
                btagDiscriminators=bTagDiscriminators,
                genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNuSoftDrop", "SubJets"),
                getJetMCFlavour=GetSubjetMCFlavour,
                explicitJTA=True,  # needed for subjet b tagging
                svClustering=True,  # needed for subjet b tagging
                fatJets=cms.InputTag(jetalgo + "PFJets" + PUMethod),  # needed for subjet flavor clustering
                groomedFatJets=cms.InputTag(
                    jetalgo + "PFJets" + PUMethod + "SoftDrop"
                ),  # needed for subjet flavor clustering
                outputModules=["outputFile"],
            )

            if miniAOD:
                getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets").addAssociatedTracks = cms.bool(
                    False
                )
                getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets").addJetCharge = cms.bool(False)
                if hasattr(
                    proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "SoftDropSubjets"
                ):
                    getattr(
                        proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "SoftDropSubjets"
                    ).extSVCollection = cms.InputTag(svLabel)
            if subJEC is not None:
                getattr(
                    proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "SoftDropSubjets"
                ).primaryVertices = pvLabel
            getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "SoftDropSubjets").matched = cms.InputTag(
                genParticlesLabel
            )
            setattr(
                proc,
                "selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets",
                selectedPatJets.clone(src="patJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets", cut=Cut),
            )

            ## Establish references between PATified fat jets and subjets using the BoostedJetMerger
            setattr(
                proc,
                "selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDropPacked",
                cms.EDProducer(
                    "BoostedJetMerger",
                    jetSrc=cms.InputTag("selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDrop"),
                    subjetSrc=cms.InputTag("selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets"),
                ),
            )
            jetSeq += getattr(proc, "selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDropPacked")
            elemToKeep += ["keep *_selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDropPacked_*_*"]
            toolsUsed.append("selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDropPacked")
            toolsUsed.append("selectedPatJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets")

    if addPruning or addPrunedSubjets:

        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "Pruned",
            ak8PFJetsCHSPruned.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Constituents"),
                rParam=jetSize,
                jetAlgorithm=algorithm,
                zcut=zCut,
                rcut_factor=rCut,
                writeCompound=cms.bool(True),
                doAreaFastjet=cms.bool(True),
                jetCollInstanceName=cms.string("SubJets"),
            ),
        )
        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "PrunedMass",
            ak8PFJetsCHSPrunedMass.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                matched=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Pruned"),
                distMax=cms.double(jetSize),
            ),
        )

        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "Pruned")
        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "PrunedMass")
        getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
            jetalgo + "PFJets" + PUMethod + "PrunedMass"
        ]
        elemToKeep += ["keep *_" + jetalgo + "PFJets" + PUMethod + "PrunedMass_*_*"]
        toolsUsed.append(jetalgo + "PFJets" + PUMethod + "PrunedMass")

        if addPrunedSubjets:
            setattr(
                proc,
                jetalgo + "GenJetsNoNuPruned",
                ak4GenJets.clone(
                    SubJetParameters,
                    rParam=jetSize,
                    usePruning=cms.bool(True),
                    writeCompound=cms.bool(True),
                    jetCollInstanceName=cms.string("SubJets"),
                ),
            )
            if miniAOD:
                getattr(proc, jetalgo + "GenJetsNoNuPruned").src = "packedGenParticlesForJetsNoNu"
            jetSeq += getattr(proc, jetalgo + "GenJetsNoNuPruned")

            addJetCollection(
                proc,
                labelName=jetALGO + "PF" + PUMethod + "Pruned",
                jetSource=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Pruned"),
                algo=jetalgo,
                rParam=jetSize,
                jetCorrections=JEC if JEC is not None else None,
                btagDiscriminators=["None"],
                genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
                getJetMCFlavour=GetJetMCFlavour,
                outputModules=["outputFile"],
            )
            if JEC is not None:
                getattr(proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "Pruned").primaryVertices = pvLabel
            getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "Pruned").matched = cms.InputTag(
                genParticlesLabel
            )
            setattr(
                proc,
                "selectedPatJets" + jetALGO + "PF" + PUMethod + "Pruned",
                selectedPatJets.clone(src="patJets" + jetALGO + "PF" + PUMethod + "Pruned", cut=Cut),
            )

            addJetCollection(
                proc,
                labelName=jetALGO + "PF" + PUMethod + "PrunedSubjets",
                jetSource=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Pruned", "SubJets"),
                algo=jetalgo,  # needed for subjet b tagging
                rParam=jetSize,  # needed for subjet b tagging
                jetCorrections=subJEC if subJEC is not None else None,
                pfCandidates=cms.InputTag(pfCand),
                pvSource=cms.InputTag(pvLabel),
                svSource=cms.InputTag(svLabel),
                getJetMCFlavour=GetSubjetMCFlavour,
                btagDiscriminators=bTagDiscriminators,
                genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNuPruned", "SubJets"),
                explicitJTA=True,  # needed for subjet b tagging
                svClustering=True,  # needed for subjet b tagging
                fatJets=cms.InputTag(jetalgo + "PFJets" + PUMethod),  # needed for subjet flavor clustering
                groomedFatJets=cms.InputTag(
                    jetalgo + "PFJets" + PUMethod + "Pruned"
                ),  # needed for subjet flavor clustering
                outputModules=["outputFile"],
            )

            getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "PrunedSubjets").matched = cms.InputTag(
                genParticlesLabel
            )
            if subJEC is not None:
                getattr(
                    proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "PrunedSubjets"
                ).primaryVertices = pvLabel
            if miniAOD:
                if hasattr(
                    proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "PrunedSubjets"
                ):
                    getattr(
                        proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "PrunedSubjets"
                    ).extSVCollection = cms.InputTag(svLabel)
                getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets").addAssociatedTracks = cms.bool(
                    False
                )
                getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets").addJetCharge = cms.bool(False)
            setattr(
                proc,
                "selectedPatJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets",
                selectedPatJets.clone(src="patJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets", cut=Cut),
            )

            ## Establish references between PATified fat jets and subjets using the BoostedJetMerger
            setattr(
                proc,
                "selectedPatJets" + jetALGO + "PF" + PUMethod + "PrunedPacked",
                cms.EDProducer(
                    "BoostedJetMerger",
                    jetSrc=cms.InputTag("selectedPatJets" + jetALGO + "PF" + PUMethod + "Pruned"),
                    subjetSrc=cms.InputTag("selectedPatJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets"),
                ),
            )
            jetSeq += getattr(proc, "selectedPatJets" + jetALGO + "PF" + PUMethod + "PrunedPacked")
            elemToKeep += ["keep *_selectedPatJets" + jetALGO + "PF" + PUMethod + "PrunedPacked_*_*"]
            toolsUsed.append("selectedPatJets" + jetALGO + "PF" + PUMethod + "PrunedPacked")
            toolsUsed.append("selectedPatJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets")

    if addTrimming:

        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "Trimmed",
            ak8PFJetsCHSTrimmed.clone(
                rParam=jetSize,
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Constituents"),
                jetAlgorithm=algorithm,
                rFilt=rFiltTrim,
                trimPtFracMin=ptFrac,
            ),
        )
        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "TrimmedMass",
            ak8PFJetsCHSTrimmedMass.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                matched=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Trimmed"),
                distMax=cms.double(jetSize),
            ),
        )

        elemToKeep += ["keep *_" + jetalgo + "PFJets" + PUMethod + "TrimmedMass_*_*"]
        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "Trimmed")
        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "TrimmedMass")
        getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
            jetalgo + "PFJets" + PUMethod + "TrimmedMass"
        ]
        toolsUsed.append(jetalgo + "PFJets" + PUMethod + "TrimmedMass")

    if addFiltering:

        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "Filtered",
            ak8PFJetsCHSFiltered.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Constituents"),
                rParam=jetSize,
                jetAlgorithm=algorithm,
                rFilt=rfilt,
                nFilt=nfilt,
            ),
        )
        setattr(
            proc,
            jetalgo + "PFJets" + PUMethod + "FilteredMass",
            ak8PFJetsCHSFilteredMass.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                matched=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Filtered"),
                distMax=cms.double(jetSize),
            ),
        )
        elemToKeep += ["keep *_" + jetalgo + "PFJets" + PUMethod + "FilteredMass_*_*"]
        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "Filtered")
        jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "FilteredMass")
        getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
            jetalgo + "PFJets" + PUMethod + "FilteredMass"
        ]
        toolsUsed.append(jetalgo + "PFJets" + PUMethod + "FilteredMass")

    if addCMSTopTagger:

        if "CA" in jetALGO:

            setattr(
                proc,
                "cmsTopTagPFJets" + PUMethod,
                cms.EDProducer(
                    "CATopJetProducer",
                    PFJetParameters.clone(
                        src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Constituents"),
                        doAreaFastjet=cms.bool(True),
                        doRhoFastjet=cms.bool(False),
                        jetPtMin=cms.double(100.0),
                    ),
                    AnomalousCellParameters,
                    CATopJetParameters.clone(
                        jetCollInstanceName=cms.string("SubJets"),
                        verbose=cms.bool(False),
                        algorithm=cms.int32(1),  # 0 = KT, 1 = CA, 2 = anti-KT
                        tagAlgo=cms.int32(0),  # 0=legacy top
                        useAdjacency=cms.int32(2),  # modified adjacency
                        centralEtaCut=cms.double(2.5),  # eta for defining "central" jets
                        sumEtBins=cms.vdouble(
                            0, 1600, 2600
                        ),  # sumEt bins over which cuts vary. vector={bin 0 lower bound, bin 1 lower bound, ...}
                        rBins=cms.vdouble(0.8, 0.8, 0.8),  # Jet distance paramter R. R values depend on sumEt bins.
                        ptFracBins=cms.vdouble(
                            0.05, 0.05, 0.05
                        ),  # minimum fraction of central jet pt for subjets (deltap)
                        deltarBins=cms.vdouble(
                            0.19, 0.19, 0.19
                        ),  # Applicable only if useAdjacency=1. deltar adjacency values for each sumEtBin
                        nCellBins=cms.vdouble(1.9, 1.9, 1.9),
                    ),
                    jetAlgorithm=cms.string("CambridgeAachen"),
                    rParam=cms.double(jetSize),
                    writeCompound=cms.bool(True),
                ),
            )

            setattr(
                proc,
                "CATopTagInfos",
                cms.EDProducer(
                    "CATopJetTagger",
                    src=cms.InputTag("cmsTopTagPFJets" + PUMethod),
                    TopMass=cms.double(171),
                    TopMassMin=cms.double(0.0),
                    TopMassMax=cms.double(250.0),
                    WMass=cms.double(80.4),
                    WMassMin=cms.double(0.0),
                    WMassMax=cms.double(200.0),
                    MinMassMin=cms.double(0.0),
                    MinMassMax=cms.double(200.0),
                    verbose=cms.bool(False),
                ),
            )
            addJetCollection(
                proc,
                labelName="CMSTopTag" + PUMethod,
                jetSource=cms.InputTag("cmsTopTagPFJets" + PUMethod),
                jetCorrections=JEC if JEC is not None else None,
                pfCandidates=cms.InputTag(pfCand),
                pvSource=cms.InputTag(pvLabel),
                svSource=cms.InputTag(svLabel),
                btagDiscriminators=bTagDiscriminators,
                genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
                getJetMCFlavour=GetJetMCFlavour,
            )
            getattr(proc, "patJetPartonMatchCMSTopTag" + PUMethod).matched = cms.InputTag(genParticlesLabel)
            if hasattr(proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod):
                getattr(
                    proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod
                ).extSVCollection = cms.InputTag(svLabel)
            getattr(proc, "patJetsCMSTopTag" + PUMethod).addTagInfos = True
            getattr(proc, "patJetsCMSTopTag" + PUMethod).tagInfoSources = cms.VInputTag(cms.InputTag("CATopTagInfos"))
            if JEC is not None:
                getattr(proc, "patJetCorrFactorsCMSTopTag" + PUMethod).primaryVertices = pvLabel
            getattr(proc, "patJetsCMSTopTag" + PUMethod).addAssociatedTracks = cms.bool(False)
            getattr(proc, "patJetsCMSTopTag" + PUMethod).addJetCharge = cms.bool(False)
            setattr(
                proc,
                "selectedPatJetsCMSTopTag" + PUMethod,
                selectedPatJets.clone(src="patJetsCMSTopTag" + PUMethod, cut=Cut),
            )

            addJetCollection(
                proc,
                labelName="CMSTopTag" + PUMethod + "Subjets",
                jetSource=cms.InputTag("cmsTopTagPFJets" + PUMethod, "SubJets"),
                algo=jetalgo,  # needed for subjet b tagging
                rParam=jetSize,  # needed for subjet b tagging
                jetCorrections=subJEC if subJEC is not None else None,
                pfCandidates=cms.InputTag(pfCand),
                pvSource=cms.InputTag(pvLabel),
                svSource=cms.InputTag(svLabel),
                btagDiscriminators=bTagDiscriminators,
                genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
                getJetMCFlavour=GetSubjetMCFlavour,
                explicitJTA=True,  # needed for subjet b tagging
                svClustering=True,  # needed for subjet b tagging
                fatJets=cms.InputTag(jetalgo + "PFJets" + PUMethod),  # needed for subjet flavor clustering
                groomedFatJets=cms.InputTag("patJetsCMSTopTag" + PUMethod),  # needed for subjet flavor clustering
            )

            getattr(proc, "patJetPartonMatchCMSTopTag" + PUMethod + "Subjets").matched = cms.InputTag(
                genParticlesLabel
            )  #'prunedGenParticles')
            if hasattr(proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod + "Subjets"):
                getattr(
                    proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod + "Subjets"
                ).extSVCollection = cms.InputTag(svLabel)
            if subJEC is not None:
                getattr(proc, "patJetCorrFactorsCMSTopTag" + PUMethod + "Subjets").primaryVertices = pvLabel
            getattr(proc, "patJetsCMSTopTag" + PUMethod + "Subjets").addAssociatedTracks = cms.bool(False)
            getattr(proc, "patJetsCMSTopTag" + PUMethod + "Subjets").addJetCharge = cms.bool(False)
            setattr(
                proc,
                "selectedPatJetsCMSTopTag" + PUMethod + "Subjets",
                selectedPatJets.clone(src="patJetsCMSTopTag" + PUMethod + "Subjets", cut=Cut),
            )

            setattr(
                proc,
                "patJetsCMSTopTag" + PUMethod + "Packed",
                cms.EDProducer(
                    "BoostedJetMerger",
                    jetSrc=cms.InputTag("patJetsCMSTopTag" + PUMethod),
                    subjetSrc=cms.InputTag("patJetsCMSTopTag" + PUMethod + "Subjets"),
                ),
            )
            jetSeq += getattr(proc, "patJetsCMSTopTag" + PUMethod + "Packed")
            elemToKeep += ["keep *_patJetsCMSTopTag" + PUMethod + "Packed_*_*"]
            toolsUsed.append("patJetsCMSTopTag" + PUMethod + "Packed")

        else:
            print "|---- jetToolBox: CMS recommends CambridgeAachen for CMS Top Tagger, you are using " + algorithm + ". JetToolbox will not run CMS Top Tagger."

    if addMassDrop:

        if "CA" in jetALGO:
            setattr(
                proc,
                jetalgo + "PFJets" + PUMethod + "MassDropFiltered",
                ca15PFJetsCHSMassDropFiltered.clone(
                    rParam=jetSize, src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Constituents")
                ),
            )
            setattr(
                proc,
                jetalgo + "PFJets" + PUMethod + "MassDropFilteredMass",
                ak8PFJetsCHSPrunedMass.clone(
                    src=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                    matched=cms.InputTag(jetalgo + "PFJets" + PUMethod + "MassDropFiltered"),
                    distMax=cms.double(jetSize),
                ),
            )
            elemToKeep += ["keep *_" + jetalgo + "PFJets" + PUMethod + "MassDropFilteredMass_*_*"]
            getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
                jetalgo + "PFJets" + PUMethod + "MassDropFilteredMass"
            ]
            jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "MassDropFiltered")
            jetSeq += getattr(proc, jetalgo + "PFJets" + PUMethod + "MassDropFilteredMass")
        else:
            print "|---- jetToolBox: CMS recommends CambridgeAachen for Mass Drop, you are using " + algorithm + ". JetToolbox will not run Mass Drop."
        toolsUsed.append(jetalgo + "PFJets" + PUMethod + "MassDropFilteredMass")

    if addHEPTopTagger:
        if (jetSize >= 1.0) and ("CA" in jetALGO):

            setattr(
                proc,
                "hepTopTagPFJets" + PUMethod,
                hepTopTagPFJetsCHS.clone(src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "Constituents")),
            )
            setattr(
                proc,
                "hepTopTagPFJets" + PUMethod + "Mass" + jetALGO,
                ak8PFJetsCHSPrunedMass.clone(
                    src=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                    matched=cms.InputTag("hepTopTagPFJets" + PUMethod),
                    distMax=cms.double(jetSize),
                ),
            )
            elemToKeep += ["keep *_hepTopTagPFJets" + PUMethod + "Mass" + jetALGO + "_*_*"]
            getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
                "hepTopTagPFJets" + PUMethod + "Mass" + jetALGO
            ]
            jetSeq += getattr(proc, "hepTopTagPFJets" + PUMethod)
            jetSeq += getattr(proc, "hepTopTagPFJets" + PUMethod + "Mass" + jetALGO)
            toolsUsed.append("hepTopTagPFJets" + PUMethod + "Mass" + jetALGO)
        else:
            print "|---- jetToolBox: CMS recommends CambridgeAachen for HEPTopTagger, you are using " + algorithm + ", and a jet cone size bigger than 1. JetToolbox will not run HEP TopTagger."

        ####### Nsubjettiness
    if addNsub:
        from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness

        rangeTau = range(1, maxTau + 1)
        setattr(
            proc,
            "Njettiness" + jetALGO + PUMethod,
            Njettiness.clone(
                src=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                Njets=cms.vuint32(rangeTau),  # 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(jetSize),  # 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

        elemToKeep += ["keep *_Njettiness" + jetALGO + PUMethod + "_*_*"]
        for tau in rangeTau:
            getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
                "Njettiness" + jetALGO + PUMethod + ":tau" + str(tau)
            ]
        jetSeq += getattr(proc, "Njettiness" + jetALGO + PUMethod)
        toolsUsed.append("Njettiness" + jetALGO + PUMethod)

        ###### QJetsAdder
    if addQJets:
        """
		#This is the old way before 731
		### there must be a better way to do this random number introduction
		setattr( proc, 'RandomNumberGeneratorService', cms.Service("RandomNumberGeneratorService", 
							QJetsAdderCA8 = cms.PSet(initialSeed = cms.untracked.uint32(7)),
							QJetsAdderAK8 = cms.PSet(initialSeed = cms.untracked.uint32(31)),
							QJetsAdderCA15 = cms.PSet(initialSeed = cms.untracked.uint32(76)), ) )

		from RecoJets.JetProducers.qjetsadder_cfi import QJetsAdder
		setattr( proc, 'QJetsAdder'+jetALGO, 
				QJetsAdder.clone( src = cms.InputTag(jetalgo+'PFJets'+PUMethod), 
					jetRad = cms.double( jetSize ), 
					jetAlgo = cms.string( jetALGO[0:2] )))
		elemToKeep += [ 'keep *_QJetsAdder'+jetALGO+'_*_*' ]
		getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QJetsAdder'+jetALGO+':QjetsVolatility']  
		jetSeq += getattr(proc, 'QJetsAdder'+jetALGO )
		toolsUsed.append( 'QJetsAdder'+jetALGO )
		"""
        ### This is for 731 or higher
        if "ak4" in jetalgo:
            proc.load("RecoJets.JetProducers.QGTagger_cfi")
            proc.QGTagger.srcJets = cms.InputTag(
                jetalgo + "PFJets" + PUMethod
            )  # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
            proc.QGTagger.jetsLabel = cms.string(
                "QGL_AK4PFchs"
            )  # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
            elemToKeep += ["keep *_QGTagger_*_*"]
            getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += ["QGTagger:qgLikelihood"]
            jetSeq += getattr(proc, "QGTagger")
        else:
            print "|---- jetToolBox: QGTagger is optimized for ak4 jets."

            ####### Pileup JetID
    if addPUJetID:
        if ("ak4" in jetalgo) and ("CHS" in PUMethod):
            from RecoJets.JetProducers.pileupjetidproducer_cfi import pileupJetIdCalculator, pileupJetIdEvaluator

            setattr(
                proc,
                jetALGO + "PF" + PUMethod + "pileupJetIdCalculator",
                pileupJetIdCalculator.clone(
                    jets=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                    rho=cms.InputTag("fixedGridRhoFastjetAll"),
                    vertexes=cms.InputTag(pvLabel),
                ),
            )

            setattr(
                proc,
                jetALGO + "PF" + PUMethod + "pileupJetIdEvaluator",
                pileupJetIdEvaluator.clone(
                    jetids=cms.InputTag(jetALGO + "PF" + PUMethod + "pileupJetIdCalculator"),
                    jets=cms.InputTag(jetalgo + "PFJets" + PUMethod),
                    rho=cms.InputTag("fixedGridRhoFastjetAll"),
                    vertexes=cms.InputTag(pvLabel),
                ),
            )

            getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += [
                jetALGO + "PF" + PUMethod + "pileupJetIdEvaluator:fullDiscriminant"
            ]
            getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userInts.src += [
                jetALGO + "PF" + PUMethod + "pileupJetIdEvaluator:cutbasedId",
                jetALGO + "PF" + PUMethod + "pileupJetIdEvaluator:fullId",
            ]
            elemToKeep += ["keep *_" + jetALGO + "PF" + PUMethod + "pileupJetIdEvaluator_*_*"]
            toolsUsed.append(jetALGO + "PF" + PUMethod + "pileupJetIdEvaluator")
        else:
            print "|---- jetToolBox: PUJetID is optimized for ak4 PFjets with CHS."

    if hasattr(proc, "patJetPartons"):
        proc.patJetPartons.particles = genParticlesLabel

    setattr(
        proc,
        "selectedPatJets" + jetALGO + "PF" + PUMethod,
        selectedPatJets.clone(src="patJets" + jetALGO + "PF" + PUMethod, cut=Cut),
    )
    elemToKeep += ["keep *_selectedPatJets" + jetALGO + "PF" + PUMethod + "_*_*"]
    elemToKeep += ["drop *_selectedPatJets" + jetALGO + "PF" + PUMethod + "_calo*_*"]
    elemToKeep += ["drop *_selectedPatJets" + jetALGO + "PF" + PUMethod + "_tagInfos_*"]

    print "|---- jetToolBox: Running " + ", ".join(toolsUsed) + "."
    print "|---- jetToolBox: Creating selectedPatJets" + jetALGO + "PF" + PUMethod + " collection."

    ### "return"
    setattr(proc, jetSequence, jetSeq)
    if hasattr(proc, outputFile):
        getattr(proc, outputFile).outputCommands += elemToKeep
    else:
        setattr(
            proc,
            outputFile,
            cms.OutputModule(
                "PoolOutputModule",
                fileName=cms.untracked.string("jettoolbox.root"),
                outputCommands=cms.untracked.vstring(elemToKeep),
            ),
        )
예제 #11
0
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.PFJetParameters_cfi import *
from RecoJets.JetProducers.AnomalousCellParameters_cfi import *
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi

ak8PFJetsPuppi = ak4PFJetsPuppi.clone(rParam=0.8)