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_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)
#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
################################
self.mcEventYields = mcEventYields
if not jetSyst in ['nominal', 'JERUp', 'JERDown', 'JESUp', 'JESDown']:
raise Exception(
f'{jetSyst} is not in acceptable jet systematic types [nominal, JERUp, JERDown, JESUp, JESDown]'
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)