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_resolution():
from coffea.jetmet_tools import JetResolution
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_Rho = np.full_like(test_eta, 10.0)
test_pt_jag = ak.unflatten(test_pt, counts)
test_eta_jag = ak.unflatten(test_eta, counts)
test_Rho_jag = ak.unflatten(test_Rho, counts)
jer_names = ["Spring16_25nsV10_MC_PtResolution_AK4PFPuppi"]
reso = JetResolution(**{name: evaluator[name] for name in jer_names})
print(reso)
resos = reso.getResolution(JetEta=test_eta, Rho=test_Rho, JetPt=test_pt)
resos_jag = reso.getResolution(JetEta=test_eta_jag,
Rho=test_Rho_jag,
JetPt=test_pt_jag)
assert ak.all(np.abs(resos - ak.flatten(resos_jag)) < 1e-6)
test_pt_jag = test_pt_jag[0:3]
test_eta_jag = test_eta_jag[0:3]
test_Rho_jag = test_Rho_jag[0:3]
test_Rho_jag = ak.concatenate(
[test_Rho_jag[:-1], [ak.concatenate([test_Rho_jag[-1, :-1], 100.0])]])
counts = counts[0:3]
print("Raw jet values:")
print("pT:", test_pt_jag)
print("eta:", test_eta_jag)
print("rho:", test_Rho_jag, "\n")
resos_jag_ref = ak.unflatten(
np.array([
0.21974642,
0.32421591,
0.33702479,
0.27420327,
0.13940689,
0.48134521,
0.26564994,
1.0,
]),
counts,
)
resos_jag = reso.getResolution(JetEta=test_eta_jag,
Rho=test_Rho_jag,
JetPt=test_pt_jag)
print("Reference Resolution (jagged):", resos_jag_ref)
print("Resolution (jagged):", resos_jag)
# NB: 5e-4 tolerance was agreed upon by lgray and aperloff, if the differences get bigger over time
# we need to agree upon how these numbers are evaluated (double/float conversion is kinda random)
assert ak.all(
np.abs(ak.flatten(resos_jag_ref) - ak.flatten(resos_jag)) < 5e-4)
def test_jet_resolution():
from coffea.jetmet_tools import JetResolution
counts, test_eta, test_pt = dummy_jagged_eta_pt()
test_Rho = np.full_like(test_eta, 100.)
jer_names = ['Spring16_25nsV10_MC_PtResolution_AK4PFPuppi']
reso = JetResolution(**{name: evaluator[name] for name in jer_names})
print(reso)
resos = reso.getResolution(JetEta=test_eta, Rho=test_Rho, JetPt=test_pt)
for filename in os.listdir(directory):
if jet_type not in filename: continue
fname = os.path.join(directory, filename)
Jetext.add_weight_sets(['* * '+fname])
print('%s added to weights' % fname)
Jetext.finalize()
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,
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)
'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 __init__(self, mcEventYields=None, jetSyst='nominal'):
################################
# INITIALIZE COFFEA PROCESSOR
def test_corrected_jets_factory():
import os
from coffea.jetmet_tools import CorrectedJetsFactory, CorrectedMETFactory, JECStack
events = None
from coffea.nanoevents import NanoEventsFactory
factory = NanoEventsFactory.from_root(
os.path.abspath("tests/samples/nano_dy.root"))
events = factory.events()
jec_stack_names = [
"Summer16_23Sep2016V3_MC_L1FastJet_AK4PFPuppi",
"Summer16_23Sep2016V3_MC_L2Relative_AK4PFPuppi",
"Summer16_23Sep2016V3_MC_L2L3Residual_AK4PFPuppi",
"Summer16_23Sep2016V3_MC_L3Absolute_AK4PFPuppi",
"Spring16_25nsV10_MC_PtResolution_AK4PFPuppi",
"Spring16_25nsV10_MC_SF_AK4PFPuppi",
]
for key in evaluator.keys():
if "Summer16_23Sep2016V3_MC_UncertaintySources_AK4PFPuppi" in key:
jec_stack_names.append(key)
jec_inputs = {name: evaluator[name] for name in jec_stack_names}
jec_stack = JECStack(jec_inputs)
name_map = jec_stack.blank_name_map
name_map["JetPt"] = "pt"
name_map["JetMass"] = "mass"
name_map["JetEta"] = "eta"
name_map["JetA"] = "area"
jets = events.Jet
jets["pt_raw"] = (1 - jets["rawFactor"]) * jets["pt"]
jets["mass_raw"] = (1 - jets["rawFactor"]) * jets["mass"]
jets["pt_gen"] = ak.values_astype(ak.fill_none(jets.matched_gen.pt, 0),
np.float32)
jets["rho"] = ak.broadcast_arrays(events.fixedGridRhoFastjetAll,
jets.pt)[0]
name_map["ptGenJet"] = "pt_gen"
name_map["ptRaw"] = "pt_raw"
name_map["massRaw"] = "mass_raw"
name_map["Rho"] = "rho"
jec_cache = cachetools.Cache(np.inf)
print(name_map)
tic = time.time()
jet_factory = CorrectedJetsFactory(name_map, jec_stack)
toc = time.time()
print("setup corrected jets time =", toc - tic)
tic = time.time()
prof = pyinstrument.Profiler()
prof.start()
corrected_jets = jet_factory.build(jets, lazy_cache=jec_cache)
prof.stop()
toc = time.time()
print("corrected_jets build time =", toc - tic)
print(prof.output_text(unicode=True, color=True, show_all=True))
tic = time.time()
print("Generated jet pt:", corrected_jets.pt_gen)
print("Original jet pt:", corrected_jets.pt_orig)
print("Raw jet pt:", jets.pt_raw)
print("Corrected jet pt:", corrected_jets.pt)
print("Original jet mass:", corrected_jets.mass_orig)
print("Raw jet mass:", jets["mass_raw"])
print("Corrected jet mass:", corrected_jets.mass)
print("jet eta:", jets.eta)
for unc in jet_factory.uncertainties():
print(unc)
print(corrected_jets[unc].up.pt)
print(corrected_jets[unc].down.pt)
toc = time.time()
print("build all jet variations =", toc - tic)
# Test that the corrections were applied correctly
from coffea.jetmet_tools import (
FactorizedJetCorrector,
JetResolution,
JetResolutionScaleFactor,
)
scalar_form = ak.without_parameters(jets["pt_raw"]).layout.form
corrector = FactorizedJetCorrector(
**{name: evaluator[name]
for name in jec_stack_names[0:4]})
corrs = corrector.getCorrection(JetEta=jets["eta"],
Rho=jets["rho"],
JetPt=jets["pt_raw"],
JetA=jets["area"])
reso = JetResolution(
**{name: evaluator[name]
for name in jec_stack_names[4:5]})
jets["jet_energy_resolution"] = reso.getResolution(
JetEta=jets["eta"],
Rho=jets["rho"],
JetPt=jets["pt_raw"],
form=scalar_form,
lazy_cache=jec_cache,
)
resosf = JetResolutionScaleFactor(
**{name: evaluator[name]
for name in jec_stack_names[5:6]})
jets["jet_energy_resolution_scale_factor"] = resosf.getScaleFactor(
JetEta=jets["eta"], lazy_cache=jec_cache)
# Filter out the non-deterministic (no gen pt) jets
def smear_factor(jetPt, pt_gen, jersf):
return (ak.full_like(jetPt, 1.0) +
(jersf[:, 0] - ak.full_like(jetPt, 1.0)) *
(jetPt - pt_gen) / jetPt)
test_gen_pt = ak.concatenate(
[corrected_jets.pt_gen[0, :-2], corrected_jets.pt_gen[-1, :-1]])
test_raw_pt = ak.concatenate([jets.pt_raw[0, :-2], jets.pt_raw[-1, :-1]])
test_pt = ak.concatenate(
[corrected_jets.pt[0, :-2], corrected_jets.pt[-1, :-1]])
test_eta = ak.concatenate([jets.eta[0, :-2], jets.eta[-1, :-1]])
test_jer = ak.concatenate([
jets.jet_energy_resolution[0, :-2], jets.jet_energy_resolution[-1, :-1]
])
test_jer_sf = ak.concatenate([
jets.jet_energy_resolution_scale_factor[0, :-2],
jets.jet_energy_resolution_scale_factor[-1, :-1],
])
test_jec = ak.concatenate([corrs[0, :-2], corrs[-1, :-1]])
test_corrected_pt = ak.concatenate(
[corrected_jets.pt[0, :-2], corrected_jets.pt[-1, :-1]])
test_corr_pt = test_raw_pt * test_jec
test_pt_smear_corr = test_corr_pt * smear_factor(test_corr_pt, test_gen_pt,
test_jer_sf)
# Print the results of the "by-hand" calculations and confirm that the values match the expected values
print("\nConfirm the CorrectedJetsFactory values:")
print("Jet pt (gen)", test_gen_pt.tolist())
print("Jet pt (raw)", test_raw_pt.tolist())
print("Jet pt (nano):", test_pt.tolist())
print("Jet eta:", test_eta.tolist())
print("Jet energy resolution:", test_jer.tolist())
print("Jet energy resolution sf:", test_jer_sf.tolist())
print("Jet energy correction:", test_jec.tolist())
print("Corrected jet pt (ref)", test_corr_pt.tolist())
print("Corrected & smeared jet pt (ref):", test_pt_smear_corr.tolist())
print("Corrected & smeared jet pt:", test_corrected_pt.tolist(), "\n")
assert ak.all(np.abs(test_pt_smear_corr - test_corrected_pt) < 1e-6)
name_map["METpt"] = "pt"
name_map["METphi"] = "phi"
name_map["JetPhi"] = "phi"
name_map["UnClusteredEnergyDeltaX"] = "MetUnclustEnUpDeltaX"
name_map["UnClusteredEnergyDeltaY"] = "MetUnclustEnUpDeltaY"
tic = time.time()
met_factory = CorrectedMETFactory(name_map)
toc = time.time()
print("setup corrected MET time =", toc - tic)
met = events.MET
tic = time.time()
# prof = pyinstrument.Profiler()
# prof.start()
corrected_met = met_factory.build(met,
corrected_jets,
lazy_cache=jec_cache)
# prof.stop()
toc = time.time()
# print(prof.output_text(unicode=True, color=True, show_all=True))
print("corrected_met build time =", toc - tic)
tic = time.time()
print(corrected_met.pt_orig)
print(corrected_met.pt)
prof = pyinstrument.Profiler()
prof.start()
for unc in jet_factory.uncertainties() + met_factory.uncertainties():
print(unc)
print(corrected_met[unc].up.pt)
print(corrected_met[unc].down.pt)
prof.stop()
toc = time.time()
print("build all met variations =", toc - tic)
print(prof.output_text(unicode=True, color=True, show_all=True))
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)