def test_jet_correction_uncertainty_sources():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
junc_names = []
levels = []
for name in dir(evaluator):
if 'Summer16_23Sep2016V3_MC_UncertaintySources_AK4PFPuppi' in name:
junc_names.append(name)
levels.append(name.split('_')[-1])
#test for underscore in dataera
if 'Fall17_17Nov2017_V6_MC_UncertaintySources_AK4PFchs_AbsoluteFlavMap' in name:
junc_names.append(name)
levels.append(name.split('_')[-1])
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
print(junc)
juncs = junc.getUncertainty(JetEta=test_eta, JetPt=test_pt)
for level, corrs in juncs:
assert (level in levels)
assert (corrs.shape[0] == test_eta.shape[0])
def test_jet_correction_uncertainty_sources():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_pt_jag = ak.unflatten(test_pt, counts)
test_eta_jag = ak.unflatten(test_eta, counts)
junc_names = []
levels = []
for name in dir(evaluator):
if 'Summer16_23Sep2016V3_MC_UncertaintySources_AK4PFPuppi' in name:
junc_names.append(name)
levels.append(name.split('_')[-1])
#test for underscore in dataera
if 'Fall17_17Nov2017_V6_MC_UncertaintySources_AK4PFchs_AbsoluteFlavMap' in name:
junc_names.append(name)
levels.append(name.split('_')[-1])
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
print(junc)
juncs = junc.getUncertainty(JetEta=test_eta, JetPt=test_pt)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, (level, corrs) in enumerate(juncs):
assert (level in levels)
assert (corrs.shape[0] == test_eta.shape[0])
tic = time.time()
assert (ak.all(corrs == ak.flatten(juncs_jag[i][1])))
toc = time.time()
def test_jet_correction_regrouped_uncertainty_sources():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_pt_jag = ak.unflatten(test_pt, counts)
test_eta_jag = ak.unflatten(test_eta, counts)
junc_names = []
levels = []
for name in dir(evaluator):
if 'Regrouped_Fall17_17Nov2017_V32_MC_UncertaintySources_AK4PFchs' in name:
junc_names.append(name)
if len(name.split('_')) == 9:
levels.append("_".join(name.split('_')[-2:]))
else:
levels.append(name.split('_')[-1])
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
print(junc)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, tpl in enumerate(
list(junc.getUncertainty(JetEta=test_eta, JetPt=test_pt))):
assert (tpl[0] in levels)
assert (tpl[1].shape[0] == test_eta.shape[0])
assert (ak.all(tpl[1] == ak.flatten(juncs_jag[i][1])))
def test_jet_correction_uncertainty():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_pt_jag = ak.unflatten(test_pt, counts)
test_eta_jag = ak.unflatten(test_eta, counts)
junc_names = ["Summer16_23Sep2016V3_MC_Uncertainty_AK4PFPuppi"]
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
print(junc)
juncs = junc.getUncertainty(JetEta=test_eta, JetPt=test_pt)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, (level, corrs) in enumerate(juncs):
assert corrs.shape[0] == test_eta.shape[0]
assert ak.all(corrs == ak.flatten(juncs_jag[i][1]))
test_pt_jag = test_pt_jag[0:3]
test_eta_jag = test_eta_jag[0:3]
counts = counts[0:3]
print("Raw jet values:")
print("pT:", test_pt_jag.tolist())
print("eta:", test_eta_jag.tolist(), "\n")
juncs_jag_ref = ak.unflatten(
np.array([
[1.053504214, 0.946495786],
[1.033343349, 0.966656651],
[1.065159157, 0.934840843],
[1.033140127, 0.966859873],
[1.016858652, 0.983141348],
[1.130199999, 0.869800001],
[1.039968468, 0.960031532],
[1.033100002, 0.966899998],
]),
counts,
)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, (level, corrs) in enumerate(juncs_jag):
print("Index:", i)
print("Correction level:", level)
print("Reference Uncertainties (jagged):", juncs_jag_ref)
print("Uncertainties (jagged):", corrs)
assert ak.all(
np.abs(ak.flatten(juncs_jag_ref) - ak.flatten(corrs)) < 1e-6)
def test_jet_correction_uncertainty():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
junc_names = ['Summer16_23Sep2016V3_MC_Uncertainty_AK4PFPuppi']
junc = JetCorrectionUncertainty(**{name: evaluator[name] for name in junc_names})
print(junc)
juncs = junc.getUncertainty(JetEta=test_eta, JetPt=test_pt)
for level, corrs in juncs:
assert(corrs.shape[0] == test_eta.shape[0])
def test_jet_transformer():
from coffea.analysis_objects import JaggedCandidateArray as CandArray
from coffea.jetmet_tools import (FactorizedJetCorrector,
JetResolution,
JetResolutionScaleFactor,
JetCorrectionUncertainty,
JetTransformer)
counts, test_px, test_py, test_pz, test_e = dummy_four_momenta()
test_Rho = np.full(shape=(np.sum(counts),), fill_value=100.)
test_A = np.full(shape=(np.sum(counts),), fill_value=5.)
jets = CandArray.candidatesfromcounts(counts, px=test_px, py=test_py, pz=test_pz, energy=test_e)
jets.add_attributes(ptRaw=jets.pt,
massRaw=jets.mass,
rho=test_Rho,
area=test_A)
jec_names = ['Summer16_23Sep2016V3_MC_L1FastJet_AK4PFPuppi',
'Summer16_23Sep2016V3_MC_L2Relative_AK4PFPuppi',
'Summer16_23Sep2016V3_MC_L2L3Residual_AK4PFPuppi',
'Summer16_23Sep2016V3_MC_L3Absolute_AK4PFPuppi']
corrector = FactorizedJetCorrector(**{name: evaluator[name] for name in jec_names})
junc_names = []
for name in dir(evaluator):
if 'Summer16_23Sep2016V3_MC_UncertaintySources_AK4PFPuppi' in name:
junc_names.append(name)
junc = JetCorrectionUncertainty(**{name: evaluator[name] for name in junc_names})
jer_names = ['Spring16_25nsV10_MC_PtResolution_AK4PFPuppi']
reso = JetResolution(**{name: evaluator[name] for name in jer_names})
jersf_names = ['Spring16_25nsV10_MC_SF_AK4PFPuppi']
resosf = JetResolutionScaleFactor(**{name: evaluator[name] for name in jersf_names})
xform = JetTransformer(jec=corrector, junc=junc, jer=reso, jersf=resosf)
print(xform.uncertainties)
xform.transform(jets)
print(jets.columns)
assert('pt_jer_up' in jets.columns)
assert('pt_jer_down' in jets.columns)
assert('mass_jer_up' in jets.columns)
assert('mass_jer_down' in jets.columns)
for unc in xform.uncertainties:
assert('pt_'+unc+'_up' in jets.columns)
assert('pt_'+unc+'_down' in jets.columns)
assert('mass_'+unc+'_up' in jets.columns)
assert('mass_'+unc+'_down' in jets.columns)
def test_jet_correction_uncertainty():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_pt_jag = ak.unflatten(test_pt, counts)
test_eta_jag = ak.unflatten(test_eta, counts)
junc_names = ['Summer16_23Sep2016V3_MC_Uncertainty_AK4PFPuppi']
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
print(junc)
juncs = junc.getUncertainty(JetEta=test_eta, JetPt=test_pt)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, (level, corrs) in enumerate(juncs):
assert (corrs.shape[0] == test_eta.shape[0])
assert (ak.all(corrs == ak.flatten(juncs_jag[i][1])))
Jetevaluator = Jetext.make_evaluator()
jet_corrections = {year:{'MC' : {}, 'DATA' : {}} for year in years_to_run}
for year in years_to_run:
jec_mc_tag = '_'.join([jecfiles[year]['tag'], jecfiles[year]['v'], 'MC'])
jer_tag = jerfiles[year]['tag']
# DATA
data_JER = JetResolution(**{name:Jetevaluator[name] for name in ['%s_DATA_%s_%s' % (jer_tag, jerfiles[year]['JER'], jet_type)]})
data_JERsf = JetResolutionScaleFactor(**{name:Jetevaluator[name] for name in ['%s_DATA_%s_%s' % (jer_tag, jerfiles[year]['JERSF'], jet_type)]})
for idx, era in enumerate(jecfiles[year]['eras']):
jec_data_tag = '_'.join([jecfiles[year]['tag']+jecfiles[year]['DATA'][idx], jecfiles[year]['v'], 'DATA']) if '_' in jecfiles[year]['tag'] else '_'.join([jecfiles[year]['tag'], jecfiles[year]['DATA'][idx], jecfiles[year]['v'], 'DATA'])
# get jec, junc, jr, jersf
data_JECcorrector = FactorizedJetCorrector(**{name: Jetevaluator[name] for name in ['%s_%s_%s' % (jec_data_tag, level, jet_type) for level in jec_levels_Data]})
data_JECuncertainties = JetCorrectionUncertainty(**{name:Jetevaluator[name] for name in Jetevaluator.keys() if name.startswith('%s_%s_%s' % (jec_data_tag, jecfiles['Unc'], jet_type))})
# make JEC stack of all corrections
data_JECStack = JECStack({}, jec=data_JECcorrector, junc=data_JECuncertainties)
# make jet and met factory
data_name_map = make_name_map(data_JECStack, isMC=False)
data_jet_factory = CorrectedJetsFactory(data_name_map, data_JECStack)
data_met_factory = CorrectedMETFactory(data_name_map)
jet_corrections[year]['DATA'][era] = {
'JetsFactory' : data_jet_factory,
'METFactory' : data_met_factory,
}
# MC
# get jec, junc, jr, jersf
MC_JECcorrector = FactorizedJetCorrector(**{name: Jetevaluator[name] for name in ['%s_%s_%s' % (jec_mc_tag, level, jet_type) for level in jec_levels_MC]})
MC_JECuncertainties = JetCorrectionUncertainty(**{name:Jetevaluator[name] for name in Jetevaluator.keys() if name.startswith('%s_%s_%s' % (jec_mc_tag, jecfiles['Unc'], jet_type))})
def test_jet_transformer():
import numpy as np
import awkward as ak
import math
from coffea.analysis_objects import JaggedCandidateArray as CandArray
from coffea.jetmet_tools import (FactorizedJetCorrector, JetResolution,
JetResolutionScaleFactor,
JetCorrectionUncertainty, JetTransformer)
counts, test_px, test_py, test_pz, test_e = dummy_four_momenta()
test_Rho = np.full(shape=(np.sum(counts), ), fill_value=100.)
test_A = np.full(shape=(np.sum(counts), ), fill_value=5.)
jets = CandArray.candidatesfromcounts(counts,
px=test_px,
py=test_py,
pz=test_pz,
energy=test_e)
jets.add_attributes(ptRaw=jets.pt,
massRaw=jets.mass,
rho=test_Rho,
area=test_A)
fakemet = np.random.exponential(scale=1.0, size=counts.size)
metphi = np.random.uniform(low=-math.pi, high=math.pi, size=counts.size)
syst_up = 0.001 * fakemet
syst_down = -0.001 * fakemet
met = CandArray.candidatesfromcounts(
np.ones_like(counts),
pt=fakemet,
eta=np.zeros_like(counts),
phi=metphi,
mass=np.zeros_like(counts),
MetUnclustEnUpDeltaX=syst_up * np.cos(metphi),
MetUnclustEnUpDeltaY=syst_down * np.sin(metphi))
jec_names = [
'Summer16_23Sep2016V3_MC_L1FastJet_AK4PFPuppi',
'Summer16_23Sep2016V3_MC_L2Relative_AK4PFPuppi',
'Summer16_23Sep2016V3_MC_L2L3Residual_AK4PFPuppi',
'Summer16_23Sep2016V3_MC_L3Absolute_AK4PFPuppi'
]
corrector = FactorizedJetCorrector(
**{name: evaluator[name]
for name in jec_names})
junc_names = []
for name in dir(evaluator):
if 'Summer16_23Sep2016V3_MC_UncertaintySources_AK4PFPuppi' in name:
junc_names.append(name)
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
jer_names = ['Spring16_25nsV10_MC_PtResolution_AK4PFPuppi']
reso = JetResolution(**{name: evaluator[name] for name in jer_names})
jersf_names = ['Spring16_25nsV10_MC_SF_AK4PFPuppi']
resosf = JetResolutionScaleFactor(
**{name: evaluator[name]
for name in jersf_names})
xform = JetTransformer(jec=corrector, junc=junc, jer=reso, jersf=resosf)
print(xform.uncertainties)
xform.transform(jets, met=met)
print('jets', jets.columns)
print('met', met.columns)
assert ('pt_jer_up' in jets.columns)
assert ('pt_jer_down' in jets.columns)
assert ('mass_jer_up' in jets.columns)
assert ('mass_jer_down' in jets.columns)
assert ('pt_UnclustEn_up' in met.columns)
assert ('pt_UnclustEn_down' in met.columns)
assert ('phi_UnclustEn_up' in met.columns)
assert ('phi_UnclustEn_down' in met.columns)
for unc in xform.uncertainties:
assert ('pt_' + unc + '_up' in jets.columns)
assert ('pt_' + unc + '_down' in jets.columns)
assert ('mass_' + unc + '_up' in jets.columns)
assert ('mass_' + unc + '_down' in jets.columns)
assert ('pt_' + unc + '_up' in met.columns)
assert ('phi_' + unc + '_up' in met.columns)
#list of JEC and JER correction names
jec_names = [
'Summer16_07Aug2017_V11_MC_L1FastJet_AK4PFchs',
'Summer16_07Aug2017_V11_MC_L2Relative_AK4PFchs'
]
junc_names = ['Summer16_07Aug2017_V11_MC_Uncertainty_AK4PFchs']
jer_names = ['Summer16_25nsV1_MC_PtResolution_AK4PFchs']
jersf_names = ['Summer16_25nsV1_MC_SF_AK4PFchs']
#create JEC and JER correctors
JECcorrector = FactorizedJetCorrector(
**{name: Jetevaluator[name]
for name in jec_names})
JECuncertainties = JetCorrectionUncertainty(
**{name: Jetevaluator[name]
for name in junc_names})
JER = JetResolution(**{name: Jetevaluator[name] for name in jer_names})
JERsf = JetResolutionScaleFactor(
**{name: Jetevaluator[name]
for name in jersf_names})
Jet_transformer = JetTransformer(jec=JECcorrector,
junc=JECuncertainties,
jer=JER,
jersf=JERsf)
# Look at ProcessorABC to see the expected methods and what they are supposed to do
class TTGammaProcessor(processor.ProcessorABC):
def test_jet_correction_regrouped_uncertainty_sources():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_pt_jag = ak.unflatten(test_pt, counts)
test_eta_jag = ak.unflatten(test_eta, counts)
junc_names = []
levels = []
for name in dir(evaluator):
if "Regrouped_Fall17_17Nov2017_V32_MC_UncertaintySources_AK4PFchs" in name:
junc_names.append(name)
if len(name.split("_")) == 9:
levels.append("_".join(name.split("_")[-2:]))
else:
levels.append(name.split("_")[-1])
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
print(junc)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, tpl in enumerate(
list(junc.getUncertainty(JetEta=test_eta, JetPt=test_pt))):
assert tpl[0] in levels
assert tpl[1].shape[0] == test_eta.shape[0]
assert ak.all(tpl[1] == ak.flatten(juncs_jag[i][1]))
test_pt_jag = test_pt_jag[0:3]
test_eta_jag = test_eta_jag[0:3]
counts = counts[0:3]
print("Raw jet values:")
print("pT:", test_pt_jag.tolist())
print("eta:", test_eta_jag.tolist(), "\n")
juncs_jag_ref = ak.unflatten(
np.array([
[1.119159088, 0.880840912],
[1.027003404, 0.972996596],
[1.135201275, 0.864798725],
[1.039665259, 0.960334741],
[1.015064503, 0.984935497],
[1.149900004, 0.850099996],
[1.079960600, 0.920039400],
[1.041200001, 0.958799999],
]),
counts,
)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, (level, corrs) in enumerate(juncs_jag):
if level != "Total":
continue
print("Index:", i)
print("Correction level:", level)
print("Reference Uncertainties (jagged):", juncs_jag_ref)
print("Uncertainties (jagged):", corrs, "\n")
assert ak.all(
np.abs(ak.flatten(juncs_jag_ref) - ak.flatten(corrs)) < 1e-6)
def test_jet_correction_uncertainty_sources():
from coffea.jetmet_tools import JetCorrectionUncertainty
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_pt_jag = ak.unflatten(test_pt, counts)
test_eta_jag = ak.unflatten(test_eta, counts)
junc_names = []
levels = []
for name in dir(evaluator):
if "Summer16_23Sep2016V3_MC_UncertaintySources_AK4PFPuppi" in name:
junc_names.append(name)
levels.append(name.split("_")[-1])
# test for underscore in dataera
if "Fall17_17Nov2017_V6_MC_UncertaintySources_AK4PFchs_AbsoluteFlavMap" in name:
junc_names.append(name)
levels.append(name.split("_")[-1])
junc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
print(junc)
juncs = junc.getUncertainty(JetEta=test_eta, JetPt=test_pt)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, (level, corrs) in enumerate(juncs):
assert level in levels
assert corrs.shape[0] == test_eta.shape[0]
assert ak.all(corrs == ak.flatten(juncs_jag[i][1]))
test_pt_jag = test_pt_jag[0:3]
test_eta_jag = test_eta_jag[0:3]
counts = counts[0:3]
print("Raw jet values:")
print("pT:", test_pt_jag.tolist())
print("eta:", test_eta_jag.tolist(), "\n")
juncs_jag_ref = ak.unflatten(
np.array([
[1.053504214, 0.946495786],
[1.033343349, 0.966656651],
[1.065159157, 0.934840843],
[1.033140127, 0.966859873],
[1.016858652, 0.983141348],
[1.130199999, 0.869800001],
[1.039968468, 0.960031532],
[1.033100002, 0.966899998],
]),
counts,
)
juncs_jag = list(
junc.getUncertainty(JetEta=test_eta_jag, JetPt=test_pt_jag))
for i, (level, corrs) in enumerate(juncs_jag):
if level != "Total":
continue
print("Index:", i)
print("Correction level:", level)
print("Reference Uncertainties (jagged):", juncs_jag_ref)
print("Uncertainties (jagged):", corrs, "\n")
assert ak.all(
np.abs(ak.flatten(juncs_jag_ref) - ak.flatten(corrs)) < 1e-6)
def __init__(self,
jec_tag: str,
jec_tag_data: dict,
jer_tag: str,
do_factorized_jec=True):
"""Loads the JEC and JER corrections corresponding to the given tags from txt files.
Args:
jec_tag (str): Tag for the jet energy corrections for MC simulation
jec_tag_data (dict): per-run JEC tags for real data
jer_tag (str): tag for the jet energy resolution
do_factorized_jec (bool, optional): If True, loads and enables the factorized jet
energy corrections instead of the total
"""
extract = extractor()
#For MC
extract.add_weight_sets([
'* * data/jme/{0}_L1FastJet_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_L2L3Residual_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_L2Relative_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_L3Absolute_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_UncertaintySources_AK4PFchs.junc.txt'.format(
jec_tag),
'* * data/jme/{0}_Uncertainty_AK4PFchs.junc.txt'.format(jec_tag),
])
extract.add_weight_sets([
'* * data/jme/{0}_PtResolution_AK4PFchs.jr.txt'.format(jer_tag),
'* * data/jme/{0}_SF_AK4PFchs.jersf.txt'.format(jer_tag)
])
#For data, make sure we don't duplicate
tags_done = []
for run, tag in jec_tag_data.items():
if not (tag in tags_done):
extract.add_weight_sets([
'* * data/jme/{0}_L1FastJet_AK4PFchs.txt'.format(tag),
'* * data/jme/{0}_L2L3Residual_AK4PFchs.txt'.format(tag),
'* * data/jme/{0}_L2Relative_AK4PFchs.txt'.format(tag),
'* * data/jme/{0}_L3Absolute_AK4PFchs.txt'.format(tag)
])
tags_done += [tag]
extract.finalize()
evaluator = extract.make_evaluator()
jec_names_mc = [
'{0}_L1FastJet_AK4PFchs'.format(jec_tag),
'{0}_L2Relative_AK4PFchs'.format(jec_tag),
'{0}_L2L3Residual_AK4PFchs'.format(jec_tag),
'{0}_L3Absolute_AK4PFchs'.format(jec_tag)
]
self.jec_mc = FactorizedJetCorrector(
**{name: evaluator[name]
for name in jec_names_mc})
self.jec_data = {}
for run, tag in jec_tag_data.items():
jec_names_data = [
'{0}_L1FastJet_AK4PFchs'.format(tag),
'{0}_L2Relative_AK4PFchs'.format(tag),
'{0}_L2L3Residual_AK4PFchs'.format(tag),
'{0}_L3Absolute_AK4PFchs'.format(tag)
]
self.jec_data[run] = FactorizedJetCorrector(
**{name: evaluator[name]
for name in jec_names_data})
self.jer = None
self.jersf = None
if jer_tag:
jer_names = ['{0}_PtResolution_AK4PFchs'.format(jer_tag)]
self.jer = JetResolution(
**{name: evaluator[name]
for name in jer_names})
jersf_names = ['{0}_SF_AK4PFchs'.format(jer_tag)]
self.jersf = JetResolutionScaleFactor(
**{name: evaluator[name]
for name in jersf_names})
junc_names = ['{0}_Uncertainty_AK4PFchs'.format(jec_tag)]
#levels = []
if do_factorized_jec:
for name in dir(evaluator):
#factorized sources
if '{0}_UncertaintySources_AK4PFchs'.format(jec_tag) in name:
junc_names.append(name)
self.jesunc = JetCorrectionUncertainty(
**{name: evaluator[name]
for name in junc_names})
def __init__(self,
jec_tag,
jec_tag_data,
jer_tag,
jmr_vals,
do_factorized_jec=True):
extract = extractor()
#For MC
extract.add_weight_sets([
'* * data/jme/{0}_L1FastJet_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_L2L3Residual_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_L2Relative_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_L3Absolute_AK4PFchs.txt'.format(jec_tag),
'* * data/jme/{0}_UncertaintySources_AK4PFchs.junc.txt'.format(jec_tag),
'* * data/jme/{0}_Uncertainty_AK4PFchs.junc.txt'.format(jec_tag),
])
if jer_tag:
extract.add_weight_sets([
'* * data/jme/{0}_PtResolution_AK4PFchs.jr.txt'.format(jer_tag),
'* * data/jme/{0}_SF_AK4PFchs.jersf.txt'.format(jer_tag)])
#For data, make sure we don't duplicate
tags_done = []
for run, tag in jec_tag_data.items():
if not (tag in tags_done):
extract.add_weight_sets([
'* * data/jme/{0}_L1FastJet_AK4PFchs.txt'.format(tag),
'* * data/jme/{0}_L2L3Residual_AK4PFchs.txt'.format(tag),
'* * data/jme/{0}_L2Relative_AK4PFchs.txt'.format(tag),
'* * data/jme/{0}_L3Absolute_AK4PFchs.txt'.format(tag)
])
tags_done += [tag]
extract.finalize()
evaluator = extract.make_evaluator()
jec_names_mc = [
'{0}_L1FastJet_AK4PFchs'.format(jec_tag),
'{0}_L2Relative_AK4PFchs'.format(jec_tag),
'{0}_L2L3Residual_AK4PFchs'.format(jec_tag),
'{0}_L3Absolute_AK4PFchs'.format(jec_tag)]
self.jec_mc = FactorizedJetCorrector(**{name: evaluator[name] for name in jec_names_mc})
self.jec_data = {}
for run, tag in jec_tag_data.items():
jec_names_data = [
'{0}_L1FastJet_AK4PFchs'.format(tag),
'{0}_L2Relative_AK4PFchs'.format(tag),
'{0}_L2L3Residual_AK4PFchs'.format(tag),
'{0}_L3Absolute_AK4PFchs'.format(tag)]
self.jec_data[run] = FactorizedJetCorrector(**{name: evaluator[name] for name in jec_names_data})
self.jer = None
self.jersf = None
if jer_tag:
jer_names = ['{0}_PtResolution_AK4PFchs'.format(jer_tag)]
self.jer = JetResolution(**{name: evaluator[name] for name in jer_names})
jersf_names = ['{0}_SF_AK4PFchs'.format(jer_tag)]
self.jersf = JetResolutionScaleFactor(**{name: evaluator[name] for name in jersf_names})
junc_names = ['{0}_Uncertainty_AK4PFchs'.format(jec_tag)]
#levels = []
if do_factorized_jec:
for name in dir(evaluator):
#factorized sources
if '{0}_UncertaintySources_AK4PFchs'.format(jec_tag) in name:
junc_names.append(name)
self.jesunc = JetCorrectionUncertainty(**{name: evaluator[name] for name in junc_names})
def process(self, events):
dataset = events.metadata['dataset']
selected_regions = []
for region, samples in self._samples.items():
for sample in samples:
if sample not in dataset: continue
selected_regions.append(region)
isData = 'genWeight' not in events.columns
selection = processor.PackedSelection()
weights = {}
hout = self.accumulator.identity()
###
#Getting corrections, ids from .coffea files
### Sunil Need to check why we need corrections
#get_msd_weight = self._corrections['get_msd_weight']
get_ttbar_weight = self._corrections['get_ttbar_weight']
get_nlo_weight = self._corrections['get_nlo_weight'][self._year]
get_nnlo_weight = self._corrections['get_nnlo_weight']
get_nnlo_nlo_weight = self._corrections['get_nnlo_nlo_weight']
get_adhoc_weight = self._corrections['get_adhoc_weight']
get_pu_weight = self._corrections['get_pu_weight'][self._year]
get_met_trig_weight = self._corrections['get_met_trig_weight'][self._year]
get_met_zmm_trig_weight = self._corrections['get_met_zmm_trig_weight'][self._year]
get_ele_trig_weight = self._corrections['get_ele_trig_weight'][self._year]
get_pho_trig_weight = self._corrections['get_pho_trig_weight'][self._year]
get_ele_loose_id_sf = self._corrections['get_ele_loose_id_sf'][self._year]
get_ele_tight_id_sf = self._corrections['get_ele_tight_id_sf'][self._year]
get_ele_loose_id_eff = self._corrections['get_ele_loose_id_eff'][self._year]
get_ele_tight_id_eff = self._corrections['get_ele_tight_id_eff'][self._year]
get_pho_tight_id_sf = self._corrections['get_pho_tight_id_sf'][self._year]
get_mu_tight_id_sf = self._corrections['get_mu_tight_id_sf'][self._year]
get_mu_loose_id_sf = self._corrections['get_mu_loose_id_sf'][self._year]
get_ele_reco_sf = self._corrections['get_ele_reco_sf'][self._year]
get_mu_tight_iso_sf = self._corrections['get_mu_tight_iso_sf'][self._year]
get_mu_loose_iso_sf = self._corrections['get_mu_loose_iso_sf'][self._year]
get_ecal_bad_calib = self._corrections['get_ecal_bad_calib']
get_deepflav_weight = self._corrections['get_btag_weight']['deepflav'][self._year]
Jetevaluator = self._corrections['Jetevaluator']
isLooseElectron = self._ids['isLooseElectron']
isTightElectron = self._ids['isTightElectron']
isLooseMuon = self._ids['isLooseMuon']
isTightMuon = self._ids['isTightMuon']
isLooseTau = self._ids['isLooseTau']
isLoosePhoton = self._ids['isLoosePhoton']
isTightPhoton = self._ids['isTightPhoton']
isGoodJet = self._ids['isGoodJet']
#isGoodFatJet = self._ids['isGoodFatJet']
isHEMJet = self._ids['isHEMJet']
match = self._common['match']
deepflavWPs = self._common['btagWPs']['deepflav'][self._year]
deepcsvWPs = self._common['btagWPs']['deepcsv'][self._year]
###
# Derive jet corrector for JEC/JER
###
JECcorrector = FactorizedJetCorrector(**{name: Jetevaluator[name] for name in self._jec[self._year]})
JECuncertainties = JetCorrectionUncertainty(**{name:Jetevaluator[name] for name in self._junc[self._year]})
JER = JetResolution(**{name:Jetevaluator[name] for name in self._jr[self._year]})
JERsf = JetResolutionScaleFactor(**{name:Jetevaluator[name] for name in self._jersf[self._year]})
Jet_transformer = JetTransformer(jec=JECcorrector,junc=JECuncertainties, jer = JER, jersf = JERsf)
###
#Initialize global quantities (MET ecc.)
###
met = events.MET
met['T'] = TVector2Array.from_polar(met.pt, met.phi)
met['p4'] = TLorentzVectorArray.from_ptetaphim(met.pt, 0., met.phi, 0.)
calomet = events.CaloMET
###
#Initialize physics objects
###
e = events.Electron
e['isloose'] = isLooseElectron(e.pt,e.eta,e.dxy,e.dz,e.cutBased,self._year)
e['istight'] = isTightElectron(e.pt,e.eta,e.dxy,e.dz,e.cutBased,self._year)
e['T'] = TVector2Array.from_polar(e.pt, e.phi)
#e['p4'] = TLorentzVectorArray.from_ptetaphim(e.pt, e.eta, e.phi, e.mass)
e_loose = e[e.isloose.astype(np.bool)]
e_tight = e[e.istight.astype(np.bool)]
e_ntot = e.counts
e_nloose = e_loose.counts
e_ntight = e_tight.counts
leading_e = e[e.pt.argmax()]
leading_e = leading_e[leading_e.istight.astype(np.bool)]
mu = events.Muon
mu['isloose'] = isLooseMuon(mu.pt,mu.eta,mu.pfRelIso04_all,mu.looseId,self._year)
mu['istight'] = isTightMuon(mu.pt,mu.eta,mu.pfRelIso04_all,mu.tightId,self._year)
mu['T'] = TVector2Array.from_polar(mu.pt, mu.phi)
#mu['p4'] = TLorentzVectorArray.from_ptetaphim(mu.pt, mu.eta, mu.phi, mu.mass)
mu_loose=mu[mu.isloose.astype(np.bool)]
mu_tight=mu[mu.istight.astype(np.bool)]
mu_ntot = mu.counts
mu_nloose = mu_loose.counts
mu_ntight = mu_tight.counts
leading_mu = mu[mu.pt.argmax()]
leading_mu = leading_mu[leading_mu.istight.astype(np.bool)]
tau = events.Tau
tau['isclean']=~match(tau,mu_loose,0.5)&~match(tau,e_loose,0.5)
tau['isloose']=isLooseTau(tau.pt,tau.eta,tau.idDecayMode,tau.idMVAoldDM2017v2,self._year)
tau_clean=tau[tau.isclean.astype(np.bool)]
tau_loose=tau_clean[tau_clean.isloose.astype(np.bool)]
tau_ntot=tau.counts
tau_nloose=tau_loose.counts
pho = events.Photon
pho['isclean']=~match(pho,mu_loose,0.5)&~match(pho,e_loose,0.5)
_id = 'cutBasedBitmap'
if self._year=='2016': _id = 'cutBased'
pho['isloose']=isLoosePhoton(pho.pt,pho.eta,pho[_id],self._year)
pho['istight']=isTightPhoton(pho.pt,pho.eta,pho[_id],self._year)
pho['T'] = TVector2Array.from_polar(pho.pt, pho.phi)
#pho['p4'] = TLorentzVectorArray.from_ptetaphim(pho.pt, pho.eta, pho.phi, pho.mass)
pho_clean=pho[pho.isclean.astype(np.bool)]
pho_loose=pho_clean[pho_clean.isloose.astype(np.bool)]
pho_tight=pho_clean[pho_clean.istight.astype(np.bool)]
pho_ntot=pho.counts
pho_nloose=pho_loose.counts
pho_ntight=pho_tight.counts
leading_pho = pho[pho.pt.argmax()]
leading_pho = leading_pho[leading_pho.isclean.astype(np.bool)]
leading_pho = leading_pho[leading_pho.istight.astype(np.bool)]
j = events.Jet
j['isgood'] = isGoodJet(j.pt, j.eta, j.jetId, j.neHEF, j.neEmEF, j.chHEF, j.chEmEF)
j['isHEM'] = isHEMJet(j.pt, j.eta, j.phi)
j['isclean'] = ~match(j,e_loose,0.4)&~match(j,mu_loose,0.4)&~match(j,pho_loose,0.4)
#j['isiso'] = ~match(j,fj_clean,1.5) # What is this ?????
j['isdcsvL'] = (j.btagDeepB>deepcsvWPs['loose'])
j['isdflvL'] = (j.btagDeepFlavB>deepflavWPs['loose'])
j['T'] = TVector2Array.from_polar(j.pt, j.phi)
j['p4'] = TLorentzVectorArray.from_ptetaphim(j.pt, j.eta, j.phi, j.mass)
j['ptRaw'] =j.pt * (1-j.rawFactor)
j['massRaw'] = j.mass * (1-j.rawFactor)
j['rho'] = j.pt.ones_like()*events.fixedGridRhoFastjetAll.array
j_good = j[j.isgood.astype(np.bool)]
j_clean = j_good[j_good.isclean.astype(np.bool)] # USe this instead of j_iso Sunil
#j_iso = j_clean[j_clean.isiso.astype(np.bool)]
j_iso = j_clean[j_clean.astype(np.bool)] #Sunil changed
j_dcsvL = j_iso[j_iso.isdcsvL.astype(np.bool)]
j_dflvL = j_iso[j_iso.isdflvL.astype(np.bool)]
j_HEM = j[j.isHEM.astype(np.bool)]
j_ntot=j.counts
j_ngood=j_good.counts
j_nclean=j_clean.counts
j_niso=j_iso.counts
j_ndcsvL=j_dcsvL.counts
j_ndflvL=j_dflvL.counts
j_nHEM = j_HEM.counts
leading_j = j[j.pt.argmax()]
leading_j = leading_j[leading_j.isgood.astype(np.bool)]
leading_j = leading_j[leading_j.isclean.astype(np.bool)]
###
#Calculating derivatives
###
ele_pairs = e_loose.distincts()
diele = ele_pairs.i0+ele_pairs.i1
diele['T'] = TVector2Array.from_polar(diele.pt, diele.phi)
leading_ele_pair = ele_pairs[diele.pt.argmax()]
leading_diele = diele[diele.pt.argmax()]
mu_pairs = mu_loose.distincts()
dimu = mu_pairs.i0+mu_pairs.i1
dimu['T'] = TVector2Array.from_polar(dimu.pt, dimu.phi)
leading_mu_pair = mu_pairs[dimu.pt.argmax()]
leading_dimu = dimu[dimu.pt.argmax()]
###
# Calculate recoil
### HT, LT, dPhi, mT_{W}, MT_misET
um = met.T+leading_mu.T.sum()
ue = met.T+leading_e.T.sum()
umm = met.T+leading_dimu.T.sum()
uee = met.T+leading_diele.T.sum()
ua = met.T+leading_pho.T.sum()
#Need help from Matteo
u = {}
u['sr']=met.T
u['wecr']=ue
u['tecr']=ue
u['wmcr']=um
u['tmcr']=um
u['zecr']=uee
u['zmcr']=umm
u['gcr']=ua
###
#Calculating weights
###
if not isData:
###
# JEC/JER
###
#j['ptGenJet'] = j.matched_gen.pt
#Jet_transformer.transform(j)
gen = events.GenPart
#Need to understand this part Sunil
gen['isb'] = (abs(gen.pdgId)==5)&gen.hasFlags(['fromHardProcess', 'isLastCopy'])
gen['isc'] = (abs(gen.pdgId)==4)&gen.hasFlags(['fromHardProcess', 'isLastCopy'])
gen['isTop'] = (abs(gen.pdgId)==6)&gen.hasFlags(['fromHardProcess', 'isLastCopy'])
gen['isW'] = (abs(gen.pdgId)==24)&gen.hasFlags(['fromHardProcess', 'isLastCopy'])
gen['isZ'] = (abs(gen.pdgId)==23)&gen.hasFlags(['fromHardProcess', 'isLastCopy'])
gen['isA'] = (abs(gen.pdgId)==22)&gen.hasFlags(['fromHardProcess', 'isLastCopy'])
genTops = gen[gen.isTop]
genWs = gen[gen.isW]
genZs = gen[gen.isZ]
genAs = gen[gen.isA]
nlo = np.ones(events.size)
nnlo = np.ones(events.size)
nnlo_nlo = np.ones(events.size)
adhoc = np.ones(events.size)
if('TTJets' in dataset):
nlo = np.sqrt(get_ttbar_weight(genTops[:,0].pt.sum()) * get_ttbar_weight(genTops[:,1].pt.sum()))
#elif('GJets' in dataset):
# nlo = get_nlo_weight['a'](genAs.pt.max())
elif('WJets' in dataset):
#nlo = get_nlo_weight['w'](genWs.pt.max())
#if self._year != '2016': adhoc = get_adhoc_weight['w'](genWs.pt.max())
#nnlo = get_nnlo_weight['w'](genWs.pt.max())
nnlo_nlo = get_nnlo_nlo_weight['w'](genWs.pt.max())*(genWs.pt.max()>100).astype(np.int) + (genWs.pt.max()<=100).astype(np.int)
elif('DY' in dataset):
#nlo = get_nlo_weight['z'](genZs.pt.max())
#if self._year != '2016': adhoc = get_adhoc_weight['z'](genZs.pt.max())
#nnlo = get_nnlo_weight['dy'](genZs.pt.max())
nnlo_nlo = get_nnlo_nlo_weight['dy'](genZs.pt.max())*(genZs.pt.max()>100).astype(np.int) + (genZs.pt.max()<=100).astype(np.int)
elif('ZJets' in dataset):
#nlo = get_nlo_weight['z'](genZs.pt.max())
#if self._year != '2016': adhoc = get_adhoc_weight['z'](genZs.pt.max())
#nnlo = get_nnlo_weight['z'](genZs.pt.max())
nnlo_nlo = get_nnlo_nlo_weight['z'](genZs.pt.max())*(genZs.pt.max()>100).astype(np.int) + (genZs.pt.max()<=100).astype(np.int)
###
# Calculate PU weight and systematic variations
###
pu = get_pu_weight['cen'](events.PV.npvs)
#puUp = get_pu_weight['up'](events.PV.npvs)
#puDown = get_pu_weight['down'](events.PV.npvs)
###
# Trigger efficiency weight
###
ele1_trig_weight = get_ele_trig_weight(leading_ele_pair.i0.eta.sum(),leading_ele_pair.i0.pt.sum())
ele2_trig_weight = get_ele_trig_weight(leading_ele_pair.i1.eta.sum(),leading_ele_pair.i1.pt.sum())
# Need Help from Matteo
trig = {}
trig['sre'] = get_ele_trig_weight(leading_e.eta.sum(), leading_e.pt.sum())
trig['srm'] = #Need be fixed in Util first
trig['ttbare'] = get_ele_trig_weight(leading_e.eta.sum(), leading_e.pt.sum())
trig['ttbarm'] = #Need be fixed in Util first
trig['wjete'] = get_ele_trig_weight(leading_e.eta.sum(), leading_e.pt.sum())
trig['wjetm'] = #Need be fixed in Util first
trig['dilepe'] = 1 - (1-ele1_trig_weight)*(1-ele2_trig_weight)
#trig['dilepm'] = Need be fixed in Util first
# For muon ID weights, SFs are given as a function of abs(eta), but in 2016
##
mueta = abs(leading_mu.eta.sum())
mu1eta=abs(leading_mu_pair.i0.eta.sum())
mu2eta=abs(leading_mu_pair.i1.eta.sum())
if self._year=='2016':
mueta=leading_mu.eta.sum()
mu1eta=leading_mu_pair.i0.eta.sum()
mu2eta=leading_mu_pair.i1.eta.sum()
###
# Calculating electron and muon ID SF and efficiencies (when provided)
###
mu1Tsf = get_mu_tight_id_sf(mu1eta,leading_mu_pair.i0.pt.sum())
mu2Tsf = get_mu_tight_id_sf(mu2eta,leading_mu_pair.i1.pt.sum())
mu1Lsf = get_mu_loose_id_sf(mu1eta,leading_mu_pair.i0.pt.sum())
mu2Lsf = get_mu_loose_id_sf(mu2eta,leading_mu_pair.i1.pt.sum())
e1Tsf = get_ele_tight_id_sf(leading_ele_pair.i0.eta.sum(),leading_ele_pair.i0.pt.sum())
e2Tsf = get_ele_tight_id_sf(leading_ele_pair.i1.eta.sum(),leading_ele_pair.i1.pt.sum())
e1Lsf = get_ele_loose_id_sf(leading_ele_pair.i0.eta.sum(),leading_ele_pair.i0.pt.sum())
e2Lsf = get_ele_loose_id_sf(leading_ele_pair.i1.eta.sum(),leading_ele_pair.i1.pt.sum())
e1Teff= get_ele_tight_id_eff(leading_ele_pair.i0.eta.sum(),leading_ele_pair.i0.pt.sum())
e2Teff= get_ele_tight_id_eff(leading_ele_pair.i1.eta.sum(),leading_ele_pair.i1.pt.sum())
e1Leff= get_ele_loose_id_eff(leading_ele_pair.i0.eta.sum(),leading_ele_pair.i0.pt.sum())
e2Leff= get_ele_loose_id_eff(leading_ele_pair.i1.eta.sum(),leading_ele_pair.i1.pt.sum())
# Need Help from Matteo
ids={}
ids['sre'] = get_ele_tight_id_sf(leading_e.eta.sum(),leading_e.pt.sum())
ids['srm'] = get_mu_tight_id_sf(mueta,leading_mu.pt.sum())
ids['ttbare'] = get_ele_tight_id_sf(leading_e.eta.sum(),leading_e.pt.sum())
ids['ttbarm'] = get_mu_tight_id_sf(mueta,leading_mu.pt.sum())
ids['wjete'] = get_ele_tight_id_sf(leading_e.eta.sum(),leading_e.pt.sum())
ids['wjetm'] = get_mu_tight_id_sf(mueta,leading_mu.pt.sum())
ids['dilepe'] = e1Lsf*e2Lsf
ids['dilepm'] = mu1Lsf*mu2Lsf
###
# Reconstruction weights for electrons
###
e1sf_reco = get_ele_reco_sf(leading_ele_pair.i0.eta.sum(),leading_ele_pair.i0.pt.sum())
e2sf_reco = get_ele_reco_sf(leading_ele_pair.i1.eta.sum(),leading_ele_pair.i1.pt.sum())
# Need Help from Matteo
reco = {}
reco['sre'] = get_ele_reco_sf(leading_e.eta.sum(),leading_e.pt.sum())
reco['srm'] = np.ones(events.size)
reco['ttbare'] = get_ele_reco_sf(leading_e.eta.sum(),leading_e.pt.sum())
reco['ttbarm'] = np.ones(events.size)
reco['wjete'] = get_ele_reco_sf(leading_e.eta.sum(),leading_e.pt.sum())
reco['wjetm'] = np.ones(events.size)
reco['dilepe'] = e1sf_reco * e2sf_reco
reco['dilepm'] = np.ones(events.size)
###
# Isolation weights for muons
###
mu1Tsf_iso = get_mu_tight_iso_sf(mu1eta,leading_mu_pair.i0.pt.sum())
mu2Tsf_iso = get_mu_tight_iso_sf(mu2eta,leading_mu_pair.i1.pt.sum())
mu1Lsf_iso = get_mu_loose_iso_sf(mu1eta,leading_mu_pair.i0.pt.sum())
mu2Lsf_iso = get_mu_loose_iso_sf(mu2eta,leading_mu_pair.i1.pt.sum())
# Need Help from Matteo
isolation = {}
isolation['sre'] = np.ones(events.size)
isolation['srm'] = get_mu_tight_iso_sf(mueta,leading_mu.pt.sum())
isolation['ttbare'] = np.ones(events.size)
isolation['ttbarm'] = get_mu_tight_iso_sf(mueta,leading_mu.pt.sum())
isolation['wjete'] = np.ones(events.size)
isolation['wjetm'] = get_mu_tight_iso_sf(mueta,leading_mu.pt.sum())
isolation['dilepe'] = np.ones(events.size)
isolation['dilepm'] = mu1Lsf_iso*mu2Lsf_iso
###
# AK4 b-tagging weights
###
btag = {}
btagUp = {}
btagDown = {}
# Need Help from Matteo
btag['sr'], btagUp['sr'], btagDown['sr'] = get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'0')
btag['wmcr'], btagUp['wmcr'], btagDown['wmcr'] = get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'0')
btag['tmcr'], btagUp['tmcr'], btagDown['tmcr'] = get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'-1')
btag['wecr'], btagUp['wecr'], btagDown['wecr'] = get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'0')
btag['tecr'], btagUp['tecr'], btagDown['tecr'] = get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'-1')
btag['zmcr'], btagUp['zmcr'], btagDown['zmcr'] = np.ones(events.size), np.ones(events.size), np.ones(events.size)#get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'0')
btag['zecr'], btagUp['zecr'], btagDown['zecr'] = np.ones(events.size), np.ones(events.size), np.ones(events.size)#get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'0')
btag['gcr'], btagUp['gcr'], btagDown['gcr'] = np.ones(events.size), np.ones(events.size), np.ones(events.size)#get_deepflav_weight['loose'](j_iso.pt,j_iso.eta,j_iso.hadronFlavour,'0')
for r in selected_regions:
weights[r] = processor.Weights(len(events))
weights[r].add('genw',events.genWeight)
weights[r].add('nlo',nlo)
#weights[r].add('adhoc',adhoc)
#weights[r].add('nnlo',nnlo)
weights[r].add('nnlo_nlo',nnlo_nlo)
weights[r].add('pileup',pu)#,puUp,puDown)
weights[r].add('trig', trig[r])
weights[r].add('ids', ids[r])
weights[r].add('reco', reco[r])
weights[r].add('isolation', isolation[r])
weights[r].add('btag',btag[r], btagUp[r], btagDown[r])
#leading_fj = fj[fj.pt.argmax()]
#leading_fj = leading_fj[leading_fj.isgood.astype(np.bool)]
#leading_fj = leading_fj[leading_fj.isclean.astype(np.bool)]
###
#Importing the MET filters per year from metfilters.py and constructing the filter boolean
###
met_filters = np.ones(events.size, dtype=np.bool)
for flag in AnalysisProcessor.met_filter_flags[self._year]:
met_filters = met_filters & events.Flag[flag]
selection.add('met_filters',met_filters)
triggers = np.zeros(events.size, dtype=np.bool)
for path in self._met_triggers[self._year]:
if path not in events.HLT.columns: continue
triggers = triggers | events.HLT[path]
selection.add('met_triggers', triggers)
triggers = np.zeros(events.size, dtype=np.bool)
for path in self._singleelectron_triggers[self._year]:
if path not in events.HLT.columns: continue
triggers = triggers | events.HLT[path]
selection.add('singleelectron_triggers', triggers)
triggers = np.zeros(events.size, dtype=np.bool)
for path in self._singlemuon_triggers[self._year]:
if path not in events.HLT.columns: continue
triggers = triggers | events.HLT[path]
selection.add('singlemuon_triggers', triggers)
triggers = np.zeros(events.size, dtype=np.bool)
for path in self._singlephoton_triggers[self._year]:
if path not in events.HLT.columns: continue
triggers = triggers | events.HLT[path]
selection.add('singlephoton_triggers', triggers)
noHEMj = np.ones(events.size, dtype=np.bool)
if self._year=='2018': noHEMj = (j_nHEM==0)
selection.add('iszeroL',
(e_nloose==0)&(mu_nloose==0)&(tau_nloose==0)&(pho_nloose==0)
