def customise(process):
lumiFile = 'Cert_246908-260627_13TeV_PromptReco_Collisions15_25ns_JSON.txt'
runOnMC = True
for i in process.source.fileNames:
if 'Run2015' in i:
runOnMC=False
isTTbar=False
for i in process.source.fileNames:
if '/TT' in i or '/tt' in i:
isTTbar=True
if not runOnMC:
from FWCore.PythonUtilities.LumiList import LumiList
lumiList = LumiList(os.environ["CMSSW_BASE"]+'/src/CATTools/CatProducer/prod/LumiMask/'+lumiFile)
#lumiList = LumiList(os.environ["CMSSW_BASE"]+'/src/CATTools/CommonTools/test/ttbb/'+lumiFile)
process.source.lumisToProcess = lumiList.getVLuminosityBlockRange()
def customise(process):
lumiFile = 'Cert_246908-260627_13TeV_PromptReco_Collisions15_25ns_JSON.txt'
runOnMC = True
for i in process.source.fileNames:
if 'Run2015' in i:
runOnMC = False
isTTbar = False
for i in process.source.fileNames:
if '/TT' in i or '/tt' in i:
isTTbar = True
if not runOnMC:
from FWCore.PythonUtilities.LumiList import LumiList
lumiList = LumiList(os.environ["CMSSW_BASE"] +
'/src/CATTools/CatProducer/prod/LumiMask/' +
lumiFile)
#lumiList = LumiList(os.environ["CMSSW_BASE"]+'/src/CATTools/CommonTools/test/ttbb/'+lumiFile)
process.source.lumisToProcess = lumiList.getVLuminosityBlockRange()
def split_by_lumi(config, dataset_info, task_list):
if config.has_key('lumi mask'):
lumi_mask = LumiList(filename=config['lumi mask'])
dataset_info.total_lumis = 0
for file in dataset_info.files:
dataset_info.lumis[file] = lumi_mask.filterLumis(dataset_info.lumis[file])
dataset_info.total_lumis += len(dataset_info.lumis[file])
lumis_per_task = config['lumis per task']
lumis_processed = 0
task_id = 0
tasks = []
files = iter(dataset_info.files)
file = files.next()
input_files_this_task = [file]
task_lumis_remaining = dataset_info.lumis[file]
while lumis_processed < dataset_info.total_lumis:
for file in input_files_this_task:
common_lumis = set(dataset_info.lumis[file]).intersection(set(task_lumis_remaining))
if len(common_lumis) == 0 or len(dataset_info.lumis[file]) == 0:
input_files_this_task.remove(file)
while lumis_per_task <= len(task_lumis_remaining):
task_lumis = LumiList(lumis=task_lumis_remaining[:lumis_per_task])
task_lumis_remaining = task_lumis_remaining[lumis_per_task:]
tasks.append((input_files_this_task, task_lumis.getVLuminosityBlockRange()))
task_id += 1
lumis_processed += lumis_per_task
try:
file = files.next()
input_files_this_task.append(file)
task_lumis_remaining.extend(dataset_info.lumis[file])
except:
lumis_per_task = len(task_lumis_remaining)
with open(task_list, 'w') as json_file:
json.dump(tasks, json_file)
return len(tasks)
def SingleTopStep2():
options = VarParsing("analysis")
options.register(
"subChannel",
"T_t",
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
"The sample that you are running on",
)
options.register(
"reverseIsoCut",
False,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Consider anti-isolated region",
)
options.register(
"doDebug", False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Turn on debugging messages"
)
options.register("isMC", True, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Run on MC")
options.register(
"doGenParticlePath",
True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Run the gen particle paths (only works on specific MC)",
)
options.register(
"globalTag", Config.globalTagMC, VarParsing.multiplicity.singleton, VarParsing.varType.string, "Global tag"
)
options.register(
"srcPUDistribution",
"S10",
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
"Source pile-up distribution",
)
options.register(
"destPUDistribution",
"data",
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
"destination pile-up distribution",
)
options.register(
"isComphep",
False,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Use CompHep-specific processing",
)
options.register(
"isAMCatNLO",
False,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Use aMC@NLO-specific processing",
)
options.register(
"isSherpa", False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Use sherpa-specific processing"
)
options.register(
"systematic", "", VarParsing.multiplicity.singleton, VarParsing.varType.string, "Apply Systematic variation"
)
options.register(
"dataRun",
"RunABCD",
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
"A string Run{A,B,C,D} to specify the data period",
)
options.register(
"doSync", False, VarParsing.multiplicity.singleton, VarParsing.varType.bool, "Synchronization exercise"
)
options.parseArguments()
if options.isMC:
Config.srcPUDistribution = pileUpDistributions.distributions[options.srcPUDistribution]
Config.Leptons.reverseIsoCut = options.reverseIsoCut
Config.subChannel = options.subChannel
Config.doDebug = options.doDebug
Config.isMC = options.isMC
Config.doSkim = options.doSync or not sample_types.is_signal(Config.subChannel)
Config.isCompHep = options.isComphep or "comphep" in Config.subChannel
Config.isAMCatNLO = Config.isAMCatNLO or options.isAMCatNLO or "aMCatNLO" in Config.subChannel
Config.isSherpa = options.isSherpa or "sherpa" in Config.subChannel
Config.systematic = options.systematic
Config.doSync = options.doSync
print "Systematic: ", Config.systematic
if Config.isMC and not Config.doSync:
logging.info("Changing jet source from %s to smearedPatJetsWithOwnRef" % Config.Jets.source)
Config.Jets.source = "smearedPatJetsWithOwnRef"
if Config.systematic in ["ResUp", "ResDown"]:
logging.info(
"Changing jet source from %s to smearedPatJetsWithOwnRef%s" % (Config.Jets.source, Config.systematic)
)
Config.Jets.source = "smearedPatJetsWithOwnRef" + Config.systematic
logging.info(
"Changing MET source from %s to patType1CorrectedPFMetJet%s" % (Config.metSource, Config.systematic)
)
Config.metSource = "patType1CorrectedPFMetJet" + Config.systematic
elif Config.systematic in ["EnUp", "EnDown"]:
logging.info(
"Changing jet source from %s to shiftedPatJetsWithOwnRef%sForCorrMEt"
% (Config.Jets.source, Config.systematic)
)
Config.Jets.source = "shiftedPatJetsWithOwnRef" + Config.systematic + "ForCorrMEt"
logging.info(
"Changing MET source from %s to patType1CorrectedPFMetJet%s" % (Config.metSource, Config.systematic)
)
Config.metSource = "patType1CorrectedPFMetJet" + Config.systematic
elif Config.systematic in ["UnclusteredEnUp", "UnclusteredEnDown"]:
logging.info(
"Changing MET source from %s to patType1CorrectedPFMet%s" % (Config.metSource, Config.systematic)
)
Config.metSource = "patType1CorrectedPFMet" + Config.systematic
print "Configuration"
print Config._toStr()
print Config.Jets._toStr()
print Config.Muons._toStr()
print Config.Electrons._toStr()
print ""
process = cms.Process("STPOLSEL2")
eventCounting.countProcessed(process)
process.load("Configuration.Geometry.GeometryIdeal_cff")
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = cms.string(options.globalTag)
process.load("Configuration.StandardSequences.MagneticField_cff")
if Config.doDebug:
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger = cms.Service(
"MessageLogger",
destinations=cms.untracked.vstring("cout", "debug"),
debugModules=cms.untracked.vstring("*"),
cout=cms.untracked.PSet(threshold=cms.untracked.string("INFO")),
debug=cms.untracked.PSet(threshold=cms.untracked.string("DEBUG")),
)
logging.basicConfig(level=logging.DEBUG)
else:
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
process.MessageLogger.cerr.threshold = cms.untracked.string("INFO")
logging.basicConfig(level=logging.DEBUG)
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(options.maxEvents))
process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(True))
import os
from FWCore.PythonUtilities.LumiList import LumiList
if not Config.isMC:
ll1 = LumiList(
os.environ["CMSSW_BASE"] + "/../crabs/lumis/Cert_190456-208686_8TeV_22Jan2013ReReco_Collisions12_JSON.txt"
)
process.source = cms.Source(
"PoolSource",
fileNames=cms.untracked.vstring(options.inputFiles),
cacheSize=cms.untracked.uint32(50 * 1024 * 1024),
lumisToProcess=ll1.getVLuminosityBlockRange() if not Config.isMC else cms.untracked.VLuminosityBlockRange(),
)
print options
# -------------------------------------------------
# Jets
# -------------------------------------------------
from SingleTopPolarization.Analysis.jets_step2_cfi import JetSetup
JetSetup(process, Config)
# -------------------------------------------------
# Leptons
# -------------------------------------------------
from SingleTopPolarization.Analysis.muons_step2_cfi import MuonSetup
MuonSetup(process, Config)
from SingleTopPolarization.Analysis.electrons_step2_cfi import ElectronSetup
ElectronSetup(process, Config)
process.looseVetoMuCount = cms.EDProducer(
"CollectionSizeProducer<reco::Candidate>", src=cms.InputTag("looseVetoMuons")
)
process.looseVetoEleCount = cms.EDProducer(
"CollectionSizeProducer<reco::Candidate>", src=cms.InputTag("looseVetoElectrons")
)
process.decayTreeProducerMu = cms.EDProducer(
"GenParticleDecayTreeProducer", src=cms.untracked.InputTag("singleIsoMu")
)
process.decayTreeProducerEle = cms.EDProducer(
"GenParticleDecayTreeProducer", src=cms.untracked.InputTag("singleIsoEle")
)
# -----------------------------------------------
# Top reco and cosine calcs
# -----------------------------------------------
from SingleTopPolarization.Analysis.top_step2_cfi import TopRecoSetup
TopRecoSetup(process, Config)
process.allEventObjects = cms.EDProducer(
"CandRefCombiner",
sources=cms.vstring(["goodJets", "goodSignalLeptons", Config.metSource]),
maxOut=cms.uint32(9999),
minOut=cms.uint32(0),
logErrors=cms.bool(False),
)
process.hadronicEventObjects = cms.EDProducer(
"CandRefCombiner",
sources=cms.vstring(["goodJets"]),
maxOut=cms.uint32(9999),
minOut=cms.uint32(0),
logErrors=cms.bool(False),
)
process.allEventObjectsWithNu = cms.EDProducer(
"CandRefCombiner",
sources=cms.vstring(["goodJets", "goodSignalLeptons", Config.metSource, "recoNuProducer"]),
maxOut=cms.uint32(9999),
minOut=cms.uint32(0),
logErrors=cms.bool(False),
)
process.eventShapeVars = cms.EDProducer("EventShapeVarsProducer", src=cms.InputTag("allEventObjects"))
process.eventShapeVarsWithNu = cms.EDProducer("EventShapeVarsProducer", src=cms.InputTag("allEventObjectsWithNu"))
# Vector sum of all reconstructed objects
process.shat = cms.EDProducer("SimpleCompositeCandProducer", sources=cms.VInputTag(["allEventObjects"]))
# Hadronic final state
process.ht = cms.EDProducer("SimpleCompositeCandProducer", sources=cms.VInputTag(["hadronicEventObjects"]))
process.shatNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag("shat"),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
# eventInfo = cms.untracked.bool(True),
variables=ntupleCollection([["Pt", "pt"], ["Eta", "eta"], ["Phi", "phi"], ["Mass", "mass"]]),
)
process.htNTupleProducer = process.shatNTupleProducer.clone(src=cms.InputTag("ht"))
process.eventShapeSequence = cms.Sequence(
process.allEventObjects
* process.hadronicEventObjects
* process.eventShapeVars
* process.allEventObjectsWithNu
* process.eventShapeVarsWithNu
* process.shat
* process.ht
* process.shatNTupleProducer
* process.htNTupleProducer
)
# -----------------------------------------------
# Treemaking
# -----------------------------------------------
process.recoTopNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag("recoTop"),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
# eventInfo = cms.untracked.bool(True),
variables=ntupleCollection([["Pt", "pt"], ["Eta", "eta"], ["Phi", "phi"], ["Mass", "mass"]]),
)
process.recoNuNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag("recoNu"),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
# eventInfo = cms.untracked.bool(True),
variables=ntupleCollection(
[
["Pt", "pt"],
["Eta", "eta"],
["Phi", "phi"],
["Px", "p4().Px()"],
["Py", "p4().Py()"],
["Pz", "p4().Pz()"],
]
),
)
process.recoWNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag("recoW"),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
variables=ntupleCollection([["Pt", "pt"], ["Eta", "eta"], ["Phi", "phi"], ["Mass", "mass"]]),
)
process.trueNuNTupleProducer = process.recoNuNTupleProducer.clone(
src=cms.InputTag("genParticleSelector", "trueNeutrino", "STPOLSEL2")
)
process.trueWNTupleProducer = process.recoTopNTupleProducer.clone(
src=cms.InputTag("genParticleSelector", "trueWboson", "STPOLSEL2")
)
process.trueTopNTupleProducer = process.recoTopNTupleProducer.clone(
src=cms.InputTag("genParticleSelector", "trueTop", "STPOLSEL2")
)
process.patMETDeltaRProducer = cms.EDProducer(
"DeltaRProducerMET",
muonSrc=cms.InputTag("goodSignalMuons"),
electronSrc=cms.InputTag("goodSignalElectrons"),
metSrc=cms.InputTag(Config.metSource),
)
process.patMETNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag(Config.metSource),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
variables=ntupleCollection(
[
["Pt", "pt"],
["Eta", "eta"],
["Phi", "phi"],
["Px", "p4().Px()"],
["Py", "p4().Py()"],
["Pz", "p4().Pz()"],
]
),
)
process.trueLeptonNTupleProducer = process.recoTopNTupleProducer.clone(
src=cms.InputTag("genParticleSelector", "trueLepton", "STPOLSEL2")
)
process.trueLightJetNTupleProducer = process.recoTopNTupleProducer.clone(
src=cms.InputTag("genParticleSelector", "trueLightJet", "STPOLSEL2")
)
def userfloat(key):
return "? hasUserFloat('{0}') ? userFloat('{0}') : {1}".format(key, nanval)
def userint(key):
return "? hasUserInt('{0}') ? userInt('{0}') : {1}".format(key, nanval)
process.goodSignalMuonsNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag("patMETDeltaRProducer", "muons"),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
# eventInfo = cms.untracked.bool(True),
variables=ntupleCollection(
[
["Pt", "pt"],
["Eta", "eta"],
["Phi", "phi"],
["relIso", userfloat(Config.Muons.relIsoType)],
["Charge", "charge"],
["genPdgId", "? genParticlesSize() > 0 ? genParticle(0).pdgId() : {0}".format(nanval)],
["motherGenPdgId", "? genParticlesSize() > 0 ? genParticle(0).mother(0).pdgId() : {0}".format(nanval)],
["normChi2", "? globalTrack().isNonnull() ? normChi2 : {0}".format(nanval)],
[
"trackhitPatterntrackerLayersWithMeasurement",
userfloat("track_hitPattern_trackerLayersWithMeasurement"),
],
[
"globalTrackhitPatternnumberOfValidMuonHits",
userfloat("globalTrack_hitPattern_numberOfValidMuonHits"),
],
[
"innerTrackhitPatternnumberOfValidPixelHits",
userfloat("innerTrack_hitPattern_numberOfValidPixelHits"),
],
["db", "dB"],
["dz", userfloat("dz")],
["numberOfMatchedStations", "numberOfMatchedStations"],
[
"triggerMatch",
"? triggerObjectMatchesByPath('{0}').size()==1 ? triggerObjectMatchByPath('{0}').hasPathLastFilterAccepted() : {1}".format(
Config.Muons.triggerPath, nanval
),
],
["deltaRMET", userfloat("deltaRMET")],
["deltaPhiMET", userfloat("deltaPhiMET")],
]
),
)
process.isoMuonsNTP = process.goodSignalMuonsNTupleProducer.clone(src=cms.InputTag("muonsWithIso"))
process.allMuonsNTP = process.goodSignalMuonsNTupleProducer.clone(src=cms.InputTag("muonsWithIDAll"))
process.goodSignalElectronsNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag("patMETDeltaRProducer", "electrons"),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
# eventInfo = cms.untracked.bool(True),
variables=ntupleCollection(
[
["Pt", "%s" % Config.Electrons.pt],
["Eta", "eta"],
["Phi", "phi"],
["relIso", userfloat(Config.Electrons.relIsoType)],
["mvaID", "electronID('mvaTrigV0')"],
["Charge", "charge"],
["superClustereta", "superCluster.eta"],
["passConversionVeto", "passConversionVeto()"],
[
"gsfTracktrackerExpectedHitsInnernumberOfHits",
userint("gsfTrack_trackerExpectedHitsInner_numberOfHits"),
],
[
"triggerMatch",
"? triggerObjectMatchesByPath('{0}').size()==1 ? triggerObjectMatchByPath('{0}').hasPathLastFilterAccepted() : {1}".format(
Config.Electrons.triggerPath, nanval
),
],
["genPdgId", "? genParticlesSize() > 0 ? genParticle(0).pdgId() : {0}".format(nanval)],
["motherGenPdgId", "? genParticlesSize() > 0 ? genParticle(0).mother(0).pdgId() : {0}".format(nanval)],
["deltaRMET", userfloat("deltaRMET")],
["deltaPhiMET", userfloat("deltaPhiMET")],
]
),
)
process.isoElectronsNTP = process.goodSignalElectronsNTupleProducer.clone(src=cms.InputTag("electronsWithIso"))
process.allElectronsNTP = process.goodSignalElectronsNTupleProducer.clone(src=cms.InputTag("electronsWithIDAll"))
process.goodJetsNTupleProducer = cms.EDProducer(
"CandViewNtpProducer2",
src=cms.InputTag("goodJets"),
lazyParser=cms.untracked.bool(True),
prefix=cms.untracked.string(""),
eventInfo=cms.untracked.bool(False),
variables=ntupleCollection(
[
["Pt", "pt"],
["Eta", "eta"],
["Phi", "phi"],
["Mass", "mass"],
# ["bDiscriminator", "bDiscriminator('%s')" % Config.Jets.bTagDiscriminant],
["bDiscriminatorTCHP", "bDiscriminator('%s')" % Config.Jets.BTagDiscriminant.TCHP],
["bDiscriminatorCSV", "bDiscriminator('%s')" % Config.Jets.BTagDiscriminant.CSV],
["rms", userfloat("rms")],
["partonFlavour", "partonFlavour()"],
["area", "jetArea()"],
# These require PFCandidates to be present (huge collection)
# ["n90", "n90()"],
# ["n60", "n60()"],
# ["genJetFlavour", "? genJet()>0 ? (genJet()->pdgId()) : 0"], #FIXME
["deltaR", userfloat("deltaR")],
["deltaPhi", userfloat("deltaPhi")],
["numberOfDaughters", "numberOfDaughters"],
["neutralHadronEnergy", "neutralHadronEnergy"],
["HFHadronEnergy", "HFHadronEnergy"],
["chargedEmEnergyFraction", "chargedEmEnergyFraction"],
["neutralEmEnergyFraction", "neutralEmEnergyFraction"],
["chargedHadronEnergyFraction", "chargedHadronEnergyFraction"],
["chargedMultiplicity", "chargedMultiplicity"],
["nParticles", userfloat("nParticles")],
["puMva", userfloat("mva")],
["nCharged", userfloat("nCharged")],
["nNeutral", userfloat("nNeutral")],
["deltaRMET", userfloat("deltaRMET")],
["deltaPhiMET", userfloat("deltaPhiMET")],
]
),
)
process.lowestBTagJetNTupleProducer = process.goodJetsNTupleProducer.clone(src=cms.InputTag("lowestBTagJet"))
process.highestBTagJetNTupleProducer = process.goodJetsNTupleProducer.clone(src=cms.InputTag("highestBTagJet"))
process.treeSequenceNew = cms.Sequence(
process.patMETNTupleProducer
* process.recoTopNTupleProducer
* process.recoNuNTupleProducer
* process.recoWNTupleProducer
* process.trueTopNTupleProducer
* process.trueNuNTupleProducer
* process.trueWNTupleProducer
* process.trueLeptonNTupleProducer
* process.trueLightJetNTupleProducer
* process.goodJetsNTupleProducer
* process.lowestBTagJetNTupleProducer
* process.highestBTagJetNTupleProducer
* process.goodSignalMuonsNTupleProducer
* process.goodSignalElectronsNTupleProducer
* process.isoMuonsNTP
* process.isoElectronsNTP
)
# -----------------------------------------------
# Flavour analyzer
# -----------------------------------------------
Config.doWJetsFlavour = Config.isMC and sample_types.is_wjets(Config.subChannel) and not Config.isSherpa
if Config.doWJetsFlavour:
process.flavourAnalyzer = cms.EDProducer(
"FlavourAnalyzer",
genParticles=cms.InputTag("genParticles"),
generator=cms.InputTag("generator"),
genJets=cms.InputTag("selectedPatJets", "genJets"),
saveGenJets=cms.bool(False),
savePDFInfo=cms.bool(True),
)
# -----------------------------------------------
# Paths
# -----------------------------------------------
from SingleTopPolarization.Analysis.hlt_step2_cfi import HLTSetup
HLTSetup(process, Config)
from SingleTopPolarization.Analysis.leptons_cfg import LeptonSetup
LeptonSetup(process, Config)
if Config.isMC:
WeightSetup(process, Config)
if Config.isMC and options.doGenParticlePath:
if Config.isCompHep:
from SingleTopPolarization.Analysis.partonStudy_comphep_step2_cfi import PartonStudySetup
elif Config.isAMCatNLO:
from SingleTopPolarization.Analysis.partonStudy_aMCatNLO_step2_cfi import PartonStudySetup
else:
from SingleTopPolarization.Analysis.partonStudy_step2_cfi import PartonStudySetup
PartonStudySetup(process)
process.partonPath = cms.Path()
# NOTE: this path will REJECT events not having a true t-channel lepton
if sample_types.is_signal(Config.subChannel):
logging.warning(
"Using signal-only sequence 'process.partonStudyTrueSequence' on subChannel=%s" % Config.subChannel
)
process.partonPath += process.partonStudyTrueSequence
from SingleTopPolarization.Analysis.muons_step2_cfi import MuonPath
MuonPath(process, Config)
from SingleTopPolarization.Analysis.electrons_step2_cfi import ElectronPath
ElectronPath(process, Config)
if Config.isMC:
process.muPath += process.weightSequence
process.elePath += process.weightSequence
if Config.isMC and sample_types.is_signal(Config.subChannel):
process.muPath += process.partonStudyCompareSequence
process.elePath += process.partonStudyCompareSequence
process.treePath = cms.Path(process.treeSequenceNew)
process.eventVarsPath = cms.Path(process.eventShapeSequence)
# enable embedding the gen-level weight, which is relevant for the Sherpa sample
if Config.isMC:
process.genWeightProducer = cms.EDProducer("GenWeightProducer")
process.eventVarsPath += process.genWeightProducer
if Config.isAMCatNLO:
process.lheWeightProducer = cms.EDProducer("LHEWeightProducer")
process.eventVarsPath += process.lheWeightProducer
if Config.doWJetsFlavour:
process.treePath += process.flavourAnalyzer
if Config.isMC:
if not Config.isSherpa:
process.meWeightProducer = cms.EDProducer("MEWeightProducer")
process.eventVarsPath += process.meWeightProducer
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
process.prunedGenParticles = cms.EDProducer(
"GenParticlePruner",
src=cms.InputTag("genParticles"),
select=cms.vstring(
"drop *",
"keep status = 3", # keeps all particles from the hard matrix element
"+keep abs(pdgId) = 15 & status = 1", # keeps intermediate decaying tau
),
)
"""process.pat2pxlio=cms.EDAnalyzer('EDM2PXLIO',
SelectEventsFromProcess=cms.vstring("USER"),
SelectEventsFromPath = cms.vstring("p0"),
OutFileName=cms.untracked.string("wjets.pxlio"),
process=cms.untracked.string("test"),
genCollection = cms.PSet(
type=cms.string("GenParticle2Pxlio"),
srcs=cms.VInputTag(cms.InputTag("prunedGenParticles")),
EventInfo=cms.InputTag('generator')
),
genJets = cms.PSet(
type=cms.string("GenJet2Pxlio"),
srcs=cms.VInputTag("ak5GenJets","kt4GenJets","kt6GenJets"),
names=cms.vstring("AK5GenJets","KT4GenJets","KT6GenJets")
),
q2weights = cms.PSet(
type=cms.string("ValueList2Pxlio"),
srcs=cms.VInputTag(
cms.InputTag("extraPartons","nExtraPartons"),
),
names = cms.vstring("nExtraPartons")
)
)"""
process.extraPartons = cms.EDProducer("ExtraPartonCounter", isTTJets=cms.bool("TTJets" in Config.subChannel))
process.extraPartonSequence = cms.Sequence(process.prunedGenParticles * process.extraPartons)
# process.pxlioOut=cms.EndPath(process.out*process.pat2pxlio)
process.eventVarsPath += process.extraPartonSequence
# -----------------------------------------------
# Outpath
# -----------------------------------------------
process.out = cms.OutputModule(
"PoolOutputModule",
dropMetaData=cms.untracked.string("DROPPED"),
splitLevel=cms.untracked.int32(99),
fileName=cms.untracked.string(options.outputFile),
SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring(["*"])),
outputCommands=cms.untracked.vstring(
"drop *",
#'keep *',
"keep edmMergeableCounter_*__*",
"keep *_generator__*",
#'keep *_genParticles__*', #hack for powheg PDF sets
"keep edmTriggerResults_TriggerResults__*",
"keep *_flavourAnalyzer_*_STPOLSEL2",
"keep floats_*_*_STPOLSEL2",
"keep double_*__STPOLSEL2",
"keep float_*__STPOLSEL2",
"keep double_*_*_STPOLSEL2",
"keep float_*_*_STPOLSEL2",
"keep int_*__STPOLSEL2",
"keep int_*_*_STPOLSEL2",
"keep int_*_*_*",
"keep String_*_*_*", # the decay trees
"keep *_pdfInfo1_*_STPOLSEL2",
"keep *_pdfInfo2_*_STPOLSEL2",
"keep *_pdfInfo3_*_STPOLSEL2",
"keep *_pdfInfo4_*_STPOLSEL2",
"keep *_pdfInfo5_*_STPOLSEL2",
#'keep *',
#'keep *_recoTop_*_*',
#'keep *_goodSignalMuons_*_*',
#'keep *_goodSignalElectrons_*_*',
#'keep *_goodJets_*_*',
#'keep *_bTaggedJets_*_*',
#'keep *_untaggedJets_*_*',
),
)
if Config.doDebug:
process.out.outputCommands.append("keep *")
process.debugpath = cms.Path(
process.muAnalyzer * process.eleAnalyzer * process.jetAnalyzer * process.metAnalyzer
)
process.outpath = cms.EndPath(process.out)
if Config.doSkim:
process.out.SelectEvents.SelectEvents = []
process.out.SelectEvents.SelectEvents.append("elePath")
process.out.SelectEvents.SelectEvents.append("muPath")
# -----------------------------------------------
# Final printout
# -----------------------------------------------
if hasattr(process, "out"):
print "Output patTuples: %s" % process.out.fileName.value()
print 80 * "-"
print "Step2 configured"
return process
process.RPCTwinMuxRawToDigiPacked = process.RPCTwinMuxRawToDigi.clone()
process.RPCTwinMuxRawToDigiPacked.inputTag = cms.InputTag(
"RPCTwinMuxDigiToRaw")
process.load("EventFilter.L1TXRawToDigi.twinMuxStage2Digis_cfi")
process.twinMuxStage2DigisPacked = process.twinMuxStage2Digis.clone()
process.twinMuxStage2DigisPacked.DTTM7_FED_Source = cms.InputTag(
"RPCTwinMuxDigiToRaw")
process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(True))
# Source
process.source = cms.Source("PoolSource",
fileNames=cms.untracked.vstring(
options.inputFiles),
lumisToProcess=lumilist.getVLuminosityBlockRange())
#process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(10000) )
process.maxLuminosityBlocks = cms.untracked.PSet(input=cms.untracked.int32(10))
process.p = cms.Path(
(process.rpcUnpackingModule * process.RPCTwinMuxDigiToRawPAC *
process.RPCTwinMuxRawToDigiPAC) +
(process.RPCTwinMuxRawToDigi *
((process.rpcpacker * process.rpcUnpackingModulePacked) +
(process.RPCTwinMuxDigiToRaw *
(process.RPCTwinMuxRawToDigiPacked + process.twinMuxStage2DigisPacked)))
) + process.twinMuxStage2Digis)
# Output
process.out = cms.OutputModule(
muonCollection = cms.InputTag("slimmedMuons")
metCollection = cms.InputTag("slimmedMETs")
jetCollection = cms.InputTag("slimmedJets")
metFilterBitsCollection = cms.InputTag("TriggerResults", "", miniAODProcess)
# message logger
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = options.reportEvery
# source defintion
process.source = cms.Source("PoolSource", fileNames=cms.untracked.vstring(options.inputFiles))
# good run and lumi selection
if options.isData and options.lumiFile:
lumiList = LumiList(filename=options.lumiFile)
process.source.lumisToProcess = lumiList.getVLuminosityBlockRange()
# standard sequences with global tag
if options.globalTag:
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
process.GlobalTag.globaltag = options.globalTag
# standard and geometry sequences
process.load("Configuration.StandardSequences.GeometryDB_cff")
process.load("Configuration.StandardSequences.Services_cff")
process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("Geometry.CaloEventSetup.CaloTowerConstituents_cfi")
# electron ID on uncorrected electrons
# no option to configure the electron collection available here
# https://twiki.cern.ch/twiki/bin/view/CMS/EgammaPostRecoRecipes
def updateSetup(process):
#lumiFile = 'Cert_246908-257599_13TeV_PromptReco_Collisions15_25ns_JSON.txt'
lumiFile = 'Cert_246908-258750_13TeV_PromptReco_Collisions15_25ns_JSON.txt'
runOnMC = True
for i in process.source.fileNames:
if 'Run2015' in i:
runOnMC = False
isTTbar = False
for i in process.source.fileNames:
if '/TT' in i or '/tt' in i:
isTTbar = True
if not runOnMC:
from FWCore.PythonUtilities.LumiList import LumiList
#lumiList = LumiList(os.environ["CMSSW_BASE"]+'/src/CATTools/CatProducer/prod/LumiMask/'+lumiFile)
lumiList = LumiList(os.environ["CMSSW_BASE"] +
'/src/CATTools/CommonTools/test/ttbb/' + lumiFile)
process.source.lumisToProcess = lumiList.getVLuminosityBlockRange()
if runOnMC:
setattr(process.ntuple.int, "nTrueInteraction",
cms.InputTag("pileupWeight", "nTrueInteraction"))
setattr(process.ntuple.int, "genWeightId1",
cms.InputTag("genWeight", "id1"))
setattr(process.ntuple.int, "genWeightId2",
cms.InputTag("genWeight", "id2"))
setattr(process.ntuple.float, "puWeight",
cms.InputTag("pileupWeight", ""))
setattr(process.ntuple.float, "puWeightUp",
cms.InputTag("pileupWeight", "up"))
setattr(process.ntuple.float, "puWeightDn",
cms.InputTag("pileupWeight", "dn"))
setattr(process.ntuple.float, "genWeightQ",
cms.InputTag("genWeight", "Q"))
setattr(process.ntuple.float, "genWeightX1",
cms.InputTag("genWeight", "x1"))
setattr(process.ntuple.float, "genWeightX2",
cms.InputTag("genWeight", "x2"))
setattr(process.ntuple.float, "genWeight",
cms.InputTag("genWeight", "genWeight"))
setattr(process.ntuple.float, "lheWeight",
cms.InputTag("genWeight", "lheWeight"))
setattr(process.ntuple.floats, "pdfWeight",
cms.InputTag("genWeight", "pdfWeights"))
if runOnMC and isTTbar:
process.partonTop = cms.EDProducer(
"PartonTopProducer",
genParticles=cms.InputTag("prunedGenParticles"),
jetMinPt=cms.double(20),
jetMaxEta=cms.double(2.5),
jetConeSize=cms.double(0.4),
)
setattr(process.ntuple.int, "partonTopChannel",
cms.InputTag("partonTop", "channel"))
setattr(process.ntuple.int, "genTtbarId",
cms.InputTag("GenTtbarCategories", "genTtbarId"))
setattr(process.ntuple.int, "genTtbarLeptonDecay",
cms.InputTag("genTtbarLeptonDecay", "genTtbarLeptonDecayId"))
setattr(process.ntuple.int, "NgenJet",
cms.InputTag("genTtbarLeptonDecay", "NgenJet"))
#process.ntuple.cands.gentop = cms.PSet(
# src = cms.InputTag("catGenTops"),
# #index = cms.untracked.int32(0),
# exprs = cms.untracked.PSet(
# lepton1_pt = cms.string("lepton1().Pt()"),
# lepton1_eta = cms.string("lepton1().Eta()"),
# lepton1_phi = cms.string("lepton1().Phi()"),
# lepton2_pt = cms.string("lepton2().Pt()"),
# lepton2_eta = cms.string("lepton2().Eta()"),
# lepton2_phi = cms.string("lepton2().Phi()"),
# allHadronic = cms.string("allHadronic"),
# semiLeptonic = cms.string("semiLeptonic"),
# diLeptonicMuoMuo = cms.string("diLeptonicMuoMuo"),
# diLeptonicMuoEle = cms.string("diLeptonicMuoEle"),
# diLeptonicEleEle = cms.string("diLeptonicEleEle"),
# diLeptonicTauMuo = cms.string("diLeptonicTauMuo"),
# diLeptonicTauEle = cms.string("diLeptonicTauEle"),
# diLeptonicTauTau = cms.string("diLeptonicTauTau"),
# NbJets1 = cms.string("NbJets(1)"),
# NbJets201 = cms.string("NbJets20(1)"),
# NbJets251 = cms.string("NbJets25(1)"),
# NbJets301 = cms.string("NbJets30(1)"),
# NbJets401 = cms.string("NbJets40(1)"),
# NaddbJets1 = cms.string("NaddbJets(1)"),
# NaddbJets201 = cms.string("NaddbJets20(1)"),
# NaddbJets401 = cms.string("NaddbJets40(1)"),
# NcJets1 = cms.string("NcJets(1)"),
# NcJets101 = cms.string("NcJets10(1)"),
# NcJets151 = cms.string("NcJets15(1)"),
# NcJets201 = cms.string("NcJets20(1)"),
# NcJets251 = cms.string("NcJets25(1)"),
# NcJets301 = cms.string("NcJets30(1)"),
# NcJets401 = cms.string("NcJets40(1)"),
# NbJets = cms.string("NbJets(0)"),
# NbJets20 = cms.string("NbJets20(0)"),
# NbJets25 = cms.string("NbJets25(0)"),
# NbJets30 = cms.string("NbJets30(0)"),
# NbJets40 = cms.string("NbJets40(0)"),
# NaddbJets = cms.string("NaddbJets(0)"),
# NaddbJets20 = cms.string("NaddbJets20(0)"),
# NaddbJets40 = cms.string("NaddbJets40(0)"),
# NcJets = cms.string("NcJets(0)"),
# NcJets10 = cms.string("NcJets10(0)"),
# NcJets15 = cms.string("NcJets15(0)"),
# NcJets20 = cms.string("NcJets20(0)"),
# NcJets25 = cms.string("NcJets25(0)"),
# NcJets30 = cms.string("NcJets30(0)"),
# NcJets40 = cms.string("NcJets40(0)"),
# NJets = cms.string("NJets"),
# NJets10 = cms.string("NJets10"),
# NJets20 = cms.string("NJets20"),
# NJets25 = cms.string("NJets25"),
# NJets30 = cms.string("NJets30"),
# NJets40 = cms.string("NJets40"),
# NaddJets20 = cms.string("NaddJets20"),
# NaddJets40 = cms.string("NaddJets40"),
# NbQuarksTop = cms.string("NbQuarksTop"),
# NbQuarksNoTop = cms.string("NbQuarksNoTop"),
# NbQuarks = cms.string("NbQuarks"),
# NbQuarks20 = cms.string("NbQuarks20"),
# NbQuarks40 = cms.string("NbQuarks40"),
# NaddbQuarks20 = cms.string("NaddbQuarks20"),
# NaddbQuarks40 = cms.string("NaddbQuarks40"),
# NcQuarks = cms.string("NcQuarks"),
# ),
# selections = cms.untracked.PSet(),
#)
process.ntuple.slimmedGenJets = cms.PSet(
src=cms.InputTag("slimmedGenJets", ""),
#index = cms.untracked.int32(0),
exprs=cms.untracked.PSet(
pt=cms.string("pt"),
eta=cms.string("eta"),
phi=cms.string("phi"),
m=cms.string("mass"),
#pdgId = cms.string("pdgId"),
#q = cms.string("charge"),
#status = cms.string("status"),
),
selections=cms.untracked.PSet(),
)
process.ntuple.cands.partonTop = cms.PSet(
src=cms.InputTag("partonTop"),
#index = cms.untracked.int32(0),
exprs=cms.untracked.PSet(
pt=cms.string("pt"),
eta=cms.string("eta"),
phi=cms.string("phi"),
m=cms.string("mass"),
pdgId=cms.string("pdgId"),
q=cms.string("charge"),
#status = cms.string("status"),
),
selections=cms.untracked.PSet(),
)
process.ntuple.cands.pseudoTopJet = cms.PSet(
src=cms.InputTag("pseudoTop", "jets"),
#index = cms.untracked.int32(0),
exprs=cms.untracked.PSet(
pt=cms.string("pt"),
eta=cms.string("eta"),
phi=cms.string("phi"),
m=cms.string("mass"),
pdgId=cms.string("pdgId"),
q=cms.string("charge"),
#status = cms.string("status"),
),
selections=cms.untracked.PSet(),
)
process.ntuple.cands.pseudoTopLepton = cms.PSet(
src=cms.InputTag("pseudoTop", "leptons"),
#index = cms.untracked.int32(0),
exprs=cms.untracked.PSet(
pt=cms.string("pt"),
eta=cms.string("eta"),
phi=cms.string("phi"),
m=cms.string("mass"),
pdgId=cms.string("pdgId"),
q=cms.string("charge"),
#status = cms.string("status"),
),
selections=cms.untracked.PSet(),
)
process.ntuple.cands.pseudoTopNu = cms.PSet(
src=cms.InputTag("pseudoTop", "neutrinos"),
#index = cms.untracked.int32(0),
exprs=cms.untracked.PSet(
pt=cms.string("pt"),
eta=cms.string("eta"),
phi=cms.string("phi"),
#m = cms.string("mass"),
pdgId=cms.string("pdgId"),
#q = cms.string("charge"),
#status = cms.string("status"),
),
selections=cms.untracked.PSet(),
)
process.ntuple.cands.pseudoTop = cms.PSet(
src=cms.InputTag("pseudoTop"),
#index = cms.untracked.int32(0),
exprs=cms.untracked.PSet(
pt=cms.string("pt"),
eta=cms.string("eta"),
phi=cms.string("phi"),
m=cms.string("mass"),
pdgId=cms.string("pdgId"),
q=cms.string("charge"),
#status = cms.string("status"),
),
selections=cms.untracked.PSet(),
)
process.RPCTwinMuxRawToDigiPAC = process.RPCTwinMuxRawToDigi.clone()
process.RPCTwinMuxRawToDigiPAC.inputTag = cms.InputTag("RPCTwinMuxDigiToRawPAC")
process.RPCTwinMuxRawToDigiPacked = process.RPCTwinMuxRawToDigi.clone()
process.RPCTwinMuxRawToDigiPacked.inputTag = cms.InputTag("RPCTwinMuxDigiToRaw")
process.load("EventFilter.L1TXRawToDigi.twinMuxStage2Digis_cfi")
process.twinMuxStage2DigisPacked = process.twinMuxStage2Digis.clone()
process.twinMuxStage2DigisPacked.DTTM7_FED_Source = cms.InputTag("RPCTwinMuxDigiToRaw")
process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) )
# Source
process.source = cms.Source("PoolSource"
, fileNames = cms.untracked.vstring(options.inputFiles)
, lumisToProcess = lumilist.getVLuminosityBlockRange()
)
#process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(10000) )
process.maxLuminosityBlocks = cms.untracked.PSet(input = cms.untracked.int32(10))
process.p = cms.Path( ( process.rpcUnpackingModule * process.RPCTwinMuxDigiToRawPAC * process.RPCTwinMuxRawToDigiPAC )
+ ( process.RPCTwinMuxRawToDigi
* ( ( process.rpcpacker * process.rpcUnpackingModulePacked )
+ ( process.RPCTwinMuxDigiToRaw
* ( process.RPCTwinMuxRawToDigiPacked + process.twinMuxStage2DigisPacked ) )
)
)
+ process.twinMuxStage2Digis
)
