def draw_pdf(self, k=9, n=10, **dkw):
(med, e0, e1), m = calc_eff(k, n) / 100, (k + 1) / (n + 2)
f_str = 'TMath::Factorial([1] + 1) / (TMath::Factorial([0]) * TMath::Factorial([1] - [0])) * x ** [0] * (1 - x) ** ([1] - [0])'
f = self.Draw(self.Draw.make_f('epdf', f_str, pars=[k, n], npx=1000),
'Efficiency PDF',
**prep_kw(dkw, x_tit='Efficiency', y_tit='Probability'))
ff = self.Draw(self.Draw.make_f(None,
f_str,
med - e0,
med + e1,
pars=[k, n],
lw=0,
npx=1000,
fill_style=1001,
fill_color=1,
opacity=.3),
draw_opt='same')
ls = [
Draw.vertical_line(m, 0, f(m), style=7),
Draw.vertical_line(med, 0, f(med))
]
_ = [
Draw.arrow(med - e0, med, *[f(med) / 4] * 2, size=.01),
Draw.arrow(med + e1, med, *[f(med) / 4] * 2, size=.01),
f.Draw('same')
]
Draw.legend(ls + [ff], ['mean', 'mode', 'CL = 1#sigma'],
['l', 'l', 'f'],
left=True)
def draw_chi2_cross(self, bw=.25, col=20, row=40, **dkw):
(x, y), zz = [
f(cut=self.Cut.make_cross(col, row))
for f in [self.get_txy, self.get_chi2]
]
self.Draw.prof2d(x, y, zz, bins.get_local(self.Plane, bw),
**prep_kw(dkw, **self.ax_tits(), z_tit='#chi^{2}'))
def draw_y(self, trk=0, **dkw):
"""draw track in y-z plane."""
trk = where(self.Tel.Cut.make_all_cluster())[0][trk]
x, y = self.get_z() / 10, self.Tel.get_vs(
self.Cut.make_trk(trk)).reshape(-1)
self.Draw.graph(
x, y,
**prep_kw(dkw, x_tit='Z Position [cm]', y_tit='Y Position [mm]'))
def draw_n(self, cut=None, **dkw):
return self.Draw.distribution(
self.get_n(cut),
**prep_kw(dkw,
title='NTracks',
x0=-.5,
w=1,
x_tit='Number of Tracks'))
def get_fid(self, surface=False, name=None, **dkw):
x, y = self.get_fid_config(surface, name)
return None if x is None else Draw.polygon(
x, y,
**prep_kw(dkw,
show=False,
line_color=2,
width=2,
name=choose(name, f'fid{surface:d}')))
def draw_n_ev(self, **dkw):
return self.Draw.distribution(
self.get_n_ev(),
**prep_kw(dkw,
title='NTracks',
x0=-.5,
w=1,
rf=1,
x_tit='Number of Tracks'))
def draw_vs_angle(self, **dkw):
x, y, e = self.get_tree_vec(
['angle_x', 'angle_y', self.get_var()],
self.Cut.exclude('track angle x', 'track angle y'))
self.Draw.prof2d(
x, y, e * 100,
**prep_kw(dkw,
x_tit='Angle X',
y_tit='Angle Y',
z_tit='Efficiency [%]'))
def draw_vs_chi2(self, n=2, **dkw):
x, e = self.get_tree_vec(['chi2_tracks', self.get_var()],
self.Cut.exclude('chi2_x', 'chi2_y'))
self.Draw.efficiency(x,
e,
find_bins(x, n=n, lfac=0, lq=0),
title='Efficiency vs Chi2',
**prep_kw(dkw,
x_tit='Track #chi^{2}',
file_name='EffChi'))
def draw_map(self,
res=None,
fid=False,
cut=None,
local=False,
redo=False,
**dkw):
return self.Draw(
self.get_map(res, fid, cut, local, _redo=redo),
**prep_kw(dkw, leg=self.Cut.get_fid(), file_name='EfficiencyMap'))
def get_x_args(vs_time=False,
rel_time=False,
vs_irrad=False,
draw=False,
**kwargs):
kw = prep_kw(kwargs,
x_tit=AScan.get_x_tit(vs_time),
t_ax_off=AnalysisCollection.get_tax_off(
vs_time, rel_time),
x_off=None if vs_time or vs_irrad else 1.1)
return {**kw, **AScan.get_x_draw(vs_time)} if draw else kw
def draw_in_cell(self,
nbins=None,
ox=0,
oy=0,
cut=None,
max_angle=None,
**dkw):
""" in 3D cell"""
return self.draw_in(
self.DUT.PX, self.DUT.PY, ox, oy, nbins, cut, max_angle,
**prep_kw(dkw, title='In Cell Efficiency', z_tit='Efficiency [%]'))
def draw_vs_trigphase(self, **kwargs):
x, e = self.get_tree_vec(
['trigger_phase[1]', self.get_var()],
self.Cut.exclude('trigger_phase'))
return self.Draw.efficiency(
x, e, make_bins(-.5, 10),
**prep_kw(kwargs,
title='Trigger Phase Efficiency',
x_tit='Trigger Phase',
x_range=[-1, 10],
draw_opt='bap',
file_name='EffVsTP'))
def draw_in_pixel(self,
nbins=None,
ox=0,
oy=0,
cut=None,
max_angle=None,
**dkw):
""" in pixel of ROC"""
return self.draw_in(
Plane.PX, Plane.PY, ox, oy, nbins, cut, max_angle,
**prep_kw(dkw, title='In Pixel Efficiency',
z_tit='Efficiency [%]'))
def draw_vs_chi2_cut(self, step=5, **dkw):
cx, cy, e = self.get_tree_vec(
['chi2_x', 'chi2_y', self.get_var()],
self.Cut.exclude('chi2_x', 'chi2_y'))
x = arange(100, step=step) + step
qx, qy = [quantile(c, x / 100) for c in [cx, cy]]
y = [
calc_eff(values=e[(cx < qx[i]) & (cy < qy[i])])
for i in range(qx.size)
]
return self.Draw.graph(
x, y, 'Efficiency vs Chi2 Cut',
**prep_kw(dkw, x_tit='Cut Quantile [%]', y_tit='Efficiency [%]'))
def draw_map(self,
bw=.3,
local=True,
cut=None,
dut_plane=True,
trans=True,
**dkw):
binning = bins.get_xy(local,
self.Plane if dut_plane else self.Tel.Plane,
bw,
aspect_ratio=True)
return self.Draw.histo_2d(
*self.get_xy(local, cut, trans=trans), binning,
**prep_kw(dkw, title='Track Map', **self.ax_tits(local)))
def draw_vs_cuts(self, cuts=None, short=False, redo=False, **dkw):
cuts = choose(cuts, self.Cut.get_consecutive(short))
self.PBar.start(len(cuts), counter=True) if redo or not file_exists(
self.make_simple_pickle_path(
suf=f'{[*cuts.values()][-1].GetName()}_{self.UseRhit}')
) else do_nothing()
x, y = arange(len(cuts)), array(
[self.get(cut, _redo=redo) for cut in cuts.values()])
return self.Draw.graph(x,
y,
title='Efficiency for Consecutive Cuts',
y_tit='Efficiency [%]',
**prep_kw(dkw,
draw_opt='ap',
gridy=True,
x_range=[-1, len(y)],
bin_labels=cuts.keys()))
def draw(self, cut=None, bin_size=None, rel_time=False, **dkw):
x, e = self.get_tree_vec(
[self.get_t_var(), self.get_var()], choose(cut, self.Cut()))
g = self.Draw.efficiency(
x,
e,
self.Bins.get_time(
choose(
bin_size, 1000 if x.size // 20 < 1000 or x.size / 1000 < 20
else x.size // 20)),
show=False) # min bin size of 1000 max 20 points
fit, tit = FitRes(g.Fit('pol0', 'qs')), 'Hit Efficiency'
self.Draw(
g,
**prep_kw(dkw,
title=tit,
**self.get_t_args(rel_time),
y_range=[-5, 115],
gridy=True,
draw_opt='apz',
stats=set_statbox(fit=True, form='.2f', center_y=True),
file_name='HitEff'))
return fit if fit.Parameter(0) is not None else 0
def draw_fid(self, surface=False, name=None, **dkw):
self.get_fid(surface, name, **prep_kw(dkw, show=True))
def get_res(self, **dkw):
r, mx, my = append(self.get_config('residuals', dtype=float),
uarr2n(self.Ana.Residuals.get_means(cut=0))) * 1e3
return Draw.circle(r, mx, my, **prep_kw(dkw, show=False))
def draw_grid(self, off=-.5, **dkw):
self.get_grid(off, **prep_kw(dkw, show=True))
def draw_y(self, **dkw):
return self.Residuals.draw_y(**prep_kw(
dkw, lf=.5, rf=.5, stats=set_statbox(all_stat=True, form='.2f')))
def draw_cross(self, bw=.25, col=20, row=40, **dkw):
self.draw_hit_map(bw,
cut=self.Cut.make_cross(col, row),
**prep_kw(dkw, leg=self.Plane.get_grid()))
def get_grid(self, off=-.5, **dkw):
return Draw.grid(
arange(self.NCols + 1) + off,
arange(self.NRows + 1) + off, **prep_kw(dkw, show=False))
def draw_slope_x(self, col=20, **dkw):
x, y = [
f(cut=self.Cut.make_col(col))
for f in [self.Residuals.tx, self.get_slope_x]
] # noqa
self.Draw.profile(x, y, **prep_kw(dkw))
def draw_slope_y(self, cut=None, **dkw):
return self.Draw.distribution(
rad2deg(self.get_slope_y(cut)),
**prep_kw(dkw, title='Track Slope Y', x_tit='Track Slope [deg]'))
def draw_slopes(self, cut=None, **dkw):
g = [
getattr(self, f'draw_slope_{m}')(cut, lf=1, rf=1, show=False)
for m in self.M
]
return self.Draw.stack(g, 'TrackSlopes', self.M, **prep_kw(dkw))
def draw_chi2(self, cut=None, **dkw):
return self.Draw.distribution(
self.get_chi2(cut),
**prep_kw(dkw, x0=0, title='Chi2', x_tit='#chi^{2}'))
def draw_res(self, **dkw):
self.get_res(**prep_kw(dkw, show=True))
def make_pickle_path(self, *args, **kwargs):
return self.Ana.make_pickle_path(
*args, **prep_kw(kwargs, sub_dir=self.MetaSubDir))
def draw_sim(self, res=.5, n=1e6, noise=None, cut_off=410, **kwargs):
x = self.sim_signal(res, n, noise)
self.Draw.distribution(x[x < cut_off],
self.Ana.Bins.get_pad_ph(2),
x_tit='Pulse Height [mV]',
**prep_kw(kwargs, y_off=1.65, lm=.15))
