def autoConfig(selectedComponents, sequence, services=[], xrd_aggressive=2):
import PhysicsTools.HeppyCore.framework.config as cfg
from PhysicsTools.HeppyCore.framework.eventsfwlite import Events
from CMGTools.TTHAnalysis.tools.EOSEventsWithDownload import EOSEventsWithDownload
event_class = EOSEventsWithDownload
EOSEventsWithDownload.aggressive = xrd_aggressive
if getHeppyOption("nofetch") or getHeppyOption("isCrab"):
event_class = Events
return cfg.Config(components=selectedComponents,
sequence=sequence,
services=services,
events_class=event_class)
def doTest1(comp, url=None, sequence=None, cache=False):
from PhysicsTools.HeppyCore.framework.heppy_loop import setHeppyOption
comp.files = [ url if url else comp.files[0] ]
if cache:
import os
tmpfil = os.path.expandvars("/tmp/$USER/%s" % os.path.basename(comp.files[0]))
if not os.path.exists(tmpfil):
os.system("xrdcp %s %s" % (comp.files[0],tmpfil))
comp.files = [ tmpfil ]
comp.splitFactor = 1
comp.fineSplitFactor = 5 if getHeppyOption('multi') else 1
if getHeppyOption('events'): insertEventSelector(sequence)
if not getHeppyOption('fetch'): setHeppyOption('nofetch')
return [ comp ]
def insertEventSelector(sequence):
if not sequence: raise RuntimeError, "to apply an event selection, I need a sequence"
from PhysicsTools.Heppy.analyzers.core.EventSelector import eventSelector
eventSelector = cfg.Analyzer(EventSelector,
name="EventSelector",
toSelect = [ eval("("+x.replace(":",",")+")") for x in getHeppyOption('events').split(",") ],
)
sequence.insert(0, eventSelector)
print "Will select events", eventSelector.toSelect
def insertEventSelector(sequence):
if not sequence:
raise RuntimeError, "to apply an event selection, I need a sequence"
from CMGTools.HToZZ4L.analyzers.hzz4lCore_modules_cff import eventSelector
eventSelector.toSelect = [
eval("(" + x.replace(":", ",") + ")")
for x in getHeppyOption('events').split(",")
]
sequence.insert(0, eventSelector)
print "Will select events ", eventSelector.toSelect
#-------- SEQUENCE
sequence = cfg.Sequence(dmCoreSequence+[
monoXRazorAna,
monoXMT2Ana,
ttHFatJetAna,
ttHAlphaTAna,
ttHAlphaTControlAna,
monoJetVarAna,
MonoJetEventAna,
treeProducer,
])
#-------- HOW TO RUN -----------
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
test = getHeppyOption('test')
if test == '1':
monoJetSkim.metCut = 0
comp = DYJetsToLL_M50_HT100to200
comp.files = comp.files[:1]
comp.splitFactor = 1
comp.fineSplitFactor = 1
selectedComponents = [ comp ]
elif test == '2':
for comp in selectedComponents:
comp.files = comp.files[:1]
comp.splitFactor = 1
comp.fineSplitFactor = 1
elif test == 'EOS':
comp = DYJetsToLL_M50
comp.files = comp.files[:1]
import PhysicsTools.HeppyCore.framework.config as cfg
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from PhysicsTools.HeppyCore.framework.config import printComps
test = getHeppyOption('test', False)
year = getHeppyOption('year', '2016')
#btagger = getHeppyOption('btagger', 'CSVv2' )
btagger = getHeppyOption('btagger', 'DeepCSV')
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
ComponentCreator.useLyonAAA = True
#ComponentCreator.useAAA = True
################################################################################
# Analyzers
################################################################################
from PhysicsTools.Heppy.analyzers.core.JSONAnalyzer import JSONAnalyzer
from PhysicsTools.Heppy.analyzers.core.SkimAnalyzerCount import SkimAnalyzerCount
from PhysicsTools.Heppy.analyzers.objects.VertexAnalyzer import VertexAnalyzer
json = cfg.Analyzer(
JSONAnalyzer,
name='JSONAnalyzer',
)
vertex = cfg.Analyzer(VertexAnalyzer,
name='VertexAnalyzer',
fixedWeight=1,
keepFailingEvents=True,
verbose=False)
ttHTopoJetAna,
ttHIsrJetAna,
treeProducer,
])
###---- to switch off the compression
#treeProducer.isCompressed = 0
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
#-------- HOW TO RUN
# choose 0 for quick validations tests. It doesn't require to load the sample files
# choose 2 for full mc production
# choose 3 for data production
# choose 4 for signal production
test = int(getHeppyOption('test', 0))
test = 4
isData = False # will be changed accordingly if chosen to run on data
doSpecialSettingsForMECCA = 1 # set to 1 for comparisons with americans
runPreprocessor = True #because of the EEModifiedMET
#runPreprocessor = False
#from CMGTools.RootTools.samples.samples_13TeV_RunIIFall17MiniAODv2 import *
if test == 0:
# ------------------------------------------------------------------------------------------- #
# --- all this lines taken from CMGTools.RootTools.samples.samples_13TeV_PHYS14
# --- They may not be in synch anymore
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
kreator = ComponentCreator()
testComponent = kreator.makeMCComponent(
from CMGTools.HNL.analyzers.EventFilter import EventFilter
from pdb import set_trace
# import 2016 triggers
from CMGTools.HNL.triggers.triggers_2016 import triggers_ele_data, triggers_mu_data, triggers_and_filters_ele, triggers_and_filters_mu
from CMGTools.HNL.samples.samples_data_2016 import Single_ele_2016, Single_ele_2016H, Single_ele_2016G, Single_ele_2016F, Single_ele_2016E, Single_ele_2016B, Single_ele_2016C, Single_ele_2016D
from CMGTools.HNL.samples.samples_data_2016 import Single_mu_2016, Single_mu_2016H, Single_mu_2016G, Single_mu_2016F, Single_mu_2016E, Single_mu_2016B, Single_mu_2016C, Single_mu_2016D
###################################################
### OPTIONS ###
###################################################
# Get all heppy options; set via "-o production" or "-o production=True"
# production = True run on batch, production = False (or unset) run locally
pick_events = getHeppyOption('pick_events', False)
###################################################
### HANDLE SAMPLES ###
###################################################
samples = Single_mu_2016 + Single_ele_2016
###################################################
# are trigger names and filters correct regardless of the year?
# triggers same for 2017: https://tomc.web.cern.ch/tomc/triggerPrescales/2017//?match=Ele
for sample in samples:
sample.triggers = triggers_ele_data + triggers_mu_data
sample.splitFactor = splitFactor(sample, 1e6)
selectedComponents = samples
printSummary(selectedComponents)
#redefineRunRange(selectedComponents,[258214,258214])
if True: autoAAA(selectedComponents)
if run == "Mu":
doKalmanMuonCorrections(smear="basic")
fastSkim2L.eleCut = lambda ele: False
lepAna.loose_electron_isoCut = lambda ele: False
elif run == "El":
doECalCorrections(era="25ns")
fastSkim2L.muCut = lambda mu: False
lepAna.loose_muon_isoCut = lambda mu: False
else:
doECalCorrections(era="25ns")
doKalmanMuonCorrections(smear="basic")
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
test = getHeppyOption('test')
if test in ("1", "1M", "1E"):
component = {
"1": DYJetsToLL_LO_M50,
"1M": DoubleMuon_Run2015D_16Dec2015_25ns,
"1E": DoubleEG_Run2015D_16Dec2015_25ns
}[test]
if not component.isMC: redefineRunRange([component], [258214, 258214])
selectedComponents = doTest1(component, sequence=sequence)
elif test in ('2', '3', '5'):
doTestN(test, selectedComponents)
config = autoConfig(selectedComponents, sequence)
from CMGTools.ExclusiveW.analyzers.GammaSelector import GammaSelector
from CMGTools.ExclusiveW.analyzers.LeptonicTopBuilder import LeptonicTopBuilder
# import samples, signal
from CMGTools.RootTools.samples.samples_13TeV_RunIISummer16MiniAODv2 import TTJets_SingleLeptonFromTbar, TTJets_SingleLeptonFromTbar_ext, TTJets_SingleLeptonFromT, TTJets_SingleLeptonFromT_ext
from CMGTools.ExclusiveW.samples.mc_2016 import WtoDsGamma
puFileMC = '$CMSSW_BASE/src/CMGTools/H2TauTau/data/MC_Moriond17_PU25ns_V1.root'
puFileData = '/afs/cern.ch/user/a/anehrkor/public/Data_Pileup_2016_271036-284044_80bins.root'
###################################################
### OPTIONS ###
###################################################
# Get all heppy options; set via "-o production" or "-o production=True"
# production = True run on batch, production = False (or unset) run locally
production = getHeppyOption('production', False)
pick_events = getHeppyOption('pick_events', False)
###################################################
### HANDLE SAMPLES ###
###################################################
samples = [
WtoDsGamma
] ##TTJets_SingleLeptonFromTbar, TTJets_SingleLeptonFromTbar_ext, TTJets_SingleLeptonFromT, TTJets_SingleLeptonFromT_ext]
for sample in samples:
sample.triggers = ['HLT_IsoMu24_v%d' % i for i in range(4, 5)]
sample.triggers += ['HLT_IsoTkMu24_v%d' % i for i in range(4, 5)]
# specify which muon should match to which filter.
# sample.trigger_filters = [
# test all components (1 thread per component).
selectedComponents = [RSGravToWWToLNQQ_kMpl01_4500]
for comp in selectedComponents:
comp.splitFactor = 20
## output histogram
outputService=[]
from PhysicsTools.HeppyCore.framework.services.tfile import TFileService
output_service = cfg.Service(
TFileService,
'outputfile',
name="outputfile",
fname='vvTreeProducer/tree.root',
option='recreate'
)
outputService.append(output_service)
from PhysicsTools.HeppyCore.framework.eventsfwlite import Events
from CMGTools.TTHAnalysis.tools.EOSEventsWithDownload import EOSEventsWithDownload
event_class = EOSEventsWithDownload
event_class = Events
if getHeppyOption("nofetch"):
event_class = Events
config = cfg.Config( components = selectedComponents,
sequence = sequence,
services = [],
events_class = event_class)
#-------- SAMPLES AND TRIGGERS -----------
#-------- SEQUENCE
from CMGTools.HToZZ4L.samples.samples_13TeV_Spring15 import *
selectedComponents = mcSamples + dataSamples
sequence = cfg.Sequence(hzz4lCoreSequence)
for comp in mcSamples:
comp.triggers = []
comp.vetoTriggers = []
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
test = getHeppyOption('test')
if test == "1":
comp = QQHZZ4L
comp.files = comp.files[:1]
comp.splitFactor = 1
comp.fineSplitFactor = 1 if getHeppyOption('single') else 5
selectedComponents = [ comp ]
if getHeppyOption('events'):
eventSelector.toSelect = [ eval("("+x.replace(":",",")+")") for x in getHeppyOption('events').split(",") ]
sequence = cfg.Sequence([eventSelector] + hzz4lCoreSequence)
print "Will select events ",eventSelector.toSelect
elif test == '2':
for comp in selectedComponents:
comp.files = comp.files[:1]
comp.splitFactor = 1
comp.fineSplitFactor = 1
##########################################################
## CONFIGURATION FOR EXO MONOJET TREES ##
## skim condition: MET > 200 GeV ##
##########################################################
import PhysicsTools.HeppyCore.framework.config as cfg
import re
# Load all analyzers
from CMGTools.MonoXAnalysis.analyzers.dmCore_modules_cff import *
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
#-------- SET OPTIONS AND REDEFINE CONFIGURATIONS -----------
is50ns = getHeppyOption("is50ns",False)
runData = getHeppyOption("runData",True)
scaleProdToLumi = float(getHeppyOption("scaleProdToLumi",-1)) # produce rough equivalent of X /pb for MC datasets
saveSuperClusterVariables = getHeppyOption("saveSuperClusterVariables",True)
removeJetReCalibration = getHeppyOption("removeJetReCalibration",False)
doT1METCorr = getHeppyOption("doT1METCorr",True)
forcedSplitFactor = getHeppyOption("splitFactor",-1)
forcedFineSplitFactor = getHeppyOption("fineSplitFactor",-1)
isTest = getHeppyOption("test",None) != None and not re.match("^\d+$",getHeppyOption("test"))
# Define skims
signalSkim = False
diLepSkim = False
singleLepSkim = True
# --- MONOJET SKIMMING ---
if signalSkim == True:
monoJetSkim.metCut = 200
##########################################################
## CONFIGURATION FOR SUSY MULTILEPTON TREES ##
## skim condition: >= 2 loose leptons, no pt cuts or id ##
##########################################################
import PhysicsTools.HeppyCore.framework.config as cfg
import re
#-------- LOAD ALL ANALYZERS -----------
from CMGTools.TTHAnalysis.analyzers.susyCore_modules_cff import *
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
#-------- SET OPTIONS AND REDEFINE CONFIGURATIONS -----------
is50ns = getHeppyOption("is50ns",False)
runData = getHeppyOption("runData",False)
runDataQCD = getHeppyOption("runDataQCD",False)
runFRMC = getHeppyOption("runFRMC",False)
runSMS = getHeppyOption("runSMS",False)
scaleProdToLumi = float(getHeppyOption("scaleProdToLumi",-1)) # produce rough equivalent of X /pb for MC datasets
SOS = getHeppyOption("SOS",False) ## switch True to overwrite settings for SOS skim (N.B. default settings are those from multilepton preselection)
saveSuperClusterVariables = getHeppyOption("saveSuperClusterVariables",False)
removeJetReCalibration = getHeppyOption("removeJetReCalibration",False)
doMETpreprocessor = getHeppyOption("doMETpreprocessor",False)
doT1METCorr = getHeppyOption("doT1METCorr",False)
old74XMiniAODs = (getHeppyOption("old74XMiniAODs", not runData) not in (False,"False"))
noMETNoHF = getHeppyOption("noMETNoHF",False)
#doAK4PFCHSchargedJets = getHeppyOption("doAK4PFCHSchargedJets",False)
forcedSplitFactor = getHeppyOption("splitFactor",-1)
forcedFineSplitFactor = getHeppyOption("fineSplitFactor",-1)
#configureSplittingFromTime( H4L + [ GGZZTo4mu, GGZZTo4e, GGZZTo2e2mu], 100.0, 1)
#selectedComponents = [ DYJetsToLL_M50, DYJetsToLL_LO_M50, DYBJetsToLL, DYBBJetsToLL ] + DYJetsM50HT
#configureSplittingFromTime(selectedComponents, 20.0, 1)
#configureSplittingFromTime([DYJetsToLL_M50_HT400to600], 40.0, 1)
#configureSplittingFromTime([DYJetsToLL_M50_HT600toInf], 60.0, 1)
sequence = cfg.Sequence(hzz4lCoreSequence)
for comp in mcSamples:
comp.triggers = triggers_any
comp.vetoTriggers = []
#doECalCorrections(era="25ns")
#doKalmanMuonCorrections(smear="basic")
if not getHeppyOption("test"):
printSummary(selectedComponents)
autoAAA(selectedComponents)
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
test = getHeppyOption('test')
if test == "1":
selectedComponents = doTest1(GGHZZ4L, sequence=sequence, cache=True)
elif test == "1ZZ":
selectedComponents = doTest1(ZZTo4L, sequence=sequence, cache=True)
elif test == "1F":
DYJetsToLL_M50.files = [
'/afs/cern.ch/work/g/gpetrucc/CMSSW_7_4_13/src/CMGTools/HToZZ4L/cfg/four-events.root'
]
selectedComponents = doTest1(DYJetsToLL_M50,
sequence=sequence,
logging.shutdown()
#reload(logging)
logging.basicConfig(level=logging.WARNING)
from PhysicsTools.HeppyCore.framework.event import Event
Event.print_patterns = ['*taus*', '*muons*', '*electrons*', 'veto_*',
'*dileptons_*', '*jets*']
###############
# Options
###############
# Get all heppy options; set via "-o production" or "-o production=True"
# production = True run on batch, production = False run locally
test = getHeppyOption('test', False)
syncntuple = getHeppyOption('syncntuple', False)
data = getHeppyOption('data', False) # set later
embedded = getHeppyOption('embedded', False) # set later
if embedded:
data = True
add_sys = getHeppyOption('add_sys', True)
reapplyJEC = getHeppyOption('reapplyJEC', True)
samples_name = getHeppyOption('samples_name', 'sm_higgs') # options : DY, TTbar, generic_background, data_tau, data_single_muon, data_single_electron, embedded_tt, embedded_mt, embedded_et, sm_higgs, mssm_signals
AAA = getHeppyOption('AAA', 'global') # options : global, Lyon
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
if AAA == 'Lyon':
ComponentCreator.useLyonAAA = True
else:
ComponentCreator.useAAA = True
from CMGTools.RootTools.samples.configTools import printSummary, mergeExtensions, doTestN, configureSplittingFromTime, cropToLumi
from CMGTools.RootTools.samples.autoAAAconfig import autoAAA
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from CMGTools.RootTools.samples.configTools import *
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
import time
kreator = ComponentCreator()
def byCompName(components, regexps):
return [c for c in components if any(re.match(r, c.name) for r in regexps)]
# parse options
filterSample = str(getHeppyOption("filterSample", ""))
mc = getHeppyOption("mc", False)
data = getHeppyOption("data", False)
njobs = getHeppyOption("njobs", 1)
nfiles = getHeppyOption("nfiles", 1000)
kmumu = getHeppyOption("kmumu", False)
kstarmumu = getHeppyOption("kstarmumu", False)
kshortmumu = getHeppyOption("kshortmumu", False)
kee = getHeppyOption("kee", True)
onlyPFe = getHeppyOption("onlyPFe", False)
jpsi = getHeppyOption("jpsi", True)
psi2s = getHeppyOption("psi2s", False)
test = getHeppyOption("test", True)
start_time = time.time()
print('here')
"CMS", ".*root",
json=json,
run_range=run_range,
triggers=triggers[:], vetoTriggers = vetos[:],
useAAA=useAAA)
print "Will process %s (%d files)" % (comp.name, len(comp.files))
# print "\ttrigger sel %s, veto %s" % (triggers, vetos)
comp.splitFactor = len(comp.files)
comp.fineSplitFactor = 1
selectedComponents.append( comp )
vetos += triggers
if json is None:
susyCoreSequence.remove(jsonAna)
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
test = getHeppyOption('test')
#test = '74X-MC'
if test == 'synch':
print 'I\'m in the synch test thing here!!'
comp = TTLep_pow
selectedComponents = [comp]
comp.files = comp.files[:1]
#comp.files = [
#'/afs/cern.ch/work/m/mdunser/public/synchFiles/004613BA-C46D-E511-9EB6-001E67248732.root',
#]
#comp.finesplitFactor = 10
#comp.finesplitFactor = 4
elif test == '74X-MC':
#what = getHeppyOption("sample")
what = 'TT'
if what == "TTLep":
#-------- SAMPLES AND TRIGGERS -----------
#-------- SEQUENCE
from CMGTools.HToZZ4L.samples.samples_13TeV_Spring15 import *
selectedComponents = mcSamples + dataSamples
sequence = cfg.Sequence(hzz4lCoreSequence)
for comp in mcSamples:
comp.triggers = []
comp.vetoTriggers = []
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
test = getHeppyOption('test')
if test == "1":
comp = QQHZZ4L
comp.files = comp.files[:1]
comp.splitFactor = 1
comp.fineSplitFactor = 1 if getHeppyOption('single') else 5
selectedComponents = [comp]
if getHeppyOption('events'):
eventSelector.toSelect = [
eval("(" + x.replace(":", ",") + ")")
for x in getHeppyOption('events').split(",")
]
sequence = cfg.Sequence([eventSelector] + hzz4lCoreSequence)
print "Will select events ", eventSelector.toSelect
elif test == '2':
for comp in selectedComponents:
import PhysicsTools.HeppyCore.framework.config as cfg
from PhysicsTools.HeppyCore.framework.config import printComps
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from PhysicsTools.HeppyCore.framework.eventsfwlite import Events
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
from CMGTools.H2TauTau.proto.analyzers.TauHLTAnalyzer import TauHLTAnalyzer
from CMGTools.H2TauTau.proto.analyzers.HLTTauTreeProducer import HLTTauTreeProducer
production = getHeppyOption('production', True)
c = ComponentCreator()
# ggH135_0 = c.makeMCComponentFromEOS('ggH135_rawaod', 'ggH135_rawaod', '/store/group/phys_higgs/cmshtt/steggema/HPSatHLTv5/GluGluHToTauTau_M125_13TeV_powheg_pythia8/TauHPSatHLTFine/161117_103941/0000/')
# ggH135_1 = c.makeMCComponentFromEOS('ggH135_rawaod', 'ggH135_rawaod', '/store/group/phys_higgs/cmshtt/steggema/HPSatHLTv5/GluGluHToTauTau_M125_13TeV_powheg_pythia8/TauHPSatHLTFine/161117_103941/0001/')
ggH135_0 = c.makeMCComponentFromEOS(
'ggH135_rawaod', 'ggH135_rawaod',
'/store/group/phys_tau/HLT2016/HPSatHLT/GluGluHToTauTau_M125_13TeV_powheg_pythia8/HPSatHLT/161206_134434/0000/'
)
ggH135_1 = c.makeMCComponentFromEOS(
'ggH135_rawaod_2', 'ggH135_rawaod',
'/store/group/phys_tau/HLT2016/HPSatHLT/GluGluHToTauTau_M125_13TeV_powheg_pythia8/HPSatHLT/161206_134434/0001/'
)
selectedComponents = [ggH135_0, ggH135_1]
tauHLTAna = cfg.Analyzer(
TauHLTAnalyzer,
name='TauHLTAnalyzer',
)
##########################################################
## CONFIGURATION FOR SUSY MULTILEPTON TREES ##
## skim condition: >= 2 loose leptons, no pt cuts or id ##
##########################################################
import PhysicsTools.HeppyCore.framework.config as cfg
import re
#-------- LOAD ALL ANALYZERS -----------
from CMGTools.TTHAnalysis.analyzers.susyCore_modules_cff import *
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
#-------- SET OPTIONS AND REDEFINE CONFIGURATIONS -----------
is50ns = getHeppyOption("is50ns",False)
runData = getHeppyOption("runData",False)
runDataQCD = getHeppyOption("runDataQCD",False)
runSMS = getHeppyOption("runSMS",False)
scaleProdToLumi = float(getHeppyOption("scaleProdToLumi",-1)) # produce rough equivalent of X /pb for MC datasets
SOS = getHeppyOption("SOS",False) ## switch True to overwrite settings for SOS skim (N.B. default settings are those from multilepton preselection)
saveSuperClusterVariables = getHeppyOption("saveSuperClusterVariables",False)
removeJetReCalibration = getHeppyOption("removeJetReCalibration",False)
removeJecUncertainty = getHeppyOption("removeJecUncertainty",False)
doMETpreprocessor = getHeppyOption("doMETpreprocessor",False)
skipT1METCorr = getHeppyOption("skipT1METCorr",False)
#doAK4PFCHSchargedJets = getHeppyOption("doAK4PFCHSchargedJets",False)
forcedSplitFactor = getHeppyOption("splitFactor",-1)
forcedFineSplitFactor = getHeppyOption("fineSplitFactor",-1)
isTest = getHeppyOption("test",None) != None and not re.match("^\d+$",getHeppyOption("test"))
##########################################################
## CONFIGURATION FOR EXO MONOJET TREES ##
## skim condition: MET > 200 GeV ##
##########################################################
import PhysicsTools.HeppyCore.framework.config as cfg
import re
# Load all analyzers
from CMGTools.MonoXAnalysis.analyzers.dmCore_modules_cff import *
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from CMGTools.RootTools.samples.autoAAAconfig import *
#-------- SET OPTIONS AND REDEFINE CONFIGURATIONS -----------
is50ns = getHeppyOption("is50ns",False)
runData = getHeppyOption("runData",False)#True)
scaleProdToLumi = float(getHeppyOption("scaleProdToLumi",-1)) # produce rough equivalent of X /pb for MC datasets
saveSuperClusterVariables = getHeppyOption("saveSuperClusterVariables",True)
saveFatJetIDVariables = getHeppyOption("saveFatJetIDVariables",True)
saveHEEPVariables = getHeppyOption("saveHEEPVariables",True)
removeJetReCalibration = getHeppyOption("removeJetReCalibration",False)
doT1METCorr = getHeppyOption("doT1METCorr",True)
forcedSplitFactor = getHeppyOption("splitFactor",-1)
forcedFineSplitFactor = getHeppyOption("fineSplitFactor",-1)
isTest = getHeppyOption("isTest",True)#False)
doLepCorr = getHeppyOption("doLepCorr",False)
doPhotonCorr = getHeppyOption("doPhotonCorr",False)
# Define skims
signalSkim = False
from PhysicsTools.Heppy.utils.cmsswPreprocessor import CmsswPreprocessor
from CMGTools.H2TauTau.proto.analyzers.FileCleaner import FileCleaner
from CMGTools.H2TauTau.proto.samples.spring16.htt_common import backgrounds_mu, sm_signals, mssm_signals, data_single_muon, sync_list
from CMGTools.RootTools.utils.splitFactor import splitFactor
from CMGTools.H2TauTau.proto.samples.spring16.triggers_muMu import mc_triggers, mc_triggerfilters
from CMGTools.H2TauTau.proto.samples.spring16.triggers_muMu import data_triggers, data_triggerfilters
from CMGTools.RootTools.samples.autoAAAconfig import autoAAA
# common configuration and sequence
from CMGTools.H2TauTau.htt_ntuple_base_cff import commonSequence, jetAna, dyJetsFakeAna, puFileData, puFileMC, eventSelector
# mu-mu specific configuration settings
production = getHeppyOption('production', True)
pick_events = getHeppyOption('pick_events', False)
syncntuple = getHeppyOption('syncntuple', True)
cmssw = getHeppyOption('cmssw', True)
computeSVfit = getHeppyOption('computeSVfit', False)
data = getHeppyOption('data', False)
reapplyJEC = getHeppyOption('reapplyJEC', True)
dyJetsFakeAna.channel = 'mm'
# Just to be sure
if production:
syncntuple = False
pick_events = False
if reapplyJEC:
logging.shutdown()
# reload(logging)
logging.basicConfig(level=logging.WARNING)
from PhysicsTools.HeppyCore.framework.event import Event
Event.print_patterns = ['*taus*', '*muons*', '*electrons*', 'veto_*',
'*dileptons_*', '*jets*']
###############
# Options
###############
# Get all heppy options; set via "-o production" or "-o production=True"
# production = True run on batch, production = False run locally
test = getHeppyOption('test', True)
syncntuple = getHeppyOption('syncntuple', True)
data = getHeppyOption('data', False)
embedded = getHeppyOption('embedded', True)
if embedded:
data = True
tes_string = getHeppyOption('tes_string', '') # '_tesup' '_tesdown'
reapplyJEC = getHeppyOption('reapplyJEC', True)
# For specific studies
add_iso_info = getHeppyOption('add_iso_info', False)
add_tau_fr_info = getHeppyOption('add_tau_fr_info', False)
###############
# global tags
###############
import re, os, sys
from CMGTools.RootTools.samples.configTools import printSummary, mergeExtensions, doTestN, configureSplittingFromTime, cropToLumi
from CMGTools.RootTools.samples.autoAAAconfig import autoAAA
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
kreator = ComponentCreator()
def byCompName(components, regexps):
return [ c for c in components if any(re.match(r, c.name) for r in regexps) ]
year = int(getHeppyOption("year", "2018"))
analysis = getHeppyOption("analysis", "main")
preprocessor = getHeppyOption("nanoPreProcessor")
if getHeppyOption("nanoPreProcessor"):
if year == 2018:
from CMGTools.RootTools.samples.samples_13TeV_RunIIAutumn18MiniAOD import samples as mcSamples_
from CMGTools.RootTools.samples.samples_13TeV_DATA2018_MiniAOD import samples as allData
elif year == 2017:
from CMGTools.RootTools.samples.samples_13TeV_RunIIFall17MiniAOD import samples as mcSamples_
from CMGTools.RootTools.samples.samples_13TeV_DATA2017 import dataSamples_31Mar2018 as allData
elif year == 2016:
from CMGTools.RootTools.samples.samples_13TeV_RunIISummer16MiniAODv3 import samples as mcSamples_
from CMGTools.RootTools.samples.samples_13TeV_DATA2016 import dataSamples_17Jul2018 as allData
else:
if year == 2018:
from CMGTools.RootTools.samples.samples_13TeV_RunIIAutumn18NanoAODv6 import samples as mcSamples_
from CMGTools.RootTools.samples.samples_13TeV_DATA2018_NanoAOD import dataSamples_25Oct2019 as allData
elif year == 2017:
from CMGTools.RootTools.samples.samples_13TeV_RunIIFall17NanoAODv6 import samples as mcSamples_
from CMGTools.RootTools.samples.samples_13TeV_DATA2017_NanoAOD import dataSamples_25Oct2019 as allData
from CMGTools.RootTools.samples.configTools import printSummary, mergeExtensions, doTestN, configureSplittingFromTime, cropToLumi
from CMGTools.RootTools.samples.autoAAAconfig import autoAAA
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from CMGTools.RootTools.samples.configTools import *
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
import time
kreator = ComponentCreator()
def byCompName(components, regexps):
return [c for c in components if any(re.match(r, c.name) for r in regexps)]
# parse options
filterSample = str(getHeppyOption("filterSample", ""))
mc = getHeppyOption("mc", False)
data = getHeppyOption("data", False)
njobs = getHeppyOption("njobs", 10)
nfiles = getHeppyOption("nfiles", 1)
kmumu = getHeppyOption("kmumu", False)
kstarmumu = getHeppyOption("kstarmumu", False)
kshortmumu = getHeppyOption("kshortmumu", False)
kee = getHeppyOption("kee", False)
onlyPFe = getHeppyOption("onlyPFe", False)
onlyLowPtAndPFe = getHeppyOption(
"onlyLowPtAndPFe", False) # b cands with 1 low and 1 pf e only created
jpsi = getHeppyOption("jpsi", False)
psi2s = getHeppyOption("psi2s", False)
test = getHeppyOption("test")
start_time = time.time()
def generateKeyConfigs(samples,production, promptLeptonType, L1L2LeptonType, isData, isSignal):
import os
from collections import OrderedDict
import PhysicsTools.HeppyCore.framework.config as cfg
from PhysicsTools.HeppyCore.framework.config import printComps
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from PhysicsTools.Heppy.utils.cmsswPreprocessor import CmsswPreprocessor
from CMGTools.RootTools.utils.splitFactor import splitFactor
# import Heppy analyzers:
from PhysicsTools.Heppy.analyzers.core.JSONAnalyzer import JSONAnalyzer
from PhysicsTools.Heppy.analyzers.core.SkimAnalyzerCount import SkimAnalyzerCount
from PhysicsTools.Heppy.analyzers.core.EventSelector import EventSelector
from PhysicsTools.Heppy.analyzers.objects.VertexAnalyzer import VertexAnalyzer
from PhysicsTools.Heppy.analyzers.core.PileUpAnalyzer import PileUpAnalyzer
from PhysicsTools.Heppy.analyzers.gen.GeneratorAnalyzer import GeneratorAnalyzer
from PhysicsTools.Heppy.analyzers.gen.LHEWeightAnalyzer import LHEWeightAnalyzer
from CMGTools.H2TauTau.proto.analyzers.TriggerAnalyzer import TriggerAnalyzer
# import HNL analyzers:
from CMGTools.HNL.analyzers.HNLAnalyzer import HNLAnalyzer
from CMGTools.HNL.analyzers.HNLTreeProducer import HNLTreeProducer
from CMGTools.HNL.analyzers.HNLGenTreeAnalyzer import HNLGenTreeAnalyzer
from CMGTools.HNL.analyzers.RecoGenAnalyzer import RecoGenAnalyzer
from CMGTools.HNL.analyzers.TriggerAnalyzer import TriggerAnalyzer
from CMGTools.HNL.analyzers.JetAnalyzer import JetAnalyzer
from CMGTools.HNL.analyzers.METFilter import METFilter
from CMGTools.HNL.analyzers.LeptonWeighter import LeptonWeighter
from pdb import set_trace
###################################################
### OPTIONS ###
###################################################
# Get all heppy options; set via "-o production" or "-o production=True"
# production = True run on batch, production = False (or unset) run locally
production = getHeppyOption('production' , production)
pick_events = getHeppyOption('pick_events', False)
promptLeptonType = promptLeptonType # choose from 'ele' or 'mu'
L1L2LeptonType = L1L2LeptonType #choose from 'ee', 'mm', 'em'
###################################################
### HANDLE SAMPLES ###
###################################################
#samples = [comp for comp in samples if comp.name=='TTJets_amcat']
if promptLeptonType == 'ele':
for sample in samples:
sample.triggers = ['HLT_Ele27_WPTight_Gsf_v%d' %i for i in range(1, 15)] #electron trigger
sample.triggers += ['HLT_Ele32_WPTight_Gsf_v%d' %i for i in range(1, 15)] #electron trigger
sample.triggers += ['HLT_Ele35_WPTight_Gsf_v%d' %i for i in range(1, 15)] #electron trigger
sample.triggers += ['HLT_Ele115_CaloIdVT_GsfTrkIdT_v%d' %i for i in range(1, 15)] #electron trigger
sample.triggers += ['HLT_Ele135_CaloIdVT_GsfTrkIdT_v%d' %i for i in range(1, 15)] #electron trigger
sample.splitFactor = splitFactor(sample, 1e5)
if promptLeptonType == 'mu':
for sample in samples:
sample.triggers = ['HLT_IsoMu24_v%d' %i for i in range(1, 15)] #muon trigger
sample.triggers += ['HLT_IsoMu27_v%d' %i for i in range(1, 15)] #muon trigger
sample.triggers += ['HLT_Mu50_v%d' %i for i in range(1, 15)] #muon trigger
sample.splitFactor = splitFactor(sample, 1e5)
selectedComponents = samples
###################################################
### ANALYZERS ###
###################################################
eventSelector = cfg.Analyzer(
EventSelector,
name='EventSelector',
toSelect=[326]
)
lheWeightAna = cfg.Analyzer(
LHEWeightAnalyzer, name="LHEWeightAnalyzer",
useLumiInfo=False
)
jsonAna = cfg.Analyzer(
JSONAnalyzer,
name='JSONAnalyzer',
)
skimAna = cfg.Analyzer(
SkimAnalyzerCount,
name='SkimAnalyzerCount'
)
triggerAna = cfg.Analyzer(
TriggerAnalyzer,
name='TriggerAnalyzer',
addTriggerObjects=True,
requireTrigger=True,
usePrescaled=False,
unpackLabels=True,
)
vertexAna = cfg.Analyzer(
VertexAnalyzer,
name='VertexAnalyzer',
fixedWeight=1,
keepFailingEvents=False,
verbose=False
)
pileUpAna = cfg.Analyzer(
PileUpAnalyzer,
name='PileUpAnalyzer',
true=True
)
metFilter = cfg.Analyzer(
METFilter,
name='METFilter',
processName='PAT', #mschoene: Filters very much do exist in MC and most of them should be applied to MC as well, but not all!
fallbackProcessName = 'RECO',
triggers=[
'Flag_goodVertices',
'Flag_globalSuperTightHalo2016Filter',
'Flag_HBHENoiseFilter',
'Flag_HBHENoiseIsoFilter',
'Flag_EcalDeadCellTriggerPrimitiveFilter',
'Flag_BadPFMuonFilter',
'Flag_BadChargedCandidateFilter',
'Flag_eeBadScFilter',
'Flag_ecalBadCalibFilter',
]
)
HNLTreeProducer = cfg.Analyzer(
HNLTreeProducer,
name='HNLTreeProducer',
L1L2LeptonType=L1L2LeptonType,
promptLepType=promptLeptonType,
)
HNLGenTreeAnalyzer = cfg.Analyzer(
HNLGenTreeAnalyzer,
name='HNLGenTreeAnalyzer',
)
RecoGenAnalyzer = cfg.Analyzer(
RecoGenAnalyzer,
name='RecoGenAnalyzer',
)
genAna = GeneratorAnalyzer.defaultConfig
genAna.allGenTaus = True # save in event.gentaus *ALL* taus, regardless whether hadronic / leptonic decay
# for each path specify which filters you want the electrons/muons to match to
triggers_and_filters = OrderedDict()
if promptLeptonType == 'ele':
triggers_and_filters['HLT_Ele27_WPTight_Gsf'] = 'hltEle27WPTightGsfTrackIsoFilter'
triggers_and_filters['HLT_Ele32_WPTight_Gsf'] = 'hltEle32WPTightGsfTrackIsoFilter'
triggers_and_filters['HLT_Ele35_WPTight_Gsf'] = 'hltEle35noerWPTightGsfTrackIsoFilter'
triggers_and_filters['HLT_Ele115_CaloIdVT_GsfTrkIdT'] = 'hltEle115CaloIdVTGsfTrkIdTGsfDphiFilter'
triggers_and_filters['HLT_Ele135_CaloIdVT_GsfTrkIdT'] = 'hltEle135CaloIdVTGsfTrkIdTGsfDphiFilter'
if promptLeptonType == 'mu':
triggers_and_filters['HLT_IsoMu24'] = 'hltL3crIsoL1sSingleMu22L1f0L2f10QL3f24QL3trkIsoFiltered0p07'
triggers_and_filters['HLT_IsoMu27'] = 'hltL3crIsoL1sMu22Or25L1f0L2f10QL3f27QL3trkIsoFiltered0p07'
triggers_and_filters['HLT_Mu50'] = 'hltL3fL1sMu22Or25L1f0L2f10QL3Filtered50Q'
# TODO: add (HLT_IsoTkMu24_v*) and (HLT_TkMu50_v*); but only later for 2016 dataset
HNLAnalyzer = cfg.Analyzer(
HNLAnalyzer,
name='HNLAnalyzer',
promptLepton=promptLeptonType,
L1L2LeptonType=L1L2LeptonType,
triggersAndFilters=triggers_and_filters,
candidate_selection='maxpt',
)
if promptLeptonType == 'ele':
Weighter_l0 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l0',
scaleFactorFiles={
'trigger' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_trg_SingleEle_Ele32OREle35_desy'),
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l0(),
disable=False
)
if promptLeptonType == 'mu':
Weighter_l0 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l0',
scaleFactorFiles={
'trigger' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_trg_SingleMu_Mu24ORMu27_desy'),
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l0(),
disable=False
)
if L1L2LeptonType == 'mm':
Weighter_l1 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l1',
scaleFactorFiles={
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l1(),
disable=True
)
Weighter_l2 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l2',
scaleFactorFiles={
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l2(),
disable=True
)
if L1L2LeptonType == 'em':
Weighter_l1 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l1',
scaleFactorFiles={
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l1(),
disable=True
)
Weighter_l2 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l2',
scaleFactorFiles={
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'm_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l2(),
disable=True
)
if L1L2LeptonType == 'ee':
Weighter_l1 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l1',
scaleFactorFiles={
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l1(),
disable=True
)
Weighter_l2 = cfg.Analyzer(
LeptonWeighter,
name='LeptonWeighter_l2',
scaleFactorFiles={
'idiso' :('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_id'),
'tracking':('$CMSSW_BASE/src/CMGTools/HNL/data/leptonsf/htt_scalefactors_v17_1.root', 'e_iso'),
},
dataEffFiles={
# 'trigger':('$CMSSW_BASE/src/CMGTools/H2TauTau/data/htt_scalefactors_v16_2.root', 'm_trgIsoMu22orTkIsoMu22_desy'),
},
getter = lambda event : event.the_3lep_cand.l2(),
disable=True
)
# see SM HTT TWiki
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/SMTauTau2016#Jet_Energy_Corrections
jetAna = cfg.Analyzer(
JetAnalyzer,
name = 'JetAnalyzer',
jetCol = 'slimmedJets',
jetPt = 20.,
jetEta = 5.,
relaxJetId = False, # relax = do not apply jet ID
relaxPuJetId = True, # relax = do not apply pileup jet ID
jerCorr = False,
puJetIDDisc = 'pileupJetId:fullDiscriminant',
recalibrateJets = False,
applyL2L3Residual = 'MC',
# RM: FIXME! check the GTs
# mcGT = '94X_mc2017_realistic_v14',
# dataGT = '94X_dataRun2_v6',
#jesCorr = 1., # Shift jet energy scale in terms of uncertainties (1 = +1 sigma)
)
###################################################
### SEQUENCE ###
###################################################
if isData == True:
sequence = cfg.Sequence([
# eventSelector,
jsonAna,
skimAna,
triggerAna,
vertexAna,
pileUpAna,
HNLAnalyzer,
jetAna,
metFilter,
HNLTreeProducer,
])
if isData == False:
if isSignal == True:
sequence = cfg.Sequence([
# eventSelector,
lheWeightAna, # les houches
jsonAna,
skimAna,
triggerAna,
vertexAna,
pileUpAna,
genAna,
HNLGenTreeAnalyzer,
# RecoGenAnalyzer,
HNLAnalyzer,
Weighter_l0,
Weighter_l1,
Weighter_l2,
jetAna,
metFilter,
HNLTreeProducer,
])
if isSignal == False:
sequence = cfg.Sequence([
# eventSelector,
lheWeightAna, # les houches
jsonAna,
skimAna,
triggerAna,
vertexAna,
pileUpAna,
genAna,
HNLGenTreeAnalyzer,
HNLAnalyzer,
Weighter_l0,
Weighter_l1,
Weighter_l2,
jetAna,
metFilter,
HNLTreeProducer,
])
###################################################
### SET BATCH OR LOCAL ###
###################################################
if not production:
# comp = HN3L_M_2p5_V_0p0173205080757_e_onshell
# comp = HN3L_M_2p5_V_0p00707106781187_e_onshell
# comp = all_signals_e[0]
# comp = DYJetsToLL_M50
comp = samples[0]
# comp = samples
# comp = ttbar
# comp = bkg
selectedComponents = [comp]
comp.splitFactor = 1
comp.fineSplitFactor = 1
comp.files = comp.files[:1]
###################################################
### PREPROCESSOR ###
###################################################
preprocessor = None
#temporary copy remote files using xrd
from PhysicsTools.HeppyCore.framework.eventsfwlite import Events
from CMGTools.HNL.utils.EOSEventsWithDownload import EOSEventsWithDownload
event_class = EOSEventsWithDownload if not preprocessor else Events
EOSEventsWithDownload.aggressive = 2 # always fetch if running on Wigner
EOSEventsWithDownload.long_cache = getHeppyOption('long_cache', False)
if preprocessor: preprocessor.prefetch = prefetch
# if extrap_muons_to_L1:
# fname = '$CMSSW_BASE/src/CMGTools/WTau3Mu/prod/muon_extrapolator_cfg.py'
# sequence.append(fileCleaner)
# preprocessor = CmsswPreprocessor(fname, addOrigAsSecondary=False)
# if compute_mvamet:
# fname = '$CMSSW_BASE/src/CMGTools/WTau3Mu/prod/compute_mva_met_data_cfg.py'
# sequence.append(fileCleaner)
# preprocessor = CmsswPreprocessor(fname, addOrigAsSecondary=False)
# the following is declared in case this cfg is used in input to the heppy.py script
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [],
preprocessor = preprocessor,
events_class = event_class
)
printComps(config.components, True)
return config
#selectedComponents = [RSGravToZZToZZinv_narrow_800]
selectedComponents = [DYJetsToLL_M50_Ext]
#selectedComponents = [BulkGravToZZ_narrow_800]
#selectedComponents = [BulkGravToZZToZlepZhad_narrow_800]
for c in selectedComponents:
# c.files = c.files[:5]
c.splitFactor = (len(c.files) / 5 if len(c.files) > 5 else 1)
c.triggers = []
c.vetoTriggers = []
## output histogram
outputService = []
from PhysicsTools.HeppyCore.framework.services.tfile import TFileService
output_service = cfg.Service(TFileService,
'outputfile',
name="outputfile",
fname='vvTreeProducer/tree.root',
option='recreate')
outputService.append(output_service)
from PhysicsTools.HeppyCore.framework.eventsfwlite import Events
from CMGTools.TTHAnalysis.tools.EOSEventsWithDownload import EOSEventsWithDownload
event_class = EOSEventsWithDownload
event_class = Events
if getHeppyOption("nofetch"):
event_class = Events
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=event_class)
import PhysicsTools.HeppyCore.framework.config as cfg
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
from PhysicsTools.HeppyCore.framework.config import printComps
test = getHeppyOption('test', False)
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
ComponentCreator.useLyonAAA = True
################################################################################
# Analyzers
################################################################################
from PhysicsTools.Heppy.analyzers.core.JSONAnalyzer import JSONAnalyzer
from PhysicsTools.Heppy.analyzers.core.SkimAnalyzerCount import SkimAnalyzerCount
from CMGTools.H2TauTau.proto.analyzers.TriggerAnalyzer import TriggerAnalyzer
from PhysicsTools.Heppy.analyzers.objects.VertexAnalyzer import VertexAnalyzer
from CMGTools.H2TauTau.heppy.analyzers.Debugger import Debugger
json = cfg.Analyzer(
JSONAnalyzer,
name='JSONAnalyzer',
)
vertex = cfg.Analyzer(VertexAnalyzer,
name='VertexAnalyzer',
fixedWeight=1,
keepFailingEvents=True,
verbose=False)
################################################################################
# Tau-tau analyzers
from CMGTools.H2TauTau.proto.analyzers.FileCleaner import FileCleaner
from CMGTools.H2TauTau.proto.analyzers.TauTauAnalyzer import TauTauAnalyzer
from CMGTools.H2TauTau.proto.analyzers.H2TauTauTreeProducerTauTau import H2TauTauTreeProducerTauTau
from CMGTools.H2TauTau.proto.analyzers.TauDecayModeWeighter import TauDecayModeWeighter
from CMGTools.H2TauTau.proto.analyzers.LeptonWeighter import LeptonWeighter
from CMGTools.H2TauTau.proto.analyzers.TauP4Scaler import TauP4Scaler
from CMGTools.H2TauTau.proto.analyzers.SVfitProducer import SVfitProducer
# common configuration and sequence
from CMGTools.H2TauTau.htt_ntuple_base_cff import commonSequence, genAna, dyJetsFakeAna, puFileData, puFileMC, eventSelector
# Get all heppy options; set via '-o production' or '-o production=True'
# production = True run on batch, production = False (or unset) run locally
production = getHeppyOption('production')
production = True
# local switches
syncntuple = True
computeSVfit = True
pick_events = False
cmssw = True
dyJetsFakeAna.channel = 'tt'
### Define tau-tau specific modules
tauTauAna = cfg.Analyzer(
class_object=TauTauAnalyzer,
name='TauTauAnalyzer',
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
kreator = ComponentCreator()
def byCompName(components, regexps):
return [c for c in components if any(re.match(r, c.name) for r in regexps)]
#get datasets
from CMGTools.RootTools.samples.samples_13TeV_BParkingData_NanoAOD import samples as allData
#get triggers
from CMGTools.RootTools.samples.triggers_13TeV_BParking import all_triggers as triggers
test = getHeppyOption("test", None)
#create components
selectedComponents = []
if not test:
for comp in allData:
#comp.triggers = trigs[:]
# jobs per dataset
comp.splitFactor = 10
selectedComponents.append(comp)
if test:
for comp in allData:
if comp.name != test:
continue
comp.splitFactor = 5
import logging
logging.shutdown()
#reload(logging)
logging.basicConfig(level=logging.WARNING)
############################################################################
# Options
############################################################################
# Get all heppy options; set via "-o production" or "-o production=True"
# production = True run on batch, production = False run locally
test = getHeppyOption('test', False)
syncntuple = getHeppyOption('syncntuple', True)
data = getHeppyOption('data', True)
tes_string = getHeppyOption('tes_string', '') # '_tesup' '_tesdown'
reapplyJEC = getHeppyOption('reapplyJEC', True)
############################################################################
# Components
############################################################################
from CMGTools.cpTop.proto.samples.fall17.ttbar2017 import mc_singletop
from CMGTools.cpTop.proto.samples.fall17.ttbar2017 import mc_total
from CMGTools.cpTop.proto.samples.fall17.ttbar2017 import reversed_muon
from CMGTools.cpTop.proto.samples.fall17.trigger import data_triggers
from CMGTools.cpTop.proto.samples.fall17.trigger import mc_triggers
##########################################################
## CONFIGURATION FOR TTH MULTILEPTON TREES ##
##########################################################
import PhysicsTools.HeppyCore.framework.config as cfg
import re
#-------- LOAD ALL ANALYZERS -----------
from CMGTools.TTHAnalysis.analyzers.susyCore_modules_cff import *
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
#-------- SET OPTIONS AND REDEFINE CONFIGURATIONS -----------
runData = getHeppyOption("runData", False)
runDataQCD = getHeppyOption("runDataQCD", False)
runQCDBM = getHeppyOption("runQCDBM", False)
runFRMC = getHeppyOption("runFRMC", False)
scaleProdToLumi = float(
getHeppyOption("scaleProdToLumi",
-1)) # produce rough equivalent of X /pb for MC datasets
removeJetReCalibration = getHeppyOption("removeJetReCalibration", False)
removeJecUncertainty = getHeppyOption("removeJecUncertainty", False)
doMETpreprocessor = getHeppyOption("doMETpreprocessor", False)
skipT1METCorr = getHeppyOption("skipT1METCorr", False)
forcedSplitFactor = getHeppyOption("splitFactor", -1)
forcedFineSplitFactor = getHeppyOption("fineSplitFactor", -1)
isTest = getHeppyOption("test", None) != None and not re.match(
"^\d+$", getHeppyOption("test"))
selectedEvents = getHeppyOption("selectEvents", "")
sample = "main"
# General
import os
import pickle
# Load all analyzers
from CMGTools.TTHAnalysis.analyzers.susyCore_modules_cff import *
print "Year: 2016"
# general flags & settings
minLeptons = 1
storePackedCandidates = False
doElectronScaleCorrections = False
doPhotonScaleCorrections = False
keepLHEWeights = getHeppyOption("keepLHEweights",True)
jsonAna.useLumiBlocks = True
genAna.allGenTaus = True
# Lepton settings
lepAna.packedCandidates = 'packedPFCandidates'
lepAna.rhoMuon = 'fixedGridRhoFastjetAll'
lepAna.rhoElectron = 'fixedGridRhoFastjetAll'
# Electrons
lepAna.loose_electron_pt = 5
lepAna.doMiniIsolation = True
lepAna.loose_electron_id = ""
lepAna.loose_electron_lostHits = 999. # no cut
lepAna.loose_electron_dxy = 999.
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
# Tau-tau analyzers
from CMGTools.H2TauTau.proto.analyzers.TauTauAnalyzer import TauTauAnalyzer
from CMGTools.H2TauTau.proto.analyzers.H2TauTauTreeProducerTauTau import H2TauTauTreeProducerTauTau
from CMGTools.H2TauTau.proto.analyzers.TauDecayModeWeighter import TauDecayModeWeighter
from CMGTools.H2TauTau.proto.analyzers.LeptonWeighter import LeptonWeighter
from CMGTools.H2TauTau.proto.analyzers.SVfitProducer import SVfitProducer
# common configuration and sequence
from CMGTools.H2TauTau.htt_ntuple_base_cff import commonSequence, genAna, dyJetsFakeAna, puFileData, puFileMC, eventSelector
# Get all heppy options; set via '-o production' or '-o production=True'
# production = True run on batch, production = False (or unset) run locally
production = getHeppyOption('production')
# local switches
syncntuple = True
computeSVfit = False
pick_events = False
dyJetsFakeAna.channel = 'tt'
### Define tau-tau specific modules
tauTauAna = cfg.Analyzer(
class_object = TauTauAnalyzer ,
name = 'TauTauAnalyzer' ,
pt1 = 45 ,
eta1 = 2.1 ,
from CMGTools.WTau3Mu.analyzers.GenMatcherAnalyzer import GenMatcherAnalyzer
from CMGTools.WTau3Mu.analyzers.L1TriggerAnalyzer import L1TriggerAnalyzer
from CMGTools.WTau3Mu.analyzers.BDTAnalyzer import BDTAnalyzer
# import samples
from CMGTools.WTau3Mu.samples.data_2016 import datasamplesDoubleMuLowMass as samples
puFileMC = '$CMSSW_BASE/src/CMGTools/H2TauTau/data/MC_Moriond17_PU25ns_V1.root'
puFileData = '/afs/cern.ch/user/a/anehrkor/public/Data_Pileup_2016_271036-284044_80bins.root'
###################################################
### OPTIONS ###
###################################################
# Get all heppy options; set via "-o production" or "-o production=True"
# production = True run on batch, production = False (or unset) run locally
production = getHeppyOption('production' , False)
pick_events = getHeppyOption('pick_events' , True )
kin_vtx_fitter = getHeppyOption('kin_vtx_fitter', True )
###################################################
### HANDLE SAMPLES ###
###################################################
for sample in samples:
sample.triggers = ['HLT_DoubleMu3_Trk_Tau3mu_v%d' %i for i in range(1, 5)]
# specify which muon should match to which filter.
# FIXME! cannot pickle properly...
# sample.trigger_filters = [
# (lambda triplet : triplet.mu1(), ['hltTau3muTkVertexFilter']),
# (lambda triplet : triplet.mu2(), ['hltTau3muTkVertexFilter']),
# (lambda triplet : triplet.mu3(), ['hltTau3muTkVertexFilter']),
# ]
# sequence.insert(sequence.index(MT2Ana),
# MT2AnaNoHF)
###---- to switch off the compression
# treeProducer.isCompressed = 0
from PhysicsTools.HeppyCore.framework.heppy_loop import getHeppyOption
# -------- HOW TO RUN
# choose 0 for quick validations tests. It doesn't require to load the sample files
# choose 2 for full mc production
# choose 3 for data production
# choose 4 for signal production
test = int(getHeppyOption("test", 1))
isData = False # will be changed accordingly if chosen to run on data
doSpecialSettingsForMECCA = 1 # set to 1 for comparisons with americans
runPreprocessor = False
if test == 0:
# ------------------------------------------------------------------------------------------- #
# --- all this lines taken from CMGTools.RootTools.samples.samples_13TeV_PHYS14
# --- They may not be in synch anymore
from CMGTools.RootTools.samples.ComponentCreator import ComponentCreator
kreator = ComponentCreator()
testComponent = kreator.makeMCComponent(
"testComponent",
"/GJets_HT-200to400_Tune4C_13TeV-madgraph-tauola/Phys14DR-PU20bx25_PHYS14_25_V1-v1/MINIAODSIM",
"CMS",
