| 1 |
|
# -*- coding: utf-8 -*- |
| 2 |
|
import FWCore.ParameterSet.Config as cms |
| 3 |
– |
import os |
| 4 |
– |
|
| 5 |
– |
process = cms.Process("MYPATTEST") |
| 6 |
– |
|
| 7 |
– |
isttbar = False |
| 8 |
– |
issingletop = False |
| 9 |
– |
isvjets = False |
| 10 |
– |
isdata = True |
| 11 |
– |
nickname = "MC_TTbar" |
| 12 |
– |
#nickname= "DATA" |
| 13 |
– |
if nickname.startswith('MC_'): isdata = False |
| 14 |
– |
if nickname.find("_TTbar") > -1 or nickname.find('_ZP') > -1 : isttbar = True |
| 15 |
– |
if nickname.find("_ST_tchan") > -1 : issingletop = True |
| 16 |
– |
if nickname.find("_Wjets") > -1 or nickname.find('_Vqq') > -1 or nickname.find('_Wc') > -1 or nickname.find('_Zjets') > -1 : isvjets = True |
| 17 |
– |
tmp = os.getenv('CMSSW_BASE') |
| 18 |
– |
if 'CMSSW_4_1_' in tmp: cmssw_version = '41' |
| 19 |
– |
elif 'CMSSW_4_2_' in tmp: cmssw_version = '42' |
| 20 |
– |
elif 'CMSSW_4_4_' in tmp: cmssw_version = '44' |
| 21 |
– |
else: raise RuntimeError, 'could not determine cmssw version (cmssw correctly set up?)' |
| 22 |
– |
|
| 23 |
– |
print "detected CMSSW version %s" % cmssw_version |
| 24 |
– |
if isdata: print "assuming to run over data" |
| 25 |
– |
else: print "assuming to run over MC; (single top, ttbar, vjets) = (", issingletop, isttbar, isvjets, ")" |
| 26 |
– |
|
| 27 |
– |
# for global tag, see https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideFrontierConditions |
| 28 |
– |
def globaltag(): |
| 29 |
– |
if isdata and cmssw_version=='41': return 'GR_R_41_V0::All' |
| 30 |
– |
if not isdata and cmssw_version=='41': return 'START41_V0::All' |
| 31 |
– |
if isdata and cmssw_version=='42': return 'GR_R_42_V25::All' |
| 32 |
– |
if not isdata and cmssw_version=='42': return 'START42_V17::All' |
| 33 |
– |
if isdata and cmssw_version=='44': return 'GR_R_44_V15::All' |
| 34 |
– |
if not isdata and cmssw_version=='44': return 'START44_V13::All' |
| 35 |
– |
|
| 36 |
– |
raise RuntimeError, "could not determine global tag to use!" |
| 3 |
|
|
| 4 |
+ |
process = cms.Process("MYNTUPLE") |
| 5 |
|
|
| 6 |
|
process.load("FWCore.MessageLogger.MessageLogger_cfi") |
| 7 |
|
process.MessageLogger.cerr.threshold = 'WARNING' |
| 10 |
|
) |
| 11 |
|
|
| 12 |
|
process.source = cms.Source("PoolSource", |
| 13 |
< |
#fileNames = cms.untracked.vstring('dcap://dcache-cms-dcap.desy.de//pnfs/desy.de/cms/tier2/store/data/Run2011B/Jet/AOD/19Nov2011-v1/0000/985E38E8-3B15-E111-87A8-0015178C4970.root', |
| 47 |
< |
# 'dcap://dcache-cms-dcap.desy.de//pnfs/desy.de/cms/tier2/store/data/Run2011B/Jet/AOD/19Nov2011-v1/0000/4449A169-1A15-E111-B25F-0015178C4CE8.root'), |
| 48 |
< |
fileNames = cms.untracked.vstring('dcap://dcache-cms-dcap.desy.de//pnfs/desy.de/cms/tier2/store/mc/Fall11/TTJets_TuneZ2_7TeV-madgraph-tauola/AODSIM/PU_S6-START44_V5-v1/0000/68423CA2-BC04-E111-B90B-0018F3D0968C.root'), |
| 49 |
< |
#fileNames = cms.untracked.vstring('dcap://dcache-cms-dcap.desy.de//pnfs/desy.de/cms/tier2/store/mc/Fall11/TTJets_TuneZ2_7TeV-madgraph-tauola/AODSIM/PU_S6-START44_V5-v1/0000/7C7C20EE-BB04-E111-A833-001A92971BDA.root'), |
| 50 |
< |
#fileNames = cms.untracked.vstring('dcap://dcache-cms-dcap.desy.de//pnfs/desy.de/cms/tier2/store/mc/Fall11/W2Jets_TuneZ2_7TeV-madgraph-tauola/AODSIM/PU_S6_START44_V9B-v1/0000/9A4D5BEE-F536-E111-9F71-003048C692CA.root'), |
| 51 |
< |
#fileNames = cms.untracked.vstring('dcap://dcache-cms-dcap.desy.de//pnfs/desy.de/cms/tier2/store/mc/Fall11/QCD_Pt-80to170_EMEnriched_TuneZ2_7TeV-pythia6/AODSIM/PU_S6_START42_V14B-v2/0000/50404FDF-6214-E111-8248-78E7D164BFC8.root'), |
| 52 |
< |
skipEvents = cms.untracked.uint32(0), |
| 53 |
< |
duplicateCheckMode = cms.untracked.string('noDuplicateCheck') |
| 54 |
< |
) |
| 55 |
< |
|
| 56 |
< |
|
| 57 |
< |
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1000)) |
| 58 |
< |
|
| 59 |
< |
## Output Module Configuration (expects a path 'p') |
| 60 |
< |
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent |
| 61 |
< |
process.out = cms.OutputModule("PoolOutputModule", |
| 62 |
< |
fileName = cms.untracked.string('patTuple.root'), |
| 63 |
< |
# save only events passing the full path |
| 64 |
< |
SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), |
| 65 |
< |
# save PAT Layer 1 output; you need a '*' to |
| 66 |
< |
# unpack the list of commands 'patEventContent' |
| 67 |
< |
outputCommands = cms.untracked.vstring('drop *' , *patEventContent) |
| 68 |
< |
) |
| 69 |
< |
|
| 70 |
< |
if isdata and cmssw_version == '41': # note: there are no residual corrections in 42(?!); |
| 71 |
< |
# needs to be done with recorrector in SKITA |
| 72 |
< |
JECToProcess = cms.vstring(['L1FastJet','L2Relative', 'L3Absolute', 'L2L3Residual']) |
| 73 |
< |
else: |
| 74 |
< |
JECToProcess = cms.vstring(['L1FastJet','L2Relative', 'L3Absolute']) |
| 75 |
< |
|
| 76 |
< |
# for some jet types, no residual correction is available; use l2l3 only: |
| 77 |
< |
#l2l3jec = cms.vstring(['L2Relative', 'L3Absolute']) |
| 78 |
< |
|
| 79 |
< |
inputJetCorrLabel = ('AK5PFchs', JECToProcess) |
| 80 |
< |
|
| 81 |
< |
# 1. general setup |
| 82 |
< |
process.load("Configuration.StandardSequences.Geometry_cff") |
| 83 |
< |
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") |
| 84 |
< |
process.GlobalTag.globaltag = globaltag() |
| 85 |
< |
print "using globaltag %s" % str(process.GlobalTag.globaltag) |
| 86 |
< |
process.load("Configuration.StandardSequences.MagneticField_cff") |
| 87 |
< |
|
| 88 |
< |
|
| 89 |
< |
|
| 90 |
< |
# 3. configure PF2PAT |
| 91 |
< |
#process.load("PhysicsTools.PFCandProducer.PF2PAT_cff") |
| 92 |
< |
|
| 93 |
< |
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets |
| 94 |
< |
process.kt6PFJets = kt4PFJets.clone() |
| 95 |
< |
process.kt6PFJets.rParam = 0.6 |
| 96 |
< |
process.kt6PFJets.doRhoFastjet = True |
| 97 |
< |
|
| 98 |
< |
process.kt6PFJetsRestrictedRho = process.kt6PFJets.clone() |
| 99 |
< |
process.kt6PFJetsRestrictedRho.Rho_EtaMax = cms.double(1.9) |
| 100 |
< |
process.kt6PFJetsRestrictedRho.Ghost_EtaMax = cms.double(2.5) |
| 101 |
< |
|
| 102 |
< |
|
| 103 |
< |
|
| 104 |
< |
# Get a list of good primary vertices, in 42x, these are DAF vertices |
| 105 |
< |
from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector |
| 106 |
< |
process.goodOfflinePrimaryVertices = cms.EDFilter( |
| 107 |
< |
"PrimaryVertexObjectFilter", |
| 108 |
< |
filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ), |
| 109 |
< |
src=cms.InputTag('offlinePrimaryVertices') |
| 110 |
< |
) |
| 111 |
< |
|
| 112 |
< |
|
| 113 |
< |
#top jets |
| 114 |
< |
|
| 115 |
< |
process.load("UHHAnalysis.NtupleWriter.Topjets_cfi") |
| 116 |
< |
|
| 117 |
< |
process.load("RecoJets.Configuration.GenJetParticles_cff") |
| 118 |
< |
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets |
| 119 |
< |
process.ca8GenJets = ca4GenJets.clone( rParam = cms.double(0.8) ) |
| 120 |
< |
|
| 121 |
< |
|
| 122 |
< |
|
| 123 |
< |
process.load("PhysicsTools.PatAlgos.patSequences_cff") |
| 124 |
< |
from PhysicsTools.PatAlgos.tools.trigTools import * |
| 125 |
< |
switchOnTrigger( process ) |
| 126 |
< |
from PhysicsTools.PatAlgos.tools.pfTools import * |
| 127 |
< |
usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", runOnMC = not isdata) |
| 128 |
< |
process.pfPileUp.Enable = True |
| 129 |
< |
process.pfPileUp.Vertices = 'goodOfflinePrimaryVertices' |
| 130 |
< |
process.pfJets.doAreaFastjet = True |
| 131 |
< |
process.pfJets.doRhoFastjet = False |
| 132 |
< |
process.kt6PFJets.src = process.pfJets.src |
| 133 |
< |
process.kt6PFJetsRestrictedRho.src = process.pfJets.src |
| 134 |
< |
process.patJetCorrFactors.payload = 'AK5PFchs' |
| 135 |
< |
process.patJetCorrFactors.levels = JECToProcess |
| 136 |
< |
process.patJetCorrFactors.rho = cms.InputTag("kt6PFJets", "rho") |
| 137 |
< |
process.pfNoTau.enable = cms.bool(True) ##change this???? |
| 138 |
< |
|
| 139 |
< |
|
| 140 |
< |
from PhysicsTools.PatAlgos.producersLayer1.photonProducer_cff import * |
| 141 |
< |
from PhysicsTools.PatAlgos.selectionLayer1.photonSelector_cfi import * |
| 142 |
< |
from PhysicsTools.PatAlgos.selectionLayer1.photonCountFilter_cfi import * |
| 143 |
< |
if isdata: |
| 144 |
< |
process.patDefaultSequence *= patPhotons |
| 145 |
< |
else: process.patDefaultSequence *= makePatPhotons |
| 146 |
< |
process.patDefaultSequence *= selectedPatPhotons |
| 147 |
< |
process.patDefaultSequence *= countPatPhotons |
| 148 |
< |
|
| 149 |
< |
process.pfIsolatedMuons.isolationCut = cms.double(0.2) |
| 150 |
< |
|
| 151 |
< |
|
| 152 |
< |
process.patMuons.usePV = cms.bool(False) |
| 153 |
< |
process.patElectrons.usePV = cms.bool(False) |
| 154 |
< |
process.patJets.addTagInfos = cms.bool(True) |
| 155 |
< |
|
| 156 |
< |
process.pfIsolatedMuonsLoose = process.pfIsolatedMuons.clone(isolationCut = cms.double(float("inf"))) |
| 157 |
< |
process.patMuonsLoose = process.patMuons.clone(pfMuonSource = cms.InputTag("pfIsolatedMuonsLoose"), genParticleMatch = cms.InputTag("muonMatchLoose")) |
| 158 |
< |
# use pf isolation, but do not change matching (hell this "PAT" is really f*** up). |
| 159 |
< |
tmp = process.muonMatch.src |
| 160 |
< |
adaptPFMuons(process, process.patMuonsLoose, "") |
| 161 |
< |
process.muonMatch.src = tmp |
| 162 |
< |
|
| 163 |
< |
|
| 164 |
< |
process.pfSelectedElectrons.cut = cms.string('et > 15. & abs(eta) < 2.5') |
| 165 |
< |
process.pfSelectedMuons.cut = cms.string('pt > 10. & abs(eta) < 2.5') |
| 166 |
< |
process.pfSelectedPhotons.cut = cms.string('pt > 10.') |
| 167 |
< |
|
| 168 |
< |
#jet and tau cuts are not propagated to ntuplewriter |
| 169 |
< |
process.selectedPatJets.cut = cms.string('pt > 10. & abs(eta) < 5.0') |
| 170 |
< |
process.selectedPatTaus.cut = cms.string('pt > 10. & abs(eta) < 5.0') |
| 171 |
< |
|
| 172 |
< |
process.muonMatchLoose = process.muonMatch.clone(src = cms.InputTag("pfIsolatedMuonsLoose")) |
| 173 |
< |
|
| 174 |
< |
process.pfIsolatedElectronsLoose = process.pfIsolatedElectrons.clone(isolationCut = cms.double(float("inf"))) |
| 175 |
< |
process.patElectronsLoose = process.patElectrons.clone(pfElectronSource = cms.InputTag("pfIsolatedElectronsLoose")) |
| 176 |
< |
adaptPFElectrons(process, process.patElectronsLoose, "") |
| 177 |
< |
|
| 178 |
< |
process.looseLeptonSequence = cms.Sequence( |
| 179 |
< |
process.pfIsolatedMuonsLoose + |
| 180 |
< |
process.muonMatchLoose + |
| 181 |
< |
process.patMuonsLoose + |
| 182 |
< |
process.pfIsolatedElectronsLoose + |
| 183 |
< |
process.patElectronsLoose |
| 184 |
< |
) |
| 185 |
< |
|
| 186 |
< |
if isdata: process.looseLeptonSequence.remove(process.muonMatchLoose) |
| 187 |
< |
|
| 188 |
< |
# note: we cannot use this for the moment: some modules require a primary vertex (even if is is fake!!) |
| 189 |
< |
#for module in (process.patMuons, process.patMuonsLoose, process.patElectrons, process.patElectronsLoose): |
| 190 |
< |
# module.pvSrc = "goodOfflinePrimaryVertices" |
| 191 |
< |
#for module in (process.impactParameterTagInfos, process.impactParameterTagInfosAOD, process.softMuonTagInfosAOD, process.softMuonTagInfos): |
| 192 |
< |
# module.primaryVertex = "goodOfflinePrimaryVertices" |
| 193 |
< |
#for module in (process.patJetCorrFactors,): |
| 194 |
< |
# module.primaryVertices = "goodOfflinePrimaryVertices" |
| 195 |
< |
#for module in (process.pfElectronsFromVertex,process.pfMuonsFromVertex): |
| 196 |
< |
# module.vertices = "goodOfflinePrimaryVertices" |
| 197 |
< |
|
| 198 |
< |
|
| 199 |
< |
|
| 200 |
< |
process.load('CommonTools/RecoAlgos/HBHENoiseFilterResultProducer_cfi') |
| 201 |
< |
|
| 202 |
< |
process.HBHENoiseFilterResultProducer.minRatio = cms.double(-999) |
| 203 |
< |
process.HBHENoiseFilterResultProducer.maxRatio = cms.double(999) |
| 204 |
< |
process.HBHENoiseFilterResultProducer.minHPDHits = cms.int32(17) |
| 205 |
< |
process.HBHENoiseFilterResultProducer.minRBXHits = cms.int32(999) |
| 206 |
< |
process.HBHENoiseFilterResultProducer.minHPDNoOtherHits = cms.int32(10) |
| 207 |
< |
process.HBHENoiseFilterResultProducer.minZeros = cms.int32(10) |
| 208 |
< |
process.HBHENoiseFilterResultProducer.minHighEHitTime = cms.double(-9999.0) |
| 209 |
< |
process.HBHENoiseFilterResultProducer.maxHighEHitTime = cms.double(9999.0) |
| 210 |
< |
process.HBHENoiseFilterResultProducer.maxRBXEMF = cms.double(-999.0) |
| 211 |
< |
process.HBHENoiseFilterResultProducer.minNumIsolatedNoiseChannels = cms.int32(999999) |
| 212 |
< |
process.HBHENoiseFilterResultProducer.minIsolatedNoiseSumE = cms.double(999999.) |
| 213 |
< |
process.HBHENoiseFilterResultProducer.minIsolatedNoiseSumEt = cms.double(999999.) |
| 214 |
< |
process.HBHENoiseFilterResultProducer.useTS4TS5 = cms.bool(True) |
| 215 |
< |
|
| 216 |
< |
|
| 217 |
< |
# add CA PF jets |
| 218 |
< |
process.caTopPFJets.src = process.pfJets.src |
| 219 |
< |
addJetCollection(process, |
| 220 |
< |
cms.InputTag('caTopPFJets'), |
| 221 |
< |
algoLabel = 'TopTag', typeLabel = 'PF', doJTA=False, |
| 222 |
< |
doBTagging=False, jetCorrLabel = inputJetCorrLabel, doType1MET=False,#use ak5 PFjet corrections as described in AN2011_194 |
| 223 |
< |
genJetCollection = cms.InputTag("ca8GenJets"), doJetID = False) |
| 224 |
< |
|
| 225 |
< |
# *** jet pruning ala Jott: |
| 226 |
< |
process.caPrunedPFJets.src = process.pfJets.src |
| 227 |
< |
addJetCollection(process, |
| 228 |
< |
cms.InputTag('caPrunedPFJets'), |
| 229 |
< |
algoLabel = 'Pruned', typeLabel = 'PF', doJTA=True, |
| 230 |
< |
doBTagging=True, jetCorrLabel = inputJetCorrLabel, doType1MET=False,#use ak5 PFjet corrections as described in AN2011_194 |
| 231 |
< |
genJetCollection = cms.InputTag("ca8GenJets"), doJetID = False) |
| 232 |
< |
|
| 233 |
< |
#configure jet parton flavour determination |
| 234 |
< |
for jetcollname in ('TopTagPF', 'PrunedPF'): |
| 235 |
< |
jetcoll = getattr(process, 'patJets'+jetcollname) |
| 236 |
< |
jetcoll.embedGenJetMatch = cms.bool(False) |
| 237 |
< |
jetcoll.addDiscriminators = cms.bool(False) |
| 238 |
< |
# jet flavor stuff: match also the top quark. |
| 239 |
< |
getattr(process, 'patJetPartonAssociation'+jetcollname).coneSizeToAssociate = cms.double(0.8) |
| 240 |
< |
getattr(process, 'patJetPartonAssociation'+jetcollname).doPriority = cms.bool(True) |
| 241 |
< |
getattr(process, 'patJetPartonAssociation'+jetcollname).priorityList = cms.vint32(6) |
| 242 |
< |
#4 = match heaviest flavor |
| 243 |
< |
getattr(process, 'patJetFlavourAssociation'+jetcollname).definition = cms.int32(4) |
| 244 |
< |
getattr(process, 'patJetFlavourAssociation'+jetcollname).physicsDefinition = cms.bool(False) |
| 245 |
< |
getattr(process, 'patJetPartonMatch'+jetcollname).mcPdgId = cms.vint32(1,2,3,4,5,6,21) |
| 246 |
< |
getattr(process, 'patJetPartonMatch'+jetcollname).maxDeltaR = cms.double(0.8) |
| 247 |
< |
|
| 248 |
< |
for icorr in [process.patJetCorrFactorsTopTagPF, |
| 249 |
< |
process.patJetCorrFactorsPrunedPF |
| 250 |
< |
] : |
| 251 |
< |
icorr.rho = cms.InputTag("kt6PFJets", "rho") |
| 252 |
< |
|
| 253 |
< |
# 5. compile main sequence |
| 254 |
< |
|
| 255 |
< |
#process.patPF2PATSequence.replace(process.pfJets, process.kt6PFJets * process.kt6PFJetsRestrictedRho * process.pfJets) |
| 256 |
< |
process.patPF2PATSequence.replace(process.pfJets, process.kt6PFJets * process.kt6PFJetsRestrictedRho * process.pfJets * process.topjet_seq) |
| 257 |
< |
|
| 258 |
< |
process.main_seq = cms.Sequence(process.goodOfflinePrimaryVertices) |
| 259 |
< |
|
| 260 |
< |
process.main_seq *= process.patPF2PATSequence* process.looseLeptonSequence |
| 261 |
< |
|
| 262 |
< |
process.main_genseq = cms.Sequence(process.genParticlesForJets * process.ca8GenJets * process.topjet_genseq ) |
| 263 |
< |
#process.main_genseq = cms.Sequence(process.genParticlesForJets * process.ca8GenJets * process.subjet_genseq * process.topjet_genseq) |
| 264 |
< |
|
| 265 |
< |
|
| 266 |
< |
process.p = cms.Path() |
| 267 |
< |
|
| 268 |
< |
if isdata: process.p *= process.HBHENoiseFilterResultProducer |
| 269 |
< |
if not isdata: process.p *= process.main_genseq |
| 270 |
< |
process.p *= process.main_seq |
| 271 |
< |
|
| 272 |
< |
# Apply jet ID to all of the jets upstream. We aren't going to screw around |
| 273 |
< |
# with this, most likely. So, we don't really to waste time with it |
| 274 |
< |
# at the analysis level. |
| 275 |
< |
from PhysicsTools.SelectorUtils.pfJetIDSelector_cfi import pfJetIDSelector |
| 276 |
< |
process.goodPatJets = cms.EDFilter("PFJetIDSelectionFunctorFilter", |
| 277 |
< |
filterParams = pfJetIDSelector.clone(), |
| 278 |
< |
src = cms.InputTag("patJets") |
| 279 |
< |
) |
| 280 |
< |
|
| 281 |
< |
process.goodPatJetsPrunedPF = cms.EDFilter("PFJetIDSelectionFunctorFilter", |
| 282 |
< |
filterParams = pfJetIDSelector.clone(), |
| 283 |
< |
src = cms.InputTag("patJetsPrunedPF") |
| 284 |
< |
) |
| 285 |
< |
|
| 286 |
< |
|
| 287 |
< |
process.goodPatJetsTopTagPF = cms.EDFilter("PFJetIDSelectionFunctorFilter", |
| 288 |
< |
filterParams = pfJetIDSelector.clone(), |
| 289 |
< |
src = cms.InputTag("patJetsTopTagPF") |
| 290 |
< |
) |
| 291 |
< |
|
| 13 |
> |
fileNames = cms.untracked.vstring('file:/scratch/hh/lustre/cms/user/peiffer/TLBSM_v5_Test.root'), |
| 14 |
|
|
| 15 |
+ |
skipEvents = cms.untracked.uint32(0) |
| 16 |
+ |
) |
| 17 |
+ |
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1)) |
| 18 |
|
|
| 19 |
|
#NtupleWriter |
| 20 |
+ |
useData = False |
| 21 |
+ |
writeAllGenParticles=False |
| 22 |
|
|
| 23 |
|
process.MyNtuple = cms.EDAnalyzer('NtupleWriter', |
| 24 |
< |
fileName = cms.string('ttbar.root'), |
| 24 |
> |
fileName = cms.string('Ntuple.root'), |
| 25 |
|
doElectrons = cms.bool(True), |
| 26 |
|
doMuons = cms.bool(True), |
| 27 |
|
doTaus = cms.bool(True), |
| 28 |
|
doJets = cms.bool(True), |
| 29 |
|
doTopJets = cms.bool(True), |
| 30 |
< |
doPhotons = cms.bool(True), |
| 30 |
> |
doJECUncertainty = cms.bool(False), |
| 31 |
> |
doPhotons = cms.bool(False), |
| 32 |
|
doMET = cms.bool(True), |
| 33 |
|
doPV = cms.bool(True), |
| 34 |
< |
doGenInfo = cms.bool(not isdata), |
| 35 |
< |
electron_sources = cms.vstring("patElectrons","patElectronsLoose"), |
| 36 |
< |
muon_sources = cms.vstring("patMuons","patMuonsLoose"), |
| 37 |
< |
tau_sources = cms.vstring("patTaus"), |
| 38 |
< |
tau_ptmin = cms.double(10.0), |
| 39 |
< |
tau_etamax = cms.double(5.0), |
| 40 |
< |
jet_sources = cms.vstring("goodPatJets"), |
| 34 |
> |
doGenInfo = cms.bool(not useData), |
| 35 |
> |
doAllGenParticles = cms.bool(writeAllGenParticles), #set to true if you want to store all gen particles, otherwise, only tops and status 3 particles are stored |
| 36 |
> |
doLumiInfo = cms.bool(useData), |
| 37 |
> |
doTrigger = cms.bool(True), |
| 38 |
> |
rho_source = cms.InputTag("kt6PFJets", "rho"), |
| 39 |
> |
genparticle_source = cms.InputTag("prunedGenParticles" ), |
| 40 |
> |
electron_sources = cms.vstring("selectedPatElectronsPFlow"), #,"selectedPatElectronsPFlowLoose"), |
| 41 |
> |
muon_sources = cms.vstring("selectedPatMuonsPFlow","selectedPatMuonsPFlowLoose"), |
| 42 |
> |
tau_sources = cms.vstring("selectedPatTausPFlow"), |
| 43 |
> |
tau_ptmin = cms.double(0.0), |
| 44 |
> |
tau_etamax = cms.double(999.0), |
| 45 |
> |
jet_sources = cms.vstring("goodPatJetsPFlow"), |
| 46 |
|
jet_ptmin = cms.double(10.0), |
| 47 |
|
jet_etamax = cms.double(5.0), |
| 48 |
< |
topjet_sources = cms.vstring("goodPatJetsTopTagPF","goodPatJetsPrunedPF"), |
| 48 |
> |
#photon_sources = cms.vstring("selectedPatPhotons"), |
| 49 |
> |
topjet_sources = cms.vstring("goodPatJetsCATopTagPF","goodPatJetsCA8PrunedPF"), |
| 50 |
|
topjet_ptmin = cms.double(150.0), |
| 51 |
|
topjet_etamax = cms.double(5.0), |
| 52 |
< |
photon_sources = cms.vstring("patPhotons"), |
| 53 |
< |
met_sources = cms.vstring("patMETs"), |
| 54 |
< |
pv_sources = cms.vstring("goodOfflinePrimaryVertices", "offlinePrimaryVertices"), |
| 52 |
> |
doGenTopJets = cms.bool(not useData), |
| 53 |
> |
gentopjet_sources = cms.vstring("caTopTagGen" ), |
| 54 |
> |
gentopjet_ptmin = cms.double(150.0), |
| 55 |
> |
gentopjet_etamax = cms.double(5.0), |
| 56 |
> |
met_sources = cms.vstring("patMETs","patMETsPFlow"), |
| 57 |
> |
pv_sources = cms.vstring("goodOfflinePrimaryVertices"), |
| 58 |
|
trigger_prefixes = cms.vstring(#"HLT_IsoMu", "HLT_Mu", |
| 59 |
|
#"HLT_L1SingleMu", "HLT_L2Mu", |
| 60 |
|
#"HLT_Ele", |
| 61 |
< |
"HLT_Jet", "HLT_HT", |
| 61 |
> |
"HLT_", |
| 62 |
|
#"HLT_DoubleMu", "HLT_DoubleEle" |
| 63 |
|
), |
| 64 |
|
|
| 65 |
|
) |
| 66 |
|
|
| 330 |
– |
#process.TFileService = cms.Service("TFileService", |
| 331 |
– |
# fileName = cms.string('tree3.root') |
| 332 |
– |
#) |
| 333 |
– |
process.p *=process.goodPatJets |
| 334 |
– |
process.p *=process.goodPatJetsPrunedPF |
| 335 |
– |
process.p *=process.goodPatJetsTopTagPF |
| 336 |
– |
process.p *= process.MyNtuple |
| 337 |
– |
|
| 338 |
– |
#comment this line in to produce pattuples: |
| 339 |
– |
#process.outpath = cms.EndPath(process.out) |
| 340 |
– |
|
| 341 |
– |
process.options.wantSummary = True |
| 67 |
|
|
| 68 |
< |
#open('dump.py', 'w').write(process.dumpPython()) |
| 68 |
> |
process.p = cms.Path(process.MyNtuple) |
