def test_get_equi_pop_bins(self):
n_bins = 5
w_bin = (self.dfr.y.max() - self.dfr.y.min()) / n_bins
bins = mh.get_equi_pop_bins(self.dfr, lambda df: df.y, n_bins)
self.assertEqual(len(bins), n_bins)
same_binning(bins,
[(i * w_bin, (i + 1) * w_bin) for i in xrange(n_bins)])
equal_bin_contents(self, self.dfr, bins, lambda d: d.y)
w_bin = (self.dfr.x.max() - self.dfr.x.min()) / n_bins
min_bin = self.dfr.x.min()
bins = mh.get_equi_pop_bins(self.dfr, lambda df: df.x, n_bins)
self.assertEqual(len(bins), n_bins)
same_binning(bins, [(min_bin + i * w_bin, min_bin + (i + 1) * w_bin)
for i in xrange(n_bins)])
equal_bin_contents(self, self.dfr, bins, lambda d: d.x)
def test_get_bin_means_selection(self):
sel = self.dfr.x < 0.8 # should cut off roughly the top 20 %
n_bins = 4
w_bin = (self.dfr[sel].x.max() - self.dfr[sel].x.min()) / n_bins
bin_centers = [w_bin / 2 + i * w_bin for i in xrange(n_bins)]
bins = mh.get_equi_pop_bins(self.dfr[sel], lambda d: d.x, n_bins)
means = mh.get_bin_means(self.dfr, lambda d: d.x, bins, sel)
npt.assert_allclose(means, bin_centers, atol=5e-3, rtol=0)
def test_equi_pop_bins_non_divisor(self):
n_bins = 13
w_bin = (self.dfr.y.max() - self.dfr.y.min()) / n_bins
bins = mh.get_equi_pop_bins(self.dfr, lambda d: d.y, n_bins)
self.assertEqual(len(bins), n_bins)
same_binning(bins,
[(i * w_bin, (i + 1) * w_bin) for i in xrange(n_bins)])
equal_bin_contents(self, self.dfr, bins, lambda d: d.y)
def test_get_bin_means(self):
n_bins = 5
w_bin = (self.dfr.x.max() - self.dfr.x.min()) / n_bins
bin_centers = [w_bin / 2 + i * w_bin for i in xrange(n_bins)]
bins = mh.get_equi_pop_bins(self.dfr, lambda d: d.x, n_bins)
means = mh.get_bin_means(self.dfr, lambda d: d.x, bins)
# if we get to the half percent level we are satisfied
npt.assert_allclose(means, bin_centers, atol=5e-3, rtol=0)
def create_muon_pz_res_map(dfr, n_bins_res, n_bins_p):
"""
See above, same thing for muon pz
"""
pz_bins = get_equi_pop_bins(dfr, lambda df: df.gen_muPPz.abs(), n_bins_p)
pz_bins = np.array(sorted({b for b in flatten(pz_bins)}))
res_bins = np.linspace(-0.15, 0.15, n_bins_res)
hist_sett = (len(pz_bins) - 1, pz_bins, len(res_bins) - 1, res_bins)
pz_p_map = create_res_v_gen_map(dfr, 'muPPz', hist_sett)
pz_n_map = create_res_v_gen_map(dfr, 'muNPz', hist_sett)
muon_map = pz_p_map.Clone()
muon_map.Add(pz_n_map)
return muon_map
def create_muon_pxy_res_map(dfr, n_bins_res, n_bins_p):
"""
Create the muon px and py combined residual maps (see photon for binning)
"""
px_bins = get_equi_pop_bins(dfr, lambda df: df.gen_muPPx.abs(), n_bins_p)
px_bins = np.array(sorted({b for b in flatten(px_bins)}))
res_bins = np.linspace(-0.15, 0.15, n_bins_res)
hist_sett = (len(px_bins) - 1, px_bins, len(res_bins) - 1, res_bins)
px_p_map = create_res_v_gen_map(dfr, 'muPPx', hist_sett)
px_n_map = create_res_v_gen_map(dfr, 'muNPx', hist_sett)
py_p_map = create_res_v_gen_map(dfr, 'muPPy', hist_sett)
py_n_map = create_res_v_gen_map(dfr, 'muNPy', hist_sett)
muon_map = px_n_map.Clone()
for mu_map in [px_n_map, py_p_map, py_n_map]:
muon_map.Add(mu_map)
return muon_map
def create_photon_res_map(dfr, n_bins_res, n_bins_p):
"""
Create the photon residuals map for a given number of resolution bins (equal
spacing) and a given number of P(x,y,z) bins (equal population)
"""
# determine the P(x,y,x) binning
px_bins = get_equi_pop_bins(dfr, lambda df: df.gen_photonPx.abs(),
n_bins_p)
# get_equi_pop_bins returns bins in an unsuitable format transform them to
# proper format
px_bins = np.array(sorted({b for b in flatten(px_bins)}))
res_bins = np.linspace(-2, 2, n_bins_res)
hist_sett = (len(px_bins) - 1, px_bins, len(res_bins) - 1, res_bins)
px_map = create_res_v_gen_map(dfr, 'photonPx', hist_sett)
py_map = create_res_v_gen_map(dfr, 'photonPy', hist_sett)
pz_map = create_res_v_gen_map(dfr, 'photonPz', hist_sett)
photon_map = px_map.Clone()
photon_map.Add(py_map)
photon_map.Add(pz_map)
return photon_map