def __init__(self, csv=None, wp_key=None, eff_file=None, pattern=None):
'''SF computation according to method 1a of
https://twiki.cern.ch/twiki/bin/view/CMS/BTagSFMethods
Inputs: csv, wp_key, eff_file, pattern
csv: path to a b-tagging CSV file
wp_key: a tuple of three elements containing (Algo name, SF method, WP name)
eff_file: root file containing the efficiency histograms
pattern: formattable string that accepts one parameter for flavour definition'''
parsed_csv = reshuffle_sf_dict(convert_btag_csv_file(csv))
self.sf_ = recursive_compile(
parsed_csv[wp_key[0]][wp_key[1]][wp_key[2]])
# FIXME: move to correlated/uncorrelated
# Define, by hand, the proper correlation among taggers,
# somewhere unfortunately needs to be hardcoded by hand
# tuple of names for UDSG, B, C
self.schema_ = {
'central': ('UDSG_central', 'C_central', 'B_central'),
'bc_up': ('UDSG_central', 'C_up', 'B_up'),
'bc_down': ('UDSG_central', 'C_down', 'B_down'),
'udgs_up': ('UDSG_up', 'C_central', 'B_central'),
'udsg_down': ('UDSG_down', 'C_central', 'B_central'),
}
effs = convert_histo_root_file(eff_file)
self.eff_ = {
'B':
dense_lookup(*effs[(pattern.format('bottom'), 'dense_lookup')]),
'C':
dense_lookup(*effs[(pattern.format('charm'), 'dense_lookup')]),
'UDSG':
dense_lookup(*effs[(pattern.format('light'), 'dense_lookup')]),
}
def __init__(self, year, workingpoint):
self._year = year
self._wp = BTagEfficiency.btagWPs[year][workingpoint]
files = {
'2016': 'DeepCSV_Moriond17_B_H.csv.gz',
'2017': 'DeepCSV_94XSF_V5_B_F.csv.gz',
'2018': 'DeepCSV_102XSF_V1.csv.gz',
}
filename = os.path.join(os.path.dirname(__file__), 'data', files[year])
self.sf = BTagScaleFactor(filename, workingpoint)
files = {
'2016': 'btagQCD2017.coffea',
'2017': 'btagQCD2017.coffea',
'2018': 'btagQCD2017.coffea',
}
filename = os.path.join(os.path.dirname(__file__), 'data', files[year])
btag = util.load(filename)
bpass = btag.integrate('btag', 'pass').values()[()]
ball = btag.integrate('btag').values()[()]
nom = bpass / numpy.maximum(ball, 1.)
dn, up = hist.clopper_pearson_interval(bpass, ball)
self.eff = dense_lookup(nom, [ax.edges() for ax in btag.axes()[1:]])
self.eff_statUp = dense_lookup(up,
[ax.edges() for ax in btag.axes()[1:]])
self.eff_statDn = dense_lookup(dn,
[ax.edges() for ax in btag.axes()[1:]])
def get_pu_weights_function():
pufile_ = uproot.open(
join(os.getenv('FH_BASE'),
'FireHydrant/Tools/store/puWeights_10x_56ifb.root'))
sf_pu_cen = dense_lookup(pufile_['puWeights'].values,
pufile_['puWeights'].edges)
sf_pu_up = dense_lookup(pufile_['puWeightsUp'].values,
pufile_['puWeightsUp'].edges)
sf_pu_down = dense_lookup(pufile_['puWeightsDown'].values,
pufile_['puWeightsDown'].edges)
return sf_pu_cen, sf_pu_up, sf_pu_down
def stxs_lookups():
stxs_acc_lookups = {}
edges = np.array([])
values = np.array([])
for i in range(10):
for k, v in stxs_acc.items():
edges = np.append(edges, k)
values = np.append(values, v[i])
stxs_acc_lookups[i] = dense_lookup.dense_lookup(values, [edges])
stxs_acc_lookups[i]._axes = stxs_acc_lookups[i]._axes[0]
powheg_xsec_lookup = dense_lookup.dense_lookup(
np.array(list(powheg_xsec.values())),
[np.array(list(powheg_xsec.keys()))])
powheg_xsec_lookup._axes = powheg_xsec_lookup._axes[0]
return stxs_acc_lookups, powheg_xsec_lookup
def get_nlo_weight_function(type):
kfactor = uproot.open(
join(os.getenv('FH_BASE'), 'FireHydrant/Tools/store/kfactors.root'))
sf_qcd = 1.
sf_ewk = 1
lo = dict(
z="ZJets_LO/inv_pt",
w="WJets_LO/inv_pt",
a="GJets_LO/inv_pt_G",
)
nlo = dict(
z="ZJets_012j_NLO/nominal",
w="WJets_012j_NLO/nominal",
a="GJets_1j_NLO/nominal_G",
)
ewk = dict(
z="EWKcorr/Z",
w="EWKcorr/W",
a="EWKcorr/photon",
)
LO = kfactor[lo[type]].values
NLO = kfactor[nlo[type]].values
EWK = kfactor[ewk[type]].values
sf_qcd = NLO / LO
sf_ewk = EWK / LO
correction = dense_lookup(sf_qcd * sf_ewk, kfactor[nlo[type]].edges)
return correction
def _build(self, wrapped_values):
self._nsets = wrapped_values['nsets']
self._members = wrapped_values['members']
# now build the lookup tables
# for data scale, simple, just M A in bins of eta,phi
edges = wrapped_values['edges']['scales']
M = wrapped_values['values']['M']
A = wrapped_values['values']['A']
self._M = {s: {m: {t: dense_lookup(M[s][m][t], edges) for t in M[s][m]} for m in M[s]} for s in M}
self._A = {s: {m: {t: dense_lookup(A[s][m][t], edges) for t in A[s][m]} for m in A[s]} for s in A}
# for mc scale, more complicated
# version 1 if gen pt available
# only requires the kRes lookup
edges = wrapped_values['edges']['res']
kRes = wrapped_values['values']['kRes']
self._kRes = {s: {m: {t: dense_lookup(kRes[s][m][t], edges) for t in kRes[s][m]} for m in kRes[s]} for s in kRes}
# version 2 if gen pt not available
edges = wrapped_values['edges']['cb']
rsPars = wrapped_values['values']['rsPars']
cbS = wrapped_values['values']['cbS']
cbA = wrapped_values['values']['cbA']
cbN = wrapped_values['values']['cbN']
self._rsPars = {s: {m: {t: dense_lookup(rsPars[s][m][t], edges) for t in rsPars[s][m]} for m in rsPars[s]} for s in rsPars}
self._cbS = {s: {m: dense_lookup(cbS[s][m], edges) for m in cbS[s]} for s in cbS}
self._cbA = {s: {m: dense_lookup(cbA[s][m], edges) for m in cbA[s]} for s in cbA}
self._cbN = {s: {m: dense_lookup(cbN[s][m], edges) for m in cbN[s]} for s in cbN}
self._loaduncs = len(self._M.keys()) > 1
def _build(self, wrapped_values):
self._nsets = wrapped_values["nsets"]
self._members = wrapped_values["members"]
# now build the lookup tables
# for data scale, simple, just M A in bins of eta,phi
edges = wrapped_values["edges"]["scales"]
M = wrapped_values["values"]["M"]
A = wrapped_values["values"]["A"]
self._M = {
s: {m: {t: dense_lookup(M[s][m][t], edges) for t in M[s][m]} for m in M[s]}
for s in M
}
self._A = {
s: {m: {t: dense_lookup(A[s][m][t], edges) for t in A[s][m]} for m in A[s]}
for s in A
}
# for mc scale, more complicated
# version 1 if gen pt available
# only requires the kRes lookup
edges = wrapped_values["edges"]["res"]
kRes = wrapped_values["values"]["kRes"]
self._kRes = {
s: {
m: {t: dense_lookup(kRes[s][m][t], edges) for t in kRes[s][m]}
for m in kRes[s]
}
for s in kRes
}
# version 2 if gen pt not available
edges = wrapped_values["edges"]["cb"]
rsPars = wrapped_values["values"]["rsPars"]
cbS = wrapped_values["values"]["cbS"]
cbA = wrapped_values["values"]["cbA"]
cbN = wrapped_values["values"]["cbN"]
self._rsPars = {
s: {
m: {t: dense_lookup(rsPars[s][m][t], edges) for t in rsPars[s][m]}
for m in rsPars[s]
}
for s in rsPars
}
self._cbS = {
s: {m: dense_lookup(cbS[s][m], edges) for m in cbS[s]} for s in cbS
}
self._cbA = {
s: {m: dense_lookup(cbA[s][m], edges) for m in cbA[s]} for s in cbA
}
self._cbN = {
s: {m: dense_lookup(cbN[s][m], edges) for m in cbN[s]} for s in cbN
}
self._loaduncs = len(self._M.keys()) > 1
def __init__(self):
self.lepSFs_ = {}
for lepton in lep_info[year].keys():
SFfile = convert_histo_root_file(
'%s/inputs/data/%s' %
(proj_dir, lep_info[year][lepton]['filename']))
for sf_type in lep_info[year][lepton]['SFs'].keys():
if lep_info[year][lepton]['SFs'][sf_type]['available']:
self.lepSFs_['%s_%s' % (lepton, sf_type)] = dense_lookup(
*SFfile[(sf_type, 'dense_lookup')])
print('Lepton SF constructed')
def test_dense_lookup():
from coffea.lookup_tools.dense_lookup import dense_lookup
import numpy
a = ak.Array([[0.1, 0.2], [0.3]])
lookup = dense_lookup(numpy.ones(shape=(3, 4)),
(numpy.linspace(0, 1, 4), numpy.linspace(0, 1, 5)))
assert lookup(0.1, 0.3) == 1.0
assert numpy.all(
lookup(0.1, numpy.array([0.3, 0.5])) == numpy.array([1.0, 1.0]))
assert ak.to_list(lookup(a, a)) == [[1.0, 1.0], [1.0]]
def test_dense_lookup():
from coffea.lookup_tools.dense_lookup import dense_lookup
import numpy
import awkward1
a = awkward1.Array([[.1, .2], [.3]])
lookup = dense_lookup(numpy.ones(shape=(3, 4)),
(numpy.linspace(0, 1, 4), numpy.linspace(0, 1, 5)))
assert lookup(.1, .3) == 1.
assert numpy.all(
lookup(.1, numpy.array([.3, .5])) == numpy.array([1., 1.]))
assert awkward1.to_list(lookup(a, a)) == [[1.0, 1.0], [1.0]]
def pu_lookups(parameters, mode="nom", auto=[]):
lookups = {}
branch = {"nom": "pileup", "up": "pileup_plus", "down": "pileup_minus"}
for mode in ["nom", "up", "down"]:
pu_hist_data = uproot.open(parameters["pu_file_data"])[branch[mode]].values()
nbins = len(pu_hist_data)
edges = [[i for i in range(nbins)]]
if len(auto) == 0:
pu_hist_mc = uproot.open(parameters["pu_file_mc"])["pu_mc"].values()
else:
pu_hist_mc = np.histogram(auto, bins=range(nbins + 1))[0]
lookup = dense_lookup.dense_lookup(pu_reweight(pu_hist_data, pu_hist_mc), edges)
if Version(coffea.__version__) < Version("0.7.6"):
lookup._axes = lookup._axes[0]
lookups[mode] = lookup
return lookups
def musf_lookup(parameters):
mu_id_vals = 0
mu_id_err = 0
mu_iso_vals = 0
mu_iso_err = 0
mu_trig_vals_data = 0
mu_trig_err_data = 0
mu_trig_vals_mc = 0
mu_trig_err_mc = 0
for scaleFactors in parameters['muSFFileList']:
id_file = uproot.open(scaleFactors['id'][0])
iso_file = uproot.open(scaleFactors['iso'][0])
trig_file = uproot.open(scaleFactors['trig'][0])
mu_id_vals += id_file[scaleFactors['id'][1]].values * scaleFactors['scale']
mu_id_err += id_file[scaleFactors['id'][1]].variances**0.5 * scaleFactors['scale']
mu_id_edges = id_file[scaleFactors['id'][1]].edges
mu_iso_vals += iso_file[scaleFactors['iso'][1]].values * scaleFactors['scale']
mu_iso_err += iso_file[scaleFactors['iso'][1]].variances**0.5 * scaleFactors['scale']
mu_iso_edges = iso_file[scaleFactors['iso'][1]].edges
mu_trig_vals_data += trig_file[scaleFactors['trig'][1]].values * scaleFactors['scale']
mu_trig_vals_mc += trig_file[scaleFactors['trig'][2]].values * scaleFactors['scale']
mu_trig_err_data += trig_file[scaleFactors['trig'][1]].variances**0.5 * scaleFactors['scale']
mu_trig_err_mc += trig_file[scaleFactors['trig'][2]].variances**0.5 * scaleFactors['scale']
mu_trig_edges = trig_file[scaleFactors['trig'][1]].edges
mu_id_sf = dense_lookup.dense_lookup(mu_id_vals, mu_id_edges)
mu_id_err = dense_lookup.dense_lookup(mu_id_err, mu_id_edges)
mu_iso_sf = dense_lookup.dense_lookup(mu_iso_vals, mu_iso_edges)
mu_iso_err = dense_lookup.dense_lookup(mu_iso_err, mu_iso_edges)
mu_trig_eff_data = dense_lookup.dense_lookup(mu_trig_vals_data, mu_trig_edges)
mu_trig_eff_mc = dense_lookup.dense_lookup(mu_trig_vals_mc, mu_trig_edges)
mu_trig_err_data = dense_lookup.dense_lookup(mu_trig_err_data, mu_trig_edges)
mu_trig_err_mc = dense_lookup.dense_lookup(mu_trig_err_mc, mu_trig_edges)
return (mu_id_sf, mu_id_err, mu_iso_sf, mu_iso_err, mu_trig_eff_data,\
mu_trig_eff_mc, mu_trig_err_data, mu_trig_err_mc)
def pu_lookup(parameters, mode='nom', auto=[]):
if mode=='nom':
pu_hist_data = uproot.open(parameters['pu_file_data'])['pileup']
elif mode=='up':
pu_hist_data = uproot.open(parameters['pu_file_data'])['pileup_plus']
elif mode=='down':
pu_hist_data = uproot.open(parameters['pu_file_data'])['pileup_minus']
else:
print("PU lookup: incorrect mode ", mode)
return
nbins = len(pu_hist_data)
edges = [[i for i in range(nbins)]]
if len(auto)==0:
pu_hist_mc = uproot.open(parameters['pu_file_mc'])['pu_mc']
else:
pu_hist_mc = np.histogram(auto, bins=range(nbins+1))[0]
lookup = dense_lookup.dense_lookup(pu_reweight(pu_hist_data, pu_hist_mc), edges)
lookup._axes = lookup._axes[0]
return lookup
def musf_lookup(parameters):
mu_id_vals = 0
mu_id_err = 0
mu_iso_vals = 0
mu_iso_err = 0
mu_trig_vals_data = 0
mu_trig_err_data = 0
mu_trig_vals_mc = 0
mu_trig_err_mc = 0
for scaleFactors in parameters["muSFFileList"]:
id_file = uproot.open(scaleFactors["id"][0])
iso_file = uproot.open(scaleFactors["iso"][0])
trig_file = uproot.open(scaleFactors["trig"][0])
mu_id_vals += id_file[scaleFactors["id"][1]].values() * scaleFactors["scale"]
mu_id_err += (
id_file[scaleFactors["id"][1]].variances() ** 0.5 * scaleFactors["scale"]
)
mu_id_edges = [
id_file[scaleFactors["id"][1]].axis(0).edges(),
id_file[scaleFactors["id"][1]].axis(1).edges(),
]
mu_iso_vals += iso_file[scaleFactors["iso"][1]].values() * scaleFactors["scale"]
mu_iso_err += (
iso_file[scaleFactors["iso"][1]].variances() ** 0.5 * scaleFactors["scale"]
)
mu_iso_edges = [
iso_file[scaleFactors["iso"][1]].axis(0).edges(),
iso_file[scaleFactors["iso"][1]].axis(1).edges(),
]
mu_trig_vals_data += (
trig_file[scaleFactors["trig"][1]].values() * scaleFactors["scale"]
)
mu_trig_vals_mc += (
trig_file[scaleFactors["trig"][2]].values() * scaleFactors["scale"]
)
mu_trig_err_data += (
trig_file[scaleFactors["trig"][1]].variances() ** 0.5
* scaleFactors["scale"]
)
mu_trig_err_mc += (
trig_file[scaleFactors["trig"][2]].variances() ** 0.5
* scaleFactors["scale"]
)
mu_trig_edges = [
trig_file[scaleFactors["trig"][1]].axis(0).edges(),
trig_file[scaleFactors["trig"][1]].axis(1).edges(),
]
mu_id_sf = dense_lookup.dense_lookup(mu_id_vals, mu_id_edges)
mu_id_err = dense_lookup.dense_lookup(mu_id_err, mu_id_edges)
mu_iso_sf = dense_lookup.dense_lookup(mu_iso_vals, mu_iso_edges)
mu_iso_err = dense_lookup.dense_lookup(mu_iso_err, mu_iso_edges)
mu_trig_eff_data = dense_lookup.dense_lookup(mu_trig_vals_data, mu_trig_edges)
mu_trig_eff_mc = dense_lookup.dense_lookup(mu_trig_vals_mc, mu_trig_edges)
mu_trig_err_data = dense_lookup.dense_lookup(mu_trig_err_data, mu_trig_edges)
mu_trig_err_mc = dense_lookup.dense_lookup(mu_trig_err_mc, mu_trig_edges)
return {
"mu_id_sf": mu_id_sf,
"mu_id_err": mu_id_err,
"mu_iso_sf": mu_iso_sf,
"mu_iso_err": mu_iso_err,
"mu_trig_eff_data": mu_trig_eff_data,
"mu_trig_eff_mc": mu_trig_eff_mc,
"mu_trig_err_data": mu_trig_err_data,
"mu_trig_err_mc": mu_trig_err_mc,
}
def __init__(self, runNum=-1, eventNum=-1, mcEventYields=None):
self.mcEventYields = mcEventYields
dataset_axis = hist.Cat("dataset", "Dataset")
lep_axis = hist.Bin("lepFlavor", r"ElectronOrMuon", 2, -1, 1)
lep_axis.identifiers()[0].label = 'Electron'
lep_axis.identifiers()[1].label = 'Muon'
m3_axis = hist.Bin("M3", r"$M_3$ [GeV]", 200, 0., 1000)
mass_axis = hist.Bin("mass", r"$m_{\ell\gamma}$ [GeV]", 400, 0., 400)
pt_axis = hist.Bin("pt", r"$p_{T}$ [GeV]", 200, 0., 1000)
eta_axis = hist.Bin("eta", r"$\eta_{\gamma}$", 300, -1.5, 1.5)
chIso_axis = hist.Bin("chIso", r"Charged Hadron Isolation",
np.arange(-0.1, 20.001, .05))
## Define axis to keep track of photon category
phoCategory_axis = hist.Bin("category", r"Photon Category",
[1, 2, 3, 4, 5])
phoCategory_axis.identifiers()[0].label = "Genuine Photon"
phoCategory_axis.identifiers()[1].label = "Misidentified Electron"
phoCategory_axis.identifiers()[2].label = "Hadronic Photon"
phoCategory_axis.identifiers()[3].label = "Hadronic Fake"
###
self._accumulator = processor.dict_accumulator({
##photon histograms
'photon_pt':
hist.Hist("Counts", dataset_axis, pt_axis, phoCategory_axis,
lep_axis),
'photon_eta':
hist.Hist("Counts", dataset_axis, eta_axis, phoCategory_axis,
lep_axis),
'photon_chIso':
hist.Hist("Counts", dataset_axis, chIso_axis, phoCategory_axis,
lep_axis),
'photon_chIsoSideband':
hist.Hist("Counts", dataset_axis, chIso_axis, phoCategory_axis,
lep_axis),
'photon_lepton_mass':
hist.Hist("Counts", dataset_axis, mass_axis, phoCategory_axis,
lep_axis),
'photon_lepton_mass_3j0t':
hist.Hist("Counts", dataset_axis, mass_axis, phoCategory_axis,
lep_axis),
'M3':
hist.Hist("Counts", dataset_axis, m3_axis, phoCategory_axis,
lep_axis),
'M3Presel':
hist.Hist("Counts", dataset_axis, m3_axis, lep_axis),
'EventCount':
processor.value_accumulator(int)
})
self.eventNum = eventNum
self.runNum = runNum
ext = extractor()
ext.add_weight_sets([
f"btag2016 * {cwd}/ScaleFactors/Btag/DeepCSV_2016LegacySF_V1.btag.csv"
])
ext.finalize()
self.evaluator = ext.make_evaluator()
ele_id_file = uproot.open(
f'{cwd}/ScaleFactors/MuEGammaScaleFactors/ele2016/2016LegacyReReco_ElectronTight_Fall17V2.root'
)
self.ele_id_sf = dense_lookup.dense_lookup(
ele_id_file["EGamma_SF2D"].values,
ele_id_file["EGamma_SF2D"].edges)
self.ele_id_err = dense_lookup.dense_lookup(
ele_id_file["EGamma_SF2D"].variances**0.5,
ele_id_file["EGamma_SF2D"].edges)
ele_reco_file = uproot.open(
f'{cwd}/ScaleFactors/MuEGammaScaleFactors/ele2016/egammaEffi.txt_EGM2D_runBCDEF_passingRECO.root'
)
self.ele_reco_sf = dense_lookup.dense_lookup(
ele_reco_file["EGamma_SF2D"].values,
ele_reco_file["EGamma_SF2D"].edges)
self.ele_reco_err = dense_lookup.dense_lookup(
ele_reco_file["EGamma_SF2D"].variances**.5,
ele_reco_file["EGamma_SF2D"].edges)
mu_id_vals = 0
mu_id_err = 0
mu_iso_vals = 0
mu_iso_err = 0
mu_trig_vals = 0
mu_trig_err = 0
for scaleFactors in muSFFileList:
id_file = uproot.open(scaleFactors['id'][0])
iso_file = uproot.open(scaleFactors['iso'][0])
trig_file = uproot.open(scaleFactors['trig'][0])
mu_id_vals += id_file[scaleFactors['id']
[1]].values * scaleFactors['scale']
mu_id_err += id_file[scaleFactors['id']
[1]].variances**0.5 * scaleFactors['scale']
mu_id_edges = id_file[scaleFactors['id'][1]].edges
mu_iso_vals += iso_file[scaleFactors['iso']
[1]].values * scaleFactors['scale']
mu_iso_err += iso_file[scaleFactors['iso']
[1]].variances**0.5 * scaleFactors['scale']
mu_iso_edges = iso_file[scaleFactors['iso'][1]].edges
mu_trig_vals += trig_file[scaleFactors['trig']
[1]].values * scaleFactors['scale']
mu_trig_err += trig_file[
scaleFactors['trig'][1]].variances**0.5 * scaleFactors['scale']
mu_trig_edges = trig_file[scaleFactors['trig'][1]].edges
self.mu_id_sf = dense_lookup.dense_lookup(mu_id_vals, mu_id_edges)
self.mu_id_err = dense_lookup.dense_lookup(mu_id_err, mu_id_edges)
self.mu_iso_sf = dense_lookup.dense_lookup(mu_iso_vals, mu_iso_edges)
self.mu_iso_err = dense_lookup.dense_lookup(mu_iso_err, mu_iso_edges)
self.mu_trig_sf = dense_lookup.dense_lookup(mu_trig_vals,
mu_trig_edges)
self.mu_trig_err = dense_lookup.dense_lookup(mu_trig_err,
mu_trig_edges)
def find_alpha_correction(medians,
xbins,
output_xbins,
errors=None,
ybins=None,
output_ybins=None,
degree=None,
Fit=None):
#set_trace()
if np.ndim(medians) == 1:
if (medians < 0).sum() > 0:
print("Not all median input values are valid!")
# raise ValueError("Not all median input values are valid!")
#set_trace()
valid_medians = medians[medians != -10.]
valid_xbins = xbins[medians != -10.]
if Fit is None:
deg = 1 if degree is None else degree
#set_trace()
np_fit = np.polyfit(
valid_xbins,
valid_medians,
deg,
w=np.reciprocal(errors[medians != -10.]),
full=True) if errors is not None else np.polyfit(
valid_xbins, valid_medians, deg, full=True)
chisq_ndof = np_fit[1] / (len(valid_xbins) - (deg + 1))
fitvals = np.poly1d(np_fit[0])(output_xbins)
lookup = dense_lookup(*(fitvals, output_xbins))
return lookup, fitvals, chisq_ndof
elif Fit == 'Sqrt':
#set_trace()
p0 = [0.5, 0.5, 0.5]
popt, pcov = curve_fit(sqrt_x,
valid_xbins,
valid_medians,
p0,
method='dogbox')
#popt, pcov = curve_fit(sqrt_x, xbins, medians, p0, method='dogbox')
#popt, pcov = curve_fit(sqrt_x, xbins, medians, p0, bounds=(xbins[0], xbins[-1]), method='dogbox')
fitvals = sqrt_x(output_xbins, *popt)
lookup = dense_lookup(*(fitvals, output_xbins))
return lookup, fitvals
elif Fit == 'Sigmoid':
#set_trace()
set_trace()
p0 = [1., 1., 1., 0.5] # this is an mandatory initial guess
#p0 = [max(medians), min(xbins), 1, min(medians)] # this is an mandatory initial guess
#p0 = [max(medians), np.median(xbins), 1, min(medians)] # this is an mandatory initial guess
popt, pcov = curve_fit(sigmoid, xbins, medians, method='dogbox')
#popt, pcov = curve_fit(sigmoid, xbins, medians, p0, bounds=(xbins[0], xbins[-1]), method='dogbox')
fitvals = sigmoid(output_xbins, *popt)
lookup = dense_lookup(*(fitvals, output_xbins))
return lookup, fitvals
else:
# get x bincenter range by finding first and last bin that has valid medians for all mtt bins
first_xbin, last_xbin = np.where(
(medians > 0).all(axis=0))[0][0], np.where(
(medians > 0).all(axis=0))[0][-1]
fit_ybins = np.array([
(ybins[i + 1] + ybins[i]) / 2 for i in range(len(ybins) - 1)
]) # ybins to be used in interpolation
valid_medians = medians[:, first_xbin:last_xbin + 1]
deg = 'linear' if degree is None else degree
fit = interpolate.interp2d(xbins, fit_ybins, valid_medians, kind=deg)
fitvals = fit(output_xbins, output_ybins)
lookup = dense_lookup(*(fitvals, (output_xbins, output_ybins)))
return lookup, fitvals
fig, ax = plt.subplots()
fig.subplots_adjust(hspace=.07)
hslice = h_tot[lepcat].integrate('lepcat')
hslice = hslice.group(
pcat_cat, pcat,
pcat_groups) ## make groups based on perm category
if rebinning != 1:
xaxis_name = hslice.dense_axes()[0].name
hslice = hslice.rebin(xaxis_name, rebinning)
# save distribution to dict
if save_dist and (lepcat == 'Tight'):
hcor = hslice['Correct'].integrate('permcat')
edges = hcor.dense_axes()[0].edges()
lookup = dense_lookup(*(hcor.values().values()),
edges) # not normalized
permProbs[year]['3Jets'].update({hname: lookup})
## plot comparison of perm categories
plot.plot1d(
hslice,
overlay=hslice.axes()[0].name,
ax=ax,
clear=False,
line_opts={'linestyle': '-'},
density=True, # normalized to 1,
)
ax.autoscale() #, tight=True)
ax.set_ylim(0, ax.get_ylim()[1] * 1.15)
ax.set_ylabel('Probability Density')
ax.set_xlabel(xtitle)
ID_DEN_genTracks_eta_pt"),
'iso':
(f"mu2016/EfficienciesStudies_2016_legacy_rereco_rootfiles_RunGH_SF_ISO.root",
"NUM_Tight\
RelIso_DEN_TightIDandIPCut_eta_pt"),
'trig':
(f"mu2016/EfficienciesStudies_2016_trigger_EfficienciesAndSF_RunGtoH.root",
"IsoMu24_OR_I\
soTkMu24_PtEtaBins/abseta_pt_ratio"),
'scale':
16.226452636 / 35.882515396
}]
ele_id_file = uproot.open(
f'ele2016/2016LegacyReReco_ElectronTight_Fall17V2.root')
ele_id_sf = dense_lookup.dense_lookup(ele_id_file["EGamma_SF2D"].values,
ele_id_file["EGamma_SF2D"].edges)
ele_id_err = dense_lookup.dense_lookup(
ele_id_file["EGamma_SF2D"].variances**0.5,
ele_id_file["EGamma_SF2D"].edges)
ele_reco_file = uproot.open(
f'ele2016/egammaEffi.txt_EGM2D_runBCDEF_passingRECO.root')
ele_reco_sf = dense_lookup.dense_lookup(ele_reco_file["EGamma_SF2D"].values,
ele_reco_file["EGamma_SF2D"].edges)
ele_reco_err = dense_lookup.dense_lookup(
ele_reco_file["EGamma_SF2D"].variances**.5,
ele_reco_file["EGamma_SF2D"].edges)
mu_id_vals = 0
mu_id_err = 0
mu_iso_vals = 0
Plotter.plot_1D(orig_vals, orig_bins, xlabel=var_opts[var]["xtitle"], ylabel=var_opts[var]["ytitle"], color=year_opts[year]["col"], ax=ax, label="%s Original" % year_opts[year]["leg_title"])
# get interpolated values from ROOT Interpolate
orig_ratio_hist = Hist(orig_bins, name="", title="")
for xbin in range(1, orig_bins.size):
orig_ratio_hist[xbin] = orig_vals[xbin-1]
output_bins = np.arange(min(orig_bins), max(orig_bins)+10, 10)
interped_array = np.zeros(output_bins.size-1)
for xbin in range(output_bins.size-1):
interped_array[xbin] = orig_ratio_hist.Interpolate(output_bins[xbin])
Plotter.plot_1D(interped_array, output_bins, xlabel=var_opts[var]["xtitle"], ylabel=var_opts[var]["ytitle"], color=year_opts[year]["col"], ax=ax, label="%s Interp" % (year_opts[year]["leg_title"]), linestyle="--")
if args.save_ratios:
lookup = dense_lookup(*(interped_array, output_bins))
ratios[year].update({"%s_Interp" % var : lookup})
else:
(orig_xbins, orig_ybins), orig_vals = histo._axes, histo._values
orig_ratio_hist = Hist2D(orig_xbins, orig_ybins, name="mtt_ctstar", title="mtt_ctstar")
for ybin in range(1, orig_ybins.size):
for xbin in range(1, orig_xbins.size):
orig_ratio_hist[xbin, ybin] = orig_vals[xbin-1][ybin-1]
output_xbins = np.arange(min(orig_xbins), max(orig_xbins)+10, 10)
output_ybins = np.arange(min(orig_ybins), max(orig_ybins)+0.05, 0.05)
interped_array = np.zeros((output_xbins.size-1, output_ybins.size-1))
for ybin in range(output_ybins.size-1):
for xbin in range(output_xbins.size-1):
interped_array[xbin, ybin] = orig_ratio_hist.Interpolate(output_xbins[xbin], output_ybins[ybin])
b_total = output['hJets'].integrate('jetFlav', slice(5, 6)).values()
l_tagged = output['hBJets'].integrate('jetFlav', slice(0, 4)).values()
c_tagged = output['hBJets'].integrate('jetFlav', slice(4, 5)).values()
b_tagged = output['hBJets'].integrate('jetFlav', slice(5, 6)).values()
for k in l_total.keys():
l_total[k] = np.maximum(1, l_total[k])
c_total[k] = np.maximum(1, c_total[k])
b_total[k] = np.maximum(1, b_total[k])
if 0 in l_total[k]: print(k, 'light', l_total[k])
if 0 in l_total[k]: print(k, 'charm', c_total[k])
if 0 in l_total[k]: print(k, 'b', b_total[k])
btagEff = []
samples = []
for k in l_total.keys():
btagEff.append(
np.array([
l_tagged[k] / l_total[k], c_tagged[k] / c_total[k],
b_tagged[k] / b_total[k]
]))
samples.append(k[0])
taggingEffLookup = dense_lookup.dense_lookup(
np.array(btagEff), (samples, [0, 4, 5], btagEff_ptBins, btagEff_etaBins))
with open('taggingEfficienciesDenseLookup.pkl', 'wb') as _file:
pickle.dump(taggingEffLookup, _file)
sf_file = convert_histo_root_file(
os.path.join(proj_dir, 'inputs', 'data', base_jobid, 'lepSFs',
fname))
eta_binning = sf_file[(leptons[lep]['eta'], 'dense_lookup')][1][0]
#if lep == 'Muons': set_trace()
sf_output[year][lep]['eta_ranges'] = [
(eta_binning[idx], eta_binning[idx + 1])
for idx in range(len(eta_binning) - 1)
]
for idx in range(len(eta_binning) - 1):
# reco/ID SFs
sf_output[year][lep]['Reco_ID']['Central'][
'eta_bin%i' % idx] = dense_lookup(
*(sf_file[(leptons[lep]['pt']['reco_id'][idx],
'dense_lookup')][0],
sf_file[(leptons[lep]['pt']['reco_id'][idx],
'dense_lookup')][1][0]))
sf_output[year][lep]['Reco_ID']['Error'][
'eta_bin%i' % idx] = dense_lookup(
*(sf_file[('%s_error' % leptons[lep]['pt']['reco_id'][idx],
'dense_lookup')][0],
sf_file[('%s_error' % leptons[lep]['pt']['reco_id'][idx],
'dense_lookup')][1][0]))
# trigger SFs
sf_output[year][lep]['Trig']['Central'][
'eta_bin%i' %
idx] = dense_lookup(*(sf_file[(leptons[lep]['pt']['trig'][idx],
'dense_lookup')][0],
sf_file[(leptons[lep]['pt']['trig'][idx],
'dense_lookup')][1][0]))
# sig_dname = "_".join([boson, pos_evt_fraction_name]) # name of signal dist
# vals = dense_lookup(*fdict[(sig_dname, "dense_lookup")])
# errs = dense_lookup(*fdict[(f"{sig_dname}_error", "dense_lookup")])
# create dict of LO xsection values and errors
#set_trace()
LO_outdict = {}
for boson in bosons:
for proc, proc_name in procs.items():
for scale in scales:
for xsec_type in types:
for channel, chan_name in channels.items():
sig_dname = "_".join([
boson, proc, mg5_LO_xsecs_name, scale, xsec_type,
channel
])
vals = dense_lookup(*fdict[(sig_dname, "dense_lookup")])
errs = dense_lookup(*fdict[(f"{sig_dname}_error",
"dense_lookup")])
for mtt in masses:
for width in widths:
outname = f"{boson}toTTJets{chan_name}_M{mtt}_W{widthTOname(width)}_{proc_name}"
if scale != "nominal":
outname = f"{outname}_{scale}"
LO_outdict[outname] = vals(mtt, width)
lo_xsec_fname = os.path.join(proj_dir, "inputs", "signal_xsecs.json")
with open(lo_xsec_fname, "w") as out:
out.write(prettyjson.dumps(LO_outdict))
print(f"{lo_xsec_fname} written")
## plot ratios
normed_ratio_vals, normed_ratio_bins = Plotter.get_ratio_arrays(num_vals=nnlo_normed_histo.values()[()], denom_vals=tune_normed_histo.values()[()], input_bins=nnlo_normed_histo.dense_axes()[0].edges())
# orig
rax_norm.step(normed_ratio_bins, normed_ratio_vals, where="post", **{"linestyle" : "-", "color" : style_dict[year][1]})
# logy
rax_norm_logy.step(normed_ratio_bins, normed_ratio_vals, where="post", **{"linestyle" : "-", "color" : style_dict[year][1]})
## update min/max values
if np.min(tune_histo.values()[()]) < logy_min: logy_min = np.min(tune_histo.values()[()])
if np.max(tune_histo.values()[()]) > logy_max: logy_max = np.max(tune_histo.values()[()])
if np.min(tune_normed_histo.values()[()]) < normed_logy_min: normed_logy_min = np.min(tune_normed_histo.values()[()])
if np.max(tune_normed_histo.values()[()]) > normed_logy_max: normed_logy_max = np.max(tune_normed_histo.values()[()])
if args.save_ratios:
set_trace()
save_dict[year][tune_var] = dense_lookup(normed_ratio_vals[:-1], (nnlo_binning)) if vlines is None else dense_lookup(normed_ratio_vals[:-1].reshape(len(mtt_binning)-1,len(ctstar_binning)-1), (mtt_binning, ctstar_binning))
# plot yields
# format axes
ax.autoscale()#axis="x", tight=True)
ax.set_ylim(None, ax.get_ylim()[1]*1.15)
ax.set_xlabel(None)
ax.set_ylabel("%s [pb/GeV]" % ytitle)
rax.axhline(1, **{"linestyle": "--", "color": (0, 0, 0, 0.5), "linewidth": 1})
rax.set_ylabel("NNLO/Tune")
if vlines is None: rax.set_xlabel(xtitle)
# set plotting styles
## set legend and corresponding colors
