def make_comp_plots(df, frame, outdir, jpsiPt):
"""
Make a set of histograms and put them onto some plots for comparison
"""
cond_mkdir(outdir)
selection_sets = get_selections(jpsiPt)
chi1_data = df[df.wChic1 == 1]
chi2_data = df[df.wChic2 == 1]
chi1_hists, chi2_hists, ratio_hists = {}, {}, {}
for selection in plot_selections:
print selection
chi1_hists[selection] = get_all_hists(chi1_data, frame,
selection_sets[selection])
chi2_hists[selection] = get_all_hists(chi2_data, frame,
selection_sets[selection])
ratio_hists[selection] = get_ratios(chi1_hists[selection],
chi2_hists[selection])
# save_2D_histograms(chi1_hists, outdir, 'chic1', drawOpt='colz',
# xLabel='|cos#theta^{{{}}}|'.format(frame),
# yLabel='#phi^{{{}}}'.format(frame))
# save_2D_histograms(chi2_hists, outdir, 'chic2', drawOpt='colz',
# xLabel='|cos#theta^{{{}}}|'.format(frame),
# yLabel='#phi^{{{}}}'.format(frame))
# save_2D_histograms(ratio_hists, outdir, 'ratio', drawOpt='colz',
# xLabel='|cos#theta^{{{}}}|'.format(frame),
# yLabel='#phi^{{{}}}'.format(frame))
save_1D_histograms(ratio_hists, outdir, 'ratio', drawOpt='E1',
yRange=[0, None], yLabel='#chi_{c2} / #chi_{c1}')
def main(args):
"""Main"""
data = get_dataframe(args.datafile)
cmfile = r.TFile.Open(args.corrmapfile)
accmap = get_correction_map(cmfile, not args.no_pt, args.acceptance)
cond_mkdir(args.outdir)
plot_args = {'drawOpt': 'colz'}
if args.plot_arguments is not None:
plot_args.update(parse_plot_args(args.plot_arguments.split(';;')))
if isinstance(accmap, r.TH2):
plot = make_overlay_plot(accmap, data, **plot_args)
plot.SaveAs('{}/corrmap_data_overlay_2d.pdf'.format(args.outdir))
else:
pt_binning = get_binning(accmap, 2)
pt_bins = zip(pt_binning[:-1], pt_binning[1:])
for pt_bin in pt_bins:
pdata = apply_selections(data, select_bin('JpsiPt', *pt_bin))
pmap = get_pt_bin(accmap, 0.5 * np.sum(pt_bin))
plot = make_overlay_plot(pmap, pdata, **plot_args)
plot.SaveAs('{}/corrmap_data_overlay_2d_{}_{}.pdf'.format(
args.outdir, int(pt_bin[0]), int(pt_bin[1])))
def main(args):
"""Main"""
graphf = r.TFile.Open(args.graphfile)
graphs = {
g.GetName().replace('_v_costh', ''): graphf.Get(g.GetName())
for g in graphf.GetListOfKeys()
}
if args.no_ratio:
ratio_name = 'r_chic2_chic1'
if ratio_name in graphs:
del graphs[ratio_name]
if args.intgraphfile is not None:
intf = r.TFile.Open(args.intgraphfile)
intgraphs = {
g.GetName().replace('_v_costh', ''): intf.Get(g.GetName())
for g in intf.GetListOfKeys()
}
else:
intgraphs = {g: None for g in graphs}
cond_mkdir(args.outdir)
for param in graphs:
can = make_comp_plot(graphs[param], intgraphs[param], args.dofit)
can.SaveAs(args.outdir + '/' + param + '_v_costh.pdf')
def main(args):
"""Main"""
mcfile1 = r.TFile.Open(args.mcfile1)
mcfile2 = r.TFile.Open(args.mcfile2)
frames = ['CS', 'HX', 'PX']
variables = ['TMath::Abs(costh_{})', 'phi_{}_fold']
x_labels = ['|cos#theta^{{{0}}}|', '#phi^{{{0}}}_{{folded}}']
cond_mkdir(args.outdir)
for frame in frames:
for i, var in enumerate(variables):
plot_var = var.format(frame)
x_label = x_labels[i].format(frame)
plot_name = '_'.join([get_plot_varname(plot_var),
'fidcut', 'ratio'])
save_name = get_savename(args.outdir, plot_name, args.extension)
make_plot(mcfile1, mcfile2, plot_var, x_label, save_name)
make_plot(mcfile1, mcfile2, 'TMath::Abs(cosalpha_HX)', '|cos#alpha|',
get_savename(args.outdir, 'abs_cosalpha_fidcuts_ratio',
args.extension))
def get_outdir(outdir, fitfile):
"""
Get the output directory (handle default case storing it to fitfile dir)
Also creates it if not already present
"""
if not outdir:
outdir = dirname(fitfile)
cond_mkdir(outdir)
return outdir
def main(args):
"""Main"""
set_basic_style()
sdc_dir = args.inputdir
cond_mkdir(args.outdir)
if args.plot_all:
plot_all_sdcs(sdc_dir, args.type, args.outdir)
plot_psi_sdcs(sdc_dir, args.type, args.outdir)
plot_chic1_sdcs(sdc_dir, args.type, args.outdir)
plot_chic2_sdcs(sdc_dir, args.type, args.outdir)
def main(args):
"""Main"""
set_basic_style()
input_files = parse_inputs(args.input)
outdir = '/'.join(['.', args.outdir])
cond_mkdir(outdir)
for var_pair in PLOT_PAIRS:
can = make_2d_contour_plot(input_files, var_pair)
save_name = outdir + '/' + 'corr_2d_{}_{}.pdf'.format(*var_pair)
can.SaveAs(save_name)
def main(args):
"""Main"""
set_TDR_style()
ucfile = r.TFile.Open(args.uncorrfile)
uncorr_g = get_graph(ucfile, 'r_chic2_chic1', args.variable)
cfile = r.TFile.Open(args.corrfile)
corr_g = get_graph(cfile, 'r_chic2_chic1', args.variable)
can = make_ratio_plot(uncorr_g, corr_g, args.variable)
cond_mkdir(args.outdir)
can.SaveAs('{}/r_chic2_chic1_v_{}_comp_corr_uncorr.pdf'.format(
args.outdir, args.variable))
def main(args):
"""Main"""
pserver = PlotServer(args.inputfile)
cond_mkdir(args.outdir)
input_set_sel = list(itertools.product(args.inputsets.split(','),
args.selections.split(',')))
for plot in itertools.product(args.variables.split(','),
args.frames.split(','),
args.plots.split(',')):
hists = get_plot_histos(pserver, input_set_sel, plot)
plot_savename = '_'.join([args.plotbase] + list(plot)) + args.extension
savename = '/'.join([args.outdir, plot_savename])
make_plot(hists, savename, args.reference, args.legend)
def main(args):
"""Main"""
set_basic_style()
dbfile = r.TFile.Open(args.debugfile)
var = determine_bin_variable(dbfile)
cond_mkdir(args.outdir)
for state in ['chi1', 'chi2']:
can = make_rej_evs_w_state_prob_plot(dbfile, state, var)
can.SaveAs('{}/{}_state_probs_rej_evs_{}_bins.pdf'.format(
args.outdir, state, var))
can = make_state_prob_plot(dbfile, state, var)
can.SaveAs('{}/{}_state_prob_{}_bins.pdf'.format(
args.outdir, state, var))
def main(args):
"""Main"""
ffile = r.TFile.Open(args.fitfile)
ws = ffile.Get('ws_mass_fit')
bin_sel_info = get_bin_sel_info(args.bin_info, args.fitfile)
outdir = args.outdir
if not outdir:
outdir = dirname(args.fitfile)
cond_mkdir(outdir)
if args.state == 'chic':
mass_model = ChicMassModel('chicMass')
elif args.state == 'chib':
mass_model = ChibMassModel(args.configfile)
elif args.state == 'config':
mass_model = ConfigFitModel(args.configfile)
else:
mass_model = JpsiMassModel('JpsiMass')
bin_var = None
if 'bin_variable' in bin_sel_info:
bin_var = bin_sel_info['bin_variable']
if not args.no_fit_plots:
make_fit_res_plots(ws,
bin_sel_info['costh_bins'],
args.state,
outdir,
mass_model,
bin_var,
logy=args.logy,
configfile=args.configfile,
ppars=args.print_pars,
corr_matrix=args.corr_matrix,
refit=args.refit,
fix_shape=args.fix_shape,
weighted_fit=args.weight,
verbose=args.verbose)
if args.graphs:
outfile = '/'.join([outdir, 'free_fit_param_graphs.root'])
store_graphs(ws, outfile, bin_sel_info, mass_model)
def main(args):
"""Main"""
set_basic_style()
vargraph_f = r.TFile.Open(args.variationfile)
with open(args.plot_config, 'r') as pconff:
plot_config = json.load(pconff)
cond_mkdir(args.outdir)
can = make_ratio_comp_plot(vargraph_f, plot_config, args.variable)
can.SaveAs('{}/r_chic2_chic1_comp_vars_nominal.pdf'.format(args.outdir))
can = make_abs_diff_plot(vargraph_f, plot_config, args.variable)
can.SaveAs('{}/r_chic2_chic1_abs_diff_comp_vars.pdf'.format(args.outdir))
can = make_rel_diff_plot(vargraph_f, plot_config, args.variable)
can.SaveAs('{}/r_chic2_chic1_rel_diff_comp_vars.pdf'.format(args.outdir))
def main():
"""Main"""
set_TDR_style()
cond_mkdir(OUTDIR)
data = apply_selections(get_dataframe(INFILE), SELECTIONS)
r.gStyle.SetPadRightMargin(0.129)
r.gStyle.SetPadLeftMargin(r.gStyle.GetPadLeftMargin() - 0.007)
can = make_costh_phi_plot(data, 'HX')
can.SaveAs(os.path.join(OUTDIR, 'costh_phi_fold_HX_pt_12_18_all.pdf'))
can = make_costh_phi_plot(data, 'CS')
can.SaveAs(os.path.join(OUTDIR, 'costh_phi_fold_CS_pt_12_18_all.pdf'))
set_TDR_style()
can = make_costh_mu_pt_plot(data)
can.SaveAs(os.path.join(OUTDIR, 'costh_HX_comp_mu_pt_jpsipt_12_18_all.pdf'))
def main(args):
"""Main"""
set_basic_style()
r.gStyle.SetPadLeftMargin(0.4)
with open(args.plotconfig, 'r') as conff:
plot_config = json.load(conff)
var_files = open_files(plot_config['variations'])
nom_file = r.TFile.Open(plot_config['nominal'])
cond_mkdir(args.outdir)
can = make_var_plot(nom_file, var_files, args.variable)
can.SaveAs('{}/comp_ppd_variations_nominal.pdf'.format(args.outdir))
if args.plot_ppd:
set_basic_style()
can = make_ppd_comp_plot(nom_file, var_files, args.variable)
can.SaveAs('{}/comp_ppds_full_ppds_variations_nominal.pdf'.format(
args.outdir))
def main(args):
"""Main"""
if args.verbose:
logging.getLogger().setLevel(logging.INFO)
else:
r.gROOT.ProcessLine('gErrorIgnoreLevel = 1001')
histfile = r.TFile.Open(args.inputfile)
cond_mkdir(args.outdir)
formats = args.extensions.split(',')
for hist in list_obj(histfile, 'TH1', args.filter):
store_hist(histfile.Get(hist),
args.outdir,
formats,
args.draw_opt,
xrange=args.xrange,
yrange=args.yrange,
zrange=args.zrange,
hist_cmd=args.hist_cmd)
def main(args):
"""Main"""
mcfile = r.TFile.Open(args.mcfile)
frames = ['CS', 'HX', 'PX']
frame_vars = ['TMath::Abs(costh_{})', 'phi_{}']
x_axis_labels_frame = ['|cos#theta^{{{0}}}|', '#phi^{{{0}}}_{{folded}}']
frame_indep_vars = ['TMath::Abs(cosalpha_HX)']
x_axis_labels = ['|cos#alpha|']
quantile_pairs = [[0.05, 0.99], [0.1, 0.95], [0.2, 0.9]]
outdir = args.outdir
cond_mkdir(outdir)
# mass overview plots
make_var_split_plot(mcfile, 'chicMass',
'/'.join([outdir, 'chicMass_MC_overview.pdf']),
leg=True, sum_dist=True, drawOpt='H')
make_mass_quantile_plots(mcfile, quantile_pairs,
'/'.join([outdir, 'mass_quantile_overview']))
# frame independent and frame dependent plots split by state
for state in ['chic1', 'chic2']:
for i, var in enumerate(frame_indep_vars):
save_base = '_'.join([get_plot_varname(var), state, 'quantile'])
x_label = x_axis_labels[i]
make_quantile_ratio_plots(mcfile, var, state, quantile_pairs,
'/'.join([outdir, save_base]),
x_label=x_label)
for frame in frames:
for i, var in enumerate(frame_vars):
fvar = var.format(frame)
x_label = x_axis_labels_frame[i].format(frame)
save_base = '_'.join([get_plot_varname(fvar), state, 'quantile'])
make_quantile_ratio_plots(mcfile, fvar, state, quantile_pairs,
'/'.join([outdir, save_base]),
x_label=x_label)
def main(args):
"""Main"""
set_basic_style()
llh_data = get_dataframe(args.scanfile, 'log_like_scan')
cond_mkdir(args.outdir)
can = make_plot_good_fit(llh_data, args.variable_x, args.variable_y,
args.transform_x, args.transform_y)
can.SaveAs('/'.join([args.outdir, 'scan_good_fit.pdf']))
can = make_plot_min_chi2(llh_data, args.variable_x, args.variable_y,
args.transform_x, args.transform_y)
can.SaveAs('/'.join([args.outdir, 'chi2_vals_all_fits.pdf']))
can = make_plot_min_chi2(llh_data,
args.variable_x,
args.variable_y,
args.transform_x,
args.transform_y,
gf_only=True)
can.SaveAs('/'.join([args.outdir, 'chi2_vals_good_fits.pdf']))
def main(args):
"""Main"""
with open(args.configfile, 'r') as configfile:
config = json.load(configfile)
model = BinnedFitModel(config)
ffile = r.TFile.Open(args.fitfile)
wsp = ffile.Get('ws_mass_fit')
if args.outdir is None:
outdir = dirname(args.fitfile)
else:
outdir = args.outdir
cond_mkdir(outdir)
if args.publication:
set_TDR_style()
# Saving the plots
if not args.no_plots:
cans = model.plot(wsp, verbose=args.verbose, publication=args.publication,
preliminary=args.preliminary)
canp = model.plot_fit_params(wsp)
for bin_name in model.bins:
plotname = '/'.join([outdir, bin_name+'_massfit.pdf'])
if args.publication:
add_auxiliary_info(cans[bin_name], 2012, prelim=True)
cans[bin_name].SaveAs(plotname)
parname = '/'.join([outdir, bin_name+'_massfit_res.pdf'])
canp[bin_name].SaveAs(parname)
if args.graphs:
outfile = '/'.join([outdir, 'proto_param_graphs.root'])
store_proto_pars(wsp, model, outfile, args.symmetric)
def main(args):
"""Main"""
set_basic_style()
gfile = r.TFile.Open(args.graphfile)
cond_mkdir(args.outdir)
for pfunc in [
psi2S_cs, jpsi_cs, chic_cs, chic_ratio_cs, psi_pol, combined_cs,
psi2S_cs_pulls, jpsi_cs_pulls, psi_2S_rel_diff, jpsi_rel_diff
]:
can = pfunc(gfile)
can.SaveAs('/'.join([args.outdir, pfunc.__name__ + '.pdf']))
for ptm, can in costh_ratios(gfile):
can.SaveAs('/'.join(
[args.outdir, 'costh_ratio_ptm_{}.pdf'.format(ptm)]))
can = combined_cs(gfile, 'ATLAS')
can.SaveAs('/'.join([args.outdir, 'combined_cs_ATLAS']) + '.pdf')
can = combined_cs(gfile, 'CMS')
can.SaveAs('/'.join([args.outdir, 'combined_cs_CMS']) + '.pdf')
def main(args):
"""Main"""
set_TDR_style()
graphfile = r.TFile.Open(args.graphfile)
var, graphs = get_graphs(graphfile)
if args.systematics is None:
can = make_plot(graphs, var, args.sigmas.split(','))
else:
syst_file = r.TFile.Open(args.systematics)
can = make_plot_with_syst(graphs, var, syst_file, args.fit,
args.pt_over_m)
comb_gr = can.pltables[1]
comb_gr.SetName(graphs.values()[0].GetName())
outfile = r.TFile(
'{}/comb_graph_{}_v_pt.root'.format(args.outdir, var), 'recreate')
outfile.cd()
comb_gr.Write()
outfile.Close()
cond_mkdir(args.outdir)
can.SaveAs('{}/{}_v_pt.pdf'.format(args.outdir, var))
def main(args):
c1f = r.TFile.Open(args.corrmaps1)
c2f = r.TFile.Open(args.corrmaps2)
corrmap1 = get_corrmap(c1f, 'HX', args.corr_var, args.mask_acc, args.use_acc_only,
min_acc=args.min_acc, mask_prec=args.min_prec)
corrmap2 = get_corrmap(c2f, 'HX', args.corr_var, args.mask_acc, args.use_acc_only,
min_acc=args.min_acc, mask_prec=args.min_prec)
corrmap1_PX = get_corrmap(c1f, 'PX', args.corr_var, args.mask_acc, args.use_acc_only,
min_acc=args.min_acc, mask_prec=args.min_prec)
corrmap2_PX = get_corrmap(c2f, 'PX', args.corr_var, args.mask_acc, args.use_acc_only,
min_acc=args.min_acc, mask_prec=args.min_prec)
selections = create_selection(args.selection)
scenarios = [
('chic1_R_2o3', 'chic2_R1_2o5_R2_2o5'),
('chic1_R_1', 'chic2_R1_0_R2_1'),
('chic1_R_0', 'chic2_R1_0_R2_0'),
]
attr = default_attributes(size=1.0, open_markers=True)[:3]
attr += [{'color': 13, 'line': 7, 'width': 2, 'marker': 1}]
cond_mkdir(args.outbase)
outfile = r.TFile('/'.join([args.outbase,
'costh_ratios_min_acc_{}_min_prec_{}_gen_{}.root'.format(pfloat(args.min_acc), pfloat(args.min_prec), args.gen_frame)]),
'recreate')
for scen in scenarios:
chi1_d, chi2_d = samples(args.toydatadir, scen, selections)
print(scen)
hists = OrderedDict()
print('uncorr')
hists['uncorr'] = (costh_h(chi2_d), costh_h(chi1_d))
print('corr HX')
hists['corr HX'] = (costh_h(chi2_d, corrmap2, 'HX', args.corr_var),
costh_h(chi1_d, corrmap1, 'HX', args.corr_var))
print('corr PX')
hists['corr PX'] = (costh_h(chi2_d, corrmap2_PX, 'PX', args.corr_var),
costh_h(chi1_d, corrmap1_PX, 'PX', args.corr_var))
if args.gen_frame == 'HX':
ratio_a, delta_lth = analytical_ratio(*scen)
if args.gen_frame == 'CS':
ratio_a, delta_lth = ratio_shape(*scen)
ratios = OrderedDict()
for case in hists:
ratios[case] = divide(*hists[case])
leg = setup_legend(0.15, 0.15, 0.55, 0.25)
leg.SetNColumns(2)
plots = scale_0(ratios.values())
leg_entries = ratios.keys()
if args.gen_frame == 'HX':
plots.append(scale_func(ratio_a))
leg_entries.append('analytical')
can = mkplot(plots,
attr=attr,
xLabel='|cos#vartheta^{HX}|', yLabel='#chi_{c2} / #chi_{c1}', xRange=[0, 1],
leg=leg, legEntries=leg_entries,
drawOpt='E1',
legOpt='PLE')
if args.gen_frame == 'CS':
can = mkplot(scale_0(ratio_a), attr=[attr[-1]], leg=leg, legEntries=['analytical'],
drawOpt='HISTsame', legOpt='PLE',
can=can)
can.SaveAs(pdfname(args.outbase, args.gen_frame, delta_lth, args.min_prec, args.min_acc))
outfile.cd()
for corr, ratio in ratios.iteritems():
ratio.SetName('_'.join([
scen[0], scen[1], 'ratio_costh_HX', corr.replace(' ', '_'), 'gen', args.gen_frame
]))
ratio.Write()
for corr in hists:
hist1, hist2 = hists[corr]
hist1.SetName('_'.join([
scen[0], scen[1], 'chi1_costh_HX', corr.replace(' ', '_'), 'gen', args.gen_frame
]))
hist1.Write()
hist2.SetName('_'.join([
scen[0], scen[1], 'chi2_costh_HX', corr.replace(' ', '_'), 'gen', args.gen_frame
]))
hist2.Write()
outfile.Close()
parser.add_argument('datafile', help='File containing the flat data tuple')
# parser.add_argument('--ptmin', type=float, default=8, help='minimum jpsi pt')
# parser.add_argument('--ptmax', type=float, default=50, help='maximum jpsi pt')
parser.add_argument(
'-t',
'--treename',
default='chic_tuple',
type=str,
help='name of the tree in which the original variables are '
'(used for storing output file).')
parser.add_argument('-o', '--outdir', help='output directory', default='.')
parser.add_argument('-g',
'--genlevel',
help='data is generator level',
default=False,
action='store_true')
parser.add_argument('-mc',
help='data is mc',
default=False,
action='store_true')
args = parser.parse_args()
data = get_dataframe(args.datafile, args.treename)
# right now defining a lambda for this, maybe there is a way to apply the abs function only partially
# pt_eta = lambda df, c: np.array([df['mu{}_pt'.format(c)], df['mu{}_eta'.format(c)].abs()])
cond_mkdir(args.outdir)
make_overview_plots(data, args.outdir, args.mc or args.genlevel,
args.genlevel)
