def computeDensity(input_file, tree, var, weight=None):
branches = [var]
if weight: branches.append(weight)
data = root2array(input_file, tree, branches=branches)
points = data.view((np.float64, len(data.dtype.names)))
values = points[:, 0] if weight else points
weights = points[:, 1] if weight else None
print values, weights
sumofweights = weights.sum() if weight else len(values)
histo = Hist(25, 0, 250, type='F')
histo.fill_array(values, weights=weights)
fft = False if weight else True
kde = ROOT.TKDE(len(values), array('d', values),
array('d', weights)) #, 0, 0, 'Binning:Unbinned')
graph = kde.GetGraphWithErrors(500)
for p in xrange(graph.GetN()):
graph.SetPoint(
p,
graph.GetX()[p],
graph.GetY()[p] * sumofweights * float(len(points)) / len(values))
graph.SetPointError(
p,
graph.GetEX()[p],
graph.GetEY()[p] * sumofweights * float(len(points)) / len(values))
#graph.Scale(sumofweights*float(len(points))/len(values))
#kde = sm.nonparametric.KDEUnivariate(values)
#kde.fit(kernel='gau', bw='normal_reference', fft=fft, weights=weights)
#graph = ROOT.TGraph(len(kde.support), kde.support, kde.density*sumofweights*float(len(points))/len(values))
#histo.Scale(1./histo.integral(overflow=True))
histo.Scale(float(len(points)) / len(values))
histo.Scale(1, 'width')
#graph = ROOT.TGraph(histo)
return graph, histo
def create_rootpy_hist(self,
vals=None,
bins=None,
hist=None,
norm=None,
upperCut=False,
htype=''):
'''
htype = VALS, ROOT or ROOTPY
'''
if htype == "VALS":
h_rtpy = Hist(bins)
for v in vals:
h_rtpy.Fill(v)
elif htype == "ROOTPY":
h_rtpy = hist
elif htype == "ROOT":
h_rtpy = asrootpy(hist)
else:
print "Please provide some histograms..."
return None
if upperCut:
h_rtpy = self.apply_max_cutoff(h_rtpy)
if norm:
h_rtpy.Scale(norm)
return h_rtpy
def getDataFromFile():
dataTemplate = inputTemplates[variable]['data'][whichBinFromFile]
h_data = Hist(nBins, 0, nBins, title='data')
for bin in range(1, nBins + 1):
h_data.SetBinContent(bin, dataTemplate[bin - 1])
pass
h_data.Scale(absolute_eta_initialValues['data'][whichBinFromFile][0])
return h_data
def FakeEff(in_mean, in_sigma):
in_func = F1("TMath::Gaus(x,{},{},true)".format(in_mean, in_sigma), 0, 100)
resolution = Hist(50, 0, 100)
n_events = 20000000
resolution.FillRandom(in_func.name, n_events)
resolution.Scale(1. / n_events)
hist = resolution.GetCumulative()
return hist
def computeHisto(self, name, bins):
if not name in self.data or not 'Data' in self.data[name]:
raise StandardError(
'Cannot find data for {NAME}'.format(NAME=name))
values = self.data[name]['Data'][0]
weights = self.data[name]['Data'][1]
histo = Hist(bins, type='F')
histo.Sumw2()
histo.fill_array(values, weights=weights)
histo.Scale(1, 'width')
#self.data[name]['Histo'] = histo
self.data[name]['Histo_' + str(hash(str(bins)))] = histo
def getDataFromFile(variable, whichBinFromFile):
dataTemplate = inputTemplates[variable]['data'][whichBinFromFile]
nBins = len(inputTemplates[variable]['data'][whichBinFromFile])
h_data = Hist(nBins, 0, nBins, title='data')
for bin in range(1, nBins + 1):
h_data.SetBinContent(bin, dataTemplate[bin - 1])
pass
h_data.Scale(absolute_eta_initialValues['data'][whichBinFromFile][0])
h_data.Sumw2()
for bin in range(1, nBins + 1):
h_data.SetBinError(bin, sqrt(h_data.GetBinContent(bin)))
pass
return h_data
def makeDiscr(discr_dict,
outfile,
xtitle="discriminator",
nbins=30,
x_min=0,
x_max=1):
c = ROOT.TCanvas("c", "c", 800, 500)
ROOT.gStyle.SetOptStat(0)
ROOT.gPad.SetMargin(0.15, 0.1, 0.2, 0.1)
#ROOT.gPad.SetLogy(1)
#ROOT.gPad.SetGrid(1,1)
ROOT.gStyle.SetGridColor(17)
l = TLegend(0.17, 0.75, 0.88, 0.88)
l.SetTextSize(0.055)
l.SetBorderSize(0)
l.SetFillStyle(0)
l.SetNColumns(2)
colors = [2, 4, 8, ROOT.kCyan + 2]
counter = 0
for leg, discr in discr_dict.iteritems():
a = Hist(nbins, x_min, x_max)
#fill_hist_with_ndarray(a, discr)
a.fill_array(discr)
a.SetLineColor(colors[counter])
a.SetLineWidth(2)
a.GetXaxis().SetTitle(xtitle)
a.GetXaxis().SetLabelSize(0.05)
a.GetXaxis().SetTitleSize(0.05)
a.GetXaxis().SetTitleOffset(1.45)
a.GetYaxis().SetTitle("a.u.")
a.GetYaxis().SetTickSize(0)
a.GetYaxis().SetLabelSize(0)
a.GetYaxis().SetTitleSize(0.06)
a.GetYaxis().SetTitleOffset(0.9)
a.Scale(1. / a.Integral())
#a.GetYaxis().SetRangeUser(0.00001,100)
a.GetYaxis().SetRangeUser(0, 0.2)
if counter == 0: a.draw("hist")
else: a.draw("same hist")
l.AddEntry(a, leg, "l")
counter += 1
l.Draw("same")
c.SaveAs(outfile)
def get_bias_corr(region):
if region == "ms":
bkg_bias_fname = "/lustre/cmswork/dcastrom/projects/hh/april_2017/CMSSW_8_0_25/src/Analysis/hh2bbbb_limit/notebooks/bias_22032018_with_weights_also_mass_cut/BM0/bias_correction_mass_cut_bigset_unscaled.json"
bkg_bias_fname = "/lustre/cmswork/dcastrom/projects/hh/april_2017/CMSSW_8_0_25/src/Analysis/hh2bbbb_limit/bias_01062018BM0/bias_correction_mass_cut_bigset_unscaled.json"
elif region == "btag":
bkg_bias_fname = "/lustre/cmswork/dcastrom/projects/hh/april_2017/CMSSW_8_0_25/src/Analysis/hh2bbbb_limit/notebooks/bms_btagside_err_fixed/BM0/bias_correction_bigset_unscaled.json"
elif region == "sig_unfixed":
bkg_bias_fname = "/lustre/cmswork/dcastrom/projects/hh/april_2017/CMSSW_8_0_25/src/Analysis/hh2bbbb_limit/notebooks/bias_22032018_with_weights_also_mass_cut/BM0/bias_correction_bigset_unscaled.json"
else:
bkg_bias_fname = "/lustre/cmswork/dcastrom/projects/hh/april_2017/CMSSW_8_0_25/src/Analysis/hh2bbbb_limit/bias_01062018BM0/bias_correction_bigset_unscaled.json"
with open(bkg_bias_fname, "r") as bkg_bias_file:
json_dict = json.load(bkg_bias_file)
print("using bias file: ", bkg_bias_file)
histo = Hist(json_dict['bin_edges'])
print histo
#hcorr = histo.Clone("h_bias_corrected")
#hcorr.Scale(4)
#hbias = histo.Clone("h_bias")
for n in range(len(json_dict['bias_corr'])):
bias = json_dict['bias_corr'][n]
var = json_dict['var'][n]
bias_unc = json_dict['bias_corr_unc_bs'][n]
bias_unc_stat = json_dict['bias_corr_unc_stat'][n]
#bkg_pred_initial = hcorr.GetBinContent(n+1)
#if var > np.sqrt(bkg_pred_initial):
new_bkg_pred_stat = var
#else:
# new_bkg_pred_stat = np.sqrt(bkg_pred_initial)
#new_bkg_pred_tot_unc = np.sqrt(new_bkg_pred_stat**2 + bias_unc**2 + bias_unc_stat**2)
new_bkg_pred_tot_unc = np.sqrt(bias_unc**2 + bias_unc_stat**2)
histo.SetBinContent(n + 1, bias)
histo.SetBinError(n + 1, new_bkg_pred_tot_unc)
histo.Scale(0.25)
#hcorr.Add(hbias, -1)
return histo
def plot_pTs(pT_lower_cut=100, pT_upper_cut=10000):
keywords = ['prescale', 'uncor_hardest_pT', 'cor_hardest_pT']
properties = parse_file(input_analysis_file,
pT_lower_cut=pT_lower_cut,
pT_upper_cut=pT_upper_cut,
keywords_to_populate=keywords)
uncorrected_pTs = properties['uncor_hardest_pT']
corrected_pTs = properties['cor_hardest_pT']
prescales = properties['prescale']
corrected_pt_hist = Hist(100,
5,
1005,
title='Jet Energy Corrected',
markersize=3.0,
color='black')
bin_width_corrected = (
corrected_pt_hist.upperbound() -
corrected_pt_hist.lowerbound()) / corrected_pt_hist.nbins()
uncorrected_pt_hist = Hist(100,
5,
1005,
title='Jet Energy Uncorrected',
markersize=3.0,
color='orange')
bin_width_uncorrected = (
uncorrected_pt_hist.upperbound() -
uncorrected_pt_hist.lowerbound()) / uncorrected_pt_hist.nbins()
map(uncorrected_pt_hist.Fill, uncorrected_pTs, prescales)
map(corrected_pt_hist.Fill, corrected_pTs, prescales)
corrected_pt_hist.Scale(
1.0 / (corrected_pt_hist.GetSumOfWeights() * bin_width_corrected))
uncorrected_pt_hist.Scale(
1.0 / (uncorrected_pt_hist.GetSumOfWeights() * bin_width_uncorrected))
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
ax0 = plt.subplot(gs[0])
ax1 = plt.subplot(gs[1])
data_plot = rplt.errorbar(corrected_pt_hist,
axes=ax0,
emptybins=False,
marker='o',
markersize=10,
pickradius=8,
capthick=5,
capsize=8,
elinewidth=5)
uncorrected_data_plot = rplt.errorbar(uncorrected_pt_hist,
axes=ax0,
emptybins=False,
marker='o',
markersize=10,
pickradius=8,
capthick=5,
capsize=8,
elinewidth=5)
data_x_errors, data_y_errors = [], []
for x_segment in data_plot[2][0].get_segments():
data_x_errors.append((x_segment[1][0] - x_segment[0][0]) / 2.)
for y_segment in data_plot[2][1].get_segments():
data_y_errors.append((y_segment[1][1] - y_segment[0][1]) / 2.)
data_points_x = data_plot[0].get_xdata()
data_points_y = data_plot[0].get_ydata()
data_plot_points_x = []
data_plot_points_y = []
for i in range(0, len(data_points_x)):
data_plot_points_x.append(data_points_x[i])
data_plot_points_y.append(data_points_y[i])
uncorrected_data_x_errors, uncorrected_data_y_errors = [], []
for x_segment in uncorrected_data_plot[2][0].get_segments():
uncorrected_data_x_errors.append(
(x_segment[1][0] - x_segment[0][0]) / 2.)
for y_segment in uncorrected_data_plot[2][1].get_segments():
uncorrected_data_y_errors.append(
(y_segment[1][1] - y_segment[0][1]) / 2.)
uncorrected_data_points_x = uncorrected_data_plot[0].get_xdata()
uncorrected_data_points_y = uncorrected_data_plot[0].get_ydata()
uncorrected_data_plot_points_x = []
uncorrected_data_plot_points_y = []
for i in range(0, len(uncorrected_data_points_x)):
uncorrected_data_plot_points_x.append(uncorrected_data_points_x[i])
uncorrected_data_plot_points_y.append(uncorrected_data_points_y[i])
data_to_data_y_err = [(b / m)
for b, m in zip(data_y_errors, data_plot_points_y)]
data_to_data_x_err = [
(b / m) for b, m in zip(data_x_errors, [1] * len(data_plot_points_y))
]
uncorrected_to_corrected_y_err = [
(b / m) for b, m in zip(uncorrected_data_y_errors, data_plot_points_y)
]
uncorrected_to_corrected_x_err = [
(b / m) for b, m in zip(uncorrected_data_x_errors, [1] *
len(data_plot_points_y))
]
# Legends Begin.
legend = ax0.legend(loc=1,
frameon=0,
fontsize=60,
bbox_to_anchor=[1.0, 1.0])
ax0.add_artist(legend)
extra = Rectangle((0, 0),
1,
1,
fc="w",
fill=False,
edgecolor='none',
linewidth=0)
if pT_upper_cut != 10000:
labels = [
r"$ \textrm{Anti--}k_{t}\textrm{:}~R = 0.5$",
r"$p_{T} \in [" + str(pT_lower_cut) + ", " + str(pT_upper_cut) +
"]~\mathrm{GeV};\eta<2.4$"
]
else:
labels = [
r"$ \textrm{Anti--}k_{t}\textrm{:}~R = 0.5$",
r"$p_{T} > " + str(pT_lower_cut) + "~\mathrm{GeV};\eta<2.4$"
]
ax0.legend([extra, extra],
labels,
loc=7,
frameon=0,
borderpad=0.1,
fontsize=60,
bbox_to_anchor=[0.92, 0.70])
# Legends End.
ax0.set_xlabel('$p_T~\mathrm{(GeV)}$', fontsize=75, labelpad=45)
ax1.set_xlabel('$p_T~\mathrm{(GeV)}$', fontsize=75, labelpad=45)
ax0.set_ylabel('$\mathrm{A.U.}$', fontsize=75, rotation=0, labelpad=75.)
ax1.set_ylabel("Ratio \nto \n" + "Corrected" +
" ",
fontsize=55,
rotation=0,
labelpad=115,
y=0.31)
ab = AnnotationBbox(OffsetImage(read_png(
get_sample_data("/home/aashish/root/macros/MODAnalyzer/mod_logo.png",
asfileobj=False)),
zoom=0.15,
resample=1,
dpi_cor=1), (0.26, 0.93),
xycoords='figure fraction',
frameon=0)
plt.gca().add_artist(ab)
preliminary_text = "Prelim. (20\%)"
plt.gcf().text(0.32,
0.9215,
preliminary_text,
fontsize=50,
weight='bold',
color='#444444',
multialignment='center')
# Ratio Plot.
uncorrected_pt_hist.Divide(corrected_pt_hist)
corrected_pt_hist.Divide(corrected_pt_hist)
rplt.errorbar(corrected_pt_hist,
xerr=data_to_data_x_err,
yerr=data_to_data_y_err,
axes=ax1,
emptybins=False,
marker='o',
markersize=10,
pickradius=8,
capthick=5,
capsize=8,
elinewidth=5)
rplt.errorbar(uncorrected_pt_hist,
xerr=uncorrected_to_corrected_x_err,
yerr=uncorrected_to_corrected_y_err,
axes=ax1,
emptybins=False,
marker='o',
markersize=10,
pickradius=8,
capthick=5,
capsize=8,
elinewidth=5)
ax0.set_yscale('log')
ax0.autoscale(True)
ax1.autoscale(True)
ax0.set_ylim(10e-8, 0.5 * 10e-1)
ax1.set_ylim(0., 2.)
ax0.set_xlim(0, 1000)
ax1.set_xlim(0, 1000)
plt.gcf().set_size_inches(30, 30, forward=1)
plt.sca(ax0)
plt.gca().xaxis.set_minor_locator(MultipleLocator(25))
plt.tick_params(which='major', width=5, length=25, labelsize=70)
plt.tick_params(which='minor', width=3, length=15)
plt.sca(ax1)
plt.gca().xaxis.set_minor_locator(MultipleLocator(25))
# plt.gca().yaxis.set_minor_locator(MultipleLocator(50))
plt.tick_params(which='major', width=5, length=25, labelsize=70)
plt.tick_params(which='minor', width=3, length=15)
plt.tight_layout(pad=1.08, h_pad=1.08, w_pad=1.08)
print "Printing pT spectrum with pT > " + str(
pT_lower_cut) + " and pT < " + str(pT_upper_cut)
plt.savefig("plots/Version 5/pT/data_pT_data_lower_" + str(pT_lower_cut) +
"_pT_upper_" + str(pT_upper_cut) + ".pdf")
# plt.show()
plt.clf()
if os.path.exists(sPathToFile):
a_acceptance_fraction = pickle.load(open(sPathToFile, 'r'))
print 'Successfully loaded acceptance fraction array!'
#a_acor = pickle.load(open(sPathToFile_autocorrelation, 'r'))
else:
print sPathToFile
print 'Could not find file!'
sys.exit()
#print a_acor
c_acceptance = Canvas()
h_acceptance = Hist(100,
0,
1,
name='h_acceptance',
title='Acceptance Fraction of Most Recent Sampler')
h_acceptance.fill_array(a_acceptance_fraction)
h_acceptance.Scale(1. / h_acceptance.Integral())
#h_acceptance.SetStats(0)
h_acceptance.Draw()
c_acceptance.Update()
raw_input('Press enter to continue...')
plot_name = '%s_acceptance_fraction' % (dir_specifier_name)
plot_name = 'yields_fit_%s' % (plot_name)
neriX_analysis.save_plot(l_plots, c_acceptance, plot_name)
def do_analysis(chain, analyze_this, outfile, eventtype):
# get trees from files
#t = f.Get("Delphes")
# get number of entries
nentries = chain.GetEntries()
# initialize everything here before filling histograms
if (analyze_this['Jet.PT']):
print "\nInitializing Jet.PT...\n"
# create the histograms
numJets = Hist(NBINS,
NLO,
NHI,
title='numJets ' + eventtype,
legendstyle='L')
# interesting values to plot
max_jetpt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Max JetPT/Event ' + eventtype,
legendstyle='L')
min_jetpt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Min JetPT/Event ' + eventtype,
legendstyle='L')
else:
print "Skipped Jet.PT"
if (analyze_this['Jet.BTag']):
print "Initializing Jet.BTag...\n"
# create the histograms
loose = Hist(NBINS,
NLO,
NHI,
title='loose ' + eventtype,
legendstyle='L')
medium = Hist(NBINS,
NLO,
NHI,
title='medium ' + eventtype,
legendstyle='L')
tight = Hist(NBINS,
NLO,
NHI,
title='tight ' + eventtype,
legendstyle='L')
else:
print "Skipped Jet.BTag"
if (analyze_this['Electron.PT']):
print "Initializing Electron.PT...\n"
# create the histograms
numElectrons = Hist(NBINS,
NLO,
NHI,
title='numElectrons ' + eventtype,
legendstyle='L')
# interesting values to plot
max_ept_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Max ElectronPT/Event ' + eventtype,
legendstyle='L')
min_ept_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Min ElectronPT/Event ' + eventtype,
legendstyle='L')
# initialize any variable-specific constants here:
# counter for no electrons
noeleaf = 0
else:
print "Skipped Electron.PT"
if (analyze_this['MuonTight.PT']):
print "Initializing MuonTight.PT...\n"
# create the histograms
numMuons = Hist(NBINS,
NLO,
NHI,
title='numMuons ' + eventtype,
legendstyle='L')
# interesting values to plot
max_upt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Max MuonPT/Event ' + eventtype,
legendstyle='L')
min_upt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Min MuonPT/Event ' + eventtype,
legendstyle='L')
# initialize any variable-specific constants here:
# counter for no electrons
nouleaf = 0
else:
print "Skipped MuonTight.PT"
if (analyze_this['MissingET.MET']):
print "Initializing MissingET.MET...\n"
# create the histograms
MET = Hist(MET_NBINS,
MET_NLO,
MET_NHI,
title='MET ' + eventtype,
legendstyle='L')
else:
print "Skipped MissingET.MET"
if (analyze_this['MT (NON-LEAF)']):
print "Initializing MT...\n"
# create the histograms
MT = Hist(MT_NBINS,
MT_NLO,
MT_NHI,
title='MT ' + eventtype,
legendstyle='L')
else:
print "Skipped HT"
if (analyze_this['HT (NON-LEAF)']):
print "Initializing HT...\n"
# create the histograms
HT = Hist(HT_NBINS,
HT_NLO,
HT_NHI,
title='HT ' + eventtype,
legendstyle='L')
else:
print "Skipped HT"
if (analyze_this['DELTA PHI (NON-LEAF)']):
print "Initializing Delta Phi...\n"
# create the histograms
DPHI_metlep = Hist(30,
-1 * np.pi,
np.pi,
title='Delta Phi (MET-lep) ' + eventtype,
legendstyle='L')
DPHI_metjet = Hist(30,
-1 * np.pi,
np.pi,
title='Delta Phi (MET-jet)' + eventtype,
legendstyle='L')
else:
print "Skipped DELTA PHI"
if (analyze_this['DELTA R (NON-LEAF)']):
print "Initializing Delta R...\n"
#create histograms
DR = Hist(50,
0,
2 * np.pi,
title='DELTA R ' + eventtype,
legendstyle='L')
else:
print "Skipped DELTA R"
# Now fill histograms
print "\nFilling histograms...\n"
# get float version of num entries to normalize below; subtract 1 to get
# actual integral value of hist
norm = float(nentries - 1)
for e in range(nentries):
entry = chain.GetEntry(e)
# to check whether each entry is electron or muon
is_electron = False
is_muon = False
e_maxpt = 0
e_maxpt_phi = 0
u_maxpt = 0
u_maxpt_phi = 0
jet_maxpt = 0
jet_maxpt_phi = 0
jet_maxpt_eta = 0
met = 0
met_phi = 0
met_eta = 0
lepton_vec = []
if (analyze_this['Electron.PT']):
# define leaves
var = "Electron.PT"
leaf = chain.GetLeaf(var)
phileaf = chain.GetLeaf('Electron.Phi')
etaleaf = chain.GetLeaf('Electron.Eta')
# returns phi of max pt for entry
(e_maxpt, e_maxpt_phi, e_maxpt_eta) = fill_Electron_hist(
chain, leaf, entry, numElectrons, min_ept_per_event,
max_ept_per_event, phileaf, etaleaf, lepton_vec)
#print lepton_vec
if (leaf.GetLen() == 0):
noeleaf += 1
e_maxpt = INVALID
e_maxpt_phi = INVALID
e_maxpt_eta = INVALID
else:
is_electron = True
if (analyze_this['MuonTight.PT']):
# define leaves
var = "MuonTight.PT"
leaf = chain.GetLeaf(var)
phileaf = chain.GetLeaf('MuonTight.Phi')
etaleaf = chain.GetLeaf('MuonTight.Eta')
(u_maxpt, u_maxpt_phi, u_maxpt_eta) = fill_Muon_hist(
chain, leaf, entry, numMuons, min_upt_per_event,
max_upt_per_event, phileaf, etaleaf, lepton_vec)
if leaf.GetLen() == 0:
nouleaf += 1
u_maxpt = INVALID
u_maxpt_phi = INVALID
u_maxpt_eta = INVALID
else:
is_muon = True
# Get preferred lepton for future calcs
if e_maxpt >= u_maxpt:
lpt = e_maxpt
lphi = e_maxpt_phi
leta = e_maxpt_eta
else:
lpt = u_maxpt
lphi = u_maxpt_phi
leta = u_maxpt_eta
if (analyze_this['Jet.PT']):
# define leaves
var = 'Jet.PT'
leaf = chain.GetLeaf(var)
phileaf = chain.GetLeaf('Jet.Phi')
etaleaf = chain.GetLeaf('Jet.Eta')
# analyze with Jet.PT because HT is sum of Jet.PTs
if (analyze_this['HT (NON-LEAF)']):
HTfill = True
else:
HTfill = False
# returns phi of max pt for entry
(jet_maxpt, jet_maxpt_phi, jet_maxpt_eta) = fill_JetPT_hist(
chain, leaf, entry, numJets, min_jetpt_per_event,
max_jetpt_per_event, HTfill, HT, phileaf, etaleaf, lepton_vec)
if (leaf.GetLen() == 0):
jet_maxpt = INVALID
jet_maxpt_phi = INVALID
jet_maxpt_eta = INVALID
if (analyze_this['Jet.BTag']):
# define leaves
var = "Jet.BTag"
leaf = chain.GetLeaf(var)
fill_JetBTag_hist(chain, leaf, entry, loose, medium, tight)
if (analyze_this['MissingET.MET']):
# define leaves
var = "MissingET.MET"
leaf = chain.GetLeaf(var)
phileaf = chain.GetLeaf('MissingET.Phi')
etaleaf = chain.GetLeaf('MissingET.Eta')
(met, metphi, meteta) = fill_MET_hist(chain, leaf, entry, MET,
phileaf, etaleaf)
if (analyze_this['MT (NON-LEAF)']):
#print "ok got here"
#print "here ",e_maxpt, e_maxpt_phi, u_maxpt, u_maxpt_phi, met, metphi
if (not (is_muon or is_electron)):
mt_val = 0
else:
#print e_maxpt, e_maxpt_phi, u_maxpt, u_maxpt_phi, met, metphi
#print is_electron, is_muon
mt_val = get_mt(lpt, lphi, met, metphi)
if mt_val == 0:
MT.Fill(INVALID)
else:
MT.Fill(mt_val)
if (analyze_this['DELTA PHI (NON-LEAF)']):
dphi_metlep_val = delta_phi(metphi, lphi)
dphi_metjet_val = delta_phi(metphi, jet_maxpt_phi)
DPHI_metlep.Fill(dphi_metlep_val)
DPHI_metjet.Fill(dphi_metjet_val)
if (analyze_this['DELTA R (NON-LEAF)']):
dr_val = delta_R(jet_maxpt_phi, lphi, jet_maxpt_eta, leta)
if dr_val == 0:
dr_val = INVALID
#elif dr_val > 3.0 and dr_val < 3.3:
#print jet_maxpt_phi, lphi, jet_maxpt_eta, leta
DR.Fill(dr_val)
if (analyze_this['Jet.PT']):
# normalize
numJets.Scale(1 / (numJets.Integral()))
max_jetpt_per_event.Scale(1 / (max_jetpt_per_event.Integral()))
min_jetpt_per_event.Scale(1 / (min_jetpt_per_event.Integral()))
if (analyze_this['Jet.BTag']):
# normalize
tight.Scale(1 / (tight.Integral()))
medium.Scale(1 / (medium.Integral()))
loose.Scale(1 / (loose.Integral()))
if (analyze_this['Electron.PT']):
# normalize
numElectrons.Scale(1 / (numElectrons.Integral()))
max_ept_per_event.Scale(1 / (max_ept_per_event.Integral()))
min_ept_per_event.Scale(1 / (min_ept_per_event.Integral()))
print "\nentries: " + str(nentries) + " noeleaf number: " + str(
noeleaf)
if (analyze_this['MuonTight.PT']):
# normalize
numMuons.Scale(1 / (numMuons.Integral()))
max_upt_per_event.Scale(1 / (max_upt_per_event.Integral()))
min_upt_per_event.Scale(1 / (min_upt_per_event.Integral()))
print "\nentries: " + str(nentries) + " nouleaf number: " + str(
nouleaf)
if (analyze_this['MissingET.MET']):
# normalize
MET.Scale(1 / (MET.Integral()))
if (analyze_this['MT (NON-LEAF)']):
#normalize
MT.Scale(1 / (MT.Integral()))
if (analyze_this['HT (NON-LEAF)']):
#normalize
HT.Scale(1 / (HT.Integral()))
if (analyze_this['DELTA PHI (NON-LEAF)']):
#normalize
DPHI_metlep.Scale(1 / (DPHI_metlep.Integral()))
DPHI_metjet.Scale(1 / (DPHI_metjet.Integral()))
if (analyze_this['DELTA R (NON-LEAF)']):
#normalize
DR.Scale(1 / (DR.Integral()))
print ""
print "\nDone!\n"
numJets.Write(eventtype + "numJets")
max_jetpt_per_event.Write(eventtype + "max_jetpt_per_event")
min_jetpt_per_event.Write(eventtype + "min_jetpt_per_event")
loose.Write(eventtype + "loose")
medium.Write(eventtype + "medium")
tight.Write(eventtype + "tight")
numElectrons.Write(eventtype + "numElectrons")
max_ept_per_event.Write(eventtype + "max_ept_per_event")
min_ept_per_event.Write(eventtype + "min_ept_per_event")
numMuons.Write(eventtype + "numMuons")
max_upt_per_event.Write(eventtype + "max_upt_per_event")
min_upt_per_event.Write(eventtype + "min_upt_per_event")
MET.Write(eventtype + "MET")
MT.Write(eventtype + "MT")
HT.Write(eventtype + "HT")
DPHI_metlep.Write(eventtype + "dphi_metlep")
DPHI_metjet.Write(eventtype + "dphi_metjet")
DR.Write(eventtype + "deltaR")
def do_analysis(f, eventtype, analyze_this, outfile):
# get trees from files
t = f.Get("Delphes")
# get number of entries
nentries = t.GetEntries()
# initialize everything here before filling histograms
if (analyze_this['Jet.PT']):
print "\nInitializing Jet.PT...\n"
# create the histograms
numJets = Hist(NBINS,
NLO,
NHI,
title='numJets ' + eventtype,
legendstyle='L')
# interesting values to plot
max_jetpt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Max JetPT/Event ' + eventtype,
legendstyle='L')
min_jetpt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Min JetPT/Event ' + eventtype,
legendstyle='L')
else:
print "Skipped Jet.PT"
if (analyze_this['Jet.BTag']):
print "Initializing Jet.BTag...\n"
# create the histograms
loose = Hist(NBINS,
NLO,
NHI,
title='loose ' + eventtype,
legendstyle='L')
medium = Hist(NBINS,
NLO,
NHI,
title='medium ' + eventtype,
legendstyle='L')
tight = Hist(NBINS,
NLO,
NHI,
title='tight ' + eventtype,
legendstyle='L')
else:
print "Skipped Jet.BTag"
if (analyze_this['Electron.PT']):
print "Initializing Electron.PT...\n"
# create the histograms
numElectrons = Hist(NBINS,
NLO,
NHI,
title='numElectrons ' + eventtype,
legendstyle='L')
# interesting values to plot
max_ept_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Max ElectronPT/Event ' + eventtype,
legendstyle='L')
min_ept_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Min ElectronPT/Event ' + eventtype,
legendstyle='L')
# initialize any variable-specific constants here:
# counter for no electrons
noeleaf = 0
else:
print "Skipped Electron.PT"
if (analyze_this['MuonTight.PT']):
print "Initializing MuonTight.PT...\n"
# create the histograms
numMuons = Hist(NBINS,
NLO,
NHI,
title='numMuons ' + eventtype,
legendstyle='L')
# interesting values to plot
max_upt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Max MuonPT/Event ' + eventtype,
legendstyle='L')
min_upt_per_event = Hist(PT_NBINS,
PT_NLO,
PT_NHI,
title='Min MuonPT/Event ' + eventtype,
legendstyle='L')
# initialize any variable-specific constants here:
# counter for no electrons
nouleaf = 0
else:
print "Skipped MuonTight.PT"
if (analyze_this['MissingET.MET']):
print "Initializing MissingET.MET...\n"
# create the histograms
MET = Hist(MET_NBINS,
MET_NLO,
MET_NHI,
title='MET ' + eventtype,
legendstyle='L')
else:
print "Skipped MissingET.MET"
if (analyze_this['MT (NON-LEAF)']):
print "Initializing MT...\n"
# create the histograms
MT = Hist(MT_NBINS,
MT_NLO,
MT_NHI,
title='MT ' + eventtype,
legendstyle='L')
else:
print "Skipped HT"
if (analyze_this['HT (NON-LEAF)']):
print "Initializing HT...\n"
# create the histograms
HT = Hist(HT_NBINS,
HT_NLO,
HT_NHI,
title='HT ' + eventtype,
legendstyle='L')
else:
print "Skipped HT"
# Now fill histograms
print "\nFilling histograms...\n"
# get float version of num entries to normalize below; subtract 1 to get
# actual integral value of hist
norm = float(nentries - 1)
for e in range(nentries):
entry = t.GetEntry(e)
# to check whether each entry is electron or muon
is_electron = False
is_muon = False
e_maxpt = 0
e_maxpt_phi = 0
u_maxpt = 0
u_maxpt_phi = 0
if (analyze_this['Jet.PT']):
# define leaves
var = 'Jet.PT'
leaf = t.GetLeaf(var)
# analyze with Jet.PT because HT is sum of Jet.PTs
if (analyze_this['HT (NON-LEAF)']):
HTfill = True
else:
HTfill = False
fill_JetPT_hist(t, leaf, entry, numJets, min_jetpt_per_event,
max_jetpt_per_event, HTfill, HT)
if (analyze_this['Jet.BTag']):
# define leaves
var = "Jet.BTag"
leaf = t.GetLeaf(var)
fill_JetBTag_hist(t, leaf, entry, loose, medium, tight)
if (analyze_this['Electron.PT']):
# define leaves
var = "Electron.PT"
leaf = t.GetLeaf(var)
phileaf = t.GetLeaf('Electron.Phi')
# returns phi of max pt for entry
(e_maxpt,
e_maxpt_phi) = fill_Electron_hist(t, leaf, entry, numElectrons,
min_ept_per_event,
max_ept_per_event, phileaf)
if (leaf.GetLen() == 0):
noeleaf += 1
e_maxpt = 0
e_maxpt_phi = 0
else:
is_electron = True
if (analyze_this['MuonTight.PT']):
# define leaves
var = "MuonTight.PT"
leaf = t.GetLeaf(var)
phileaf = t.GetLeaf('MuonTight.Phi')
(u_maxpt, u_maxpt_phi) = fill_Muon_hist(t, leaf, entry, numMuons,
min_upt_per_event,
max_upt_per_event, phileaf)
if leaf.GetLen() == 0:
nouleaf += 1
u_maxpt = 0
u_maxpt_phi = 0
else:
is_muon = True
if (analyze_this['MissingET.MET']):
# define leaves
var = "MissingET.MET"
leaf = t.GetLeaf(var)
phileaf = t.GetLeaf('MissingET.Phi')
(met, metphi) = fill_MET_hist(t, leaf, entry, MET, phileaf)
if (analyze_this['MT (NON-LEAF)']):
#print "ok got here"
#print "here ",e_maxpt, e_maxpt_phi, u_maxpt, u_maxpt_phi, met, metphi
mt_val = get_mt(e_maxpt, e_maxpt_phi, u_maxpt, u_maxpt_phi, met,
metphi)
if mt_val == 0:
MT.Fill(INVALID)
else:
MT.Fill(mt_val)
#print mt_val
if (analyze_this['Jet.PT']):
# normalize
numJets.Scale(1 / norm)
max_jetpt_per_event.Scale(1 / norm)
min_jetpt_per_event.Scale(1 / norm)
if (analyze_this['Jet.BTag']):
# normalize
tight.Scale(1 / norm)
medium.Scale(1 / norm)
loose.Scale(1 / norm)
if (analyze_this['Electron.PT']):
# normalize
numElectrons.Scale(1 / norm)
max_ept_per_event.Scale(1 / norm)
min_ept_per_event.Scale(1 / norm)
print "\nentries: " + str(nentries) + " noeleaf number: " + str(
noeleaf)
if (analyze_this['MuonTight.PT']):
# normalize
numMuons.Scale(1 / norm)
max_upt_per_event.Scale(1 / norm)
min_upt_per_event.Scale(1 / norm)
print "\nentries: " + str(nentries) + " nouleaf number: " + str(
nouleaf)
if (analyze_this['MissingET.MET']):
# normalize
MET.Scale(1 / norm)
if (analyze_this['MT (NON-LEAF)']):
#normalize
MT.Scale(1 / norm)
if (analyze_this['HT (NON-LEAF)']):
#normalize
HT.Scale(1 / norm)
print ""
print "\nDone!\n"
numJets.Write(eventtype + "numJets")
max_jetpt_per_event.Write(eventtype + "max_jetpt_per_event")
min_jetpt_per_event.Write(eventtype + "min_jetpt_per_event")
loose.Write(eventtype + "loose")
medium.Write(eventtype + "medium")
tight.Write(eventtype + "tight")
numElectrons.Write(eventtype + "numElectrons")
max_ept_per_event.Write(eventtype + "max_ept_per_event")
min_ept_per_event.Write(eventtype + "min_ept_per_event")
numMuons.Write(eventtype + "numMuons")
max_upt_per_event.Write(eventtype + "max_upt_per_event")
min_upt_per_event.Write(eventtype + "min_upt_per_event")
MET.Write(eventtype + "MET")
MT.Write(eventtype + "MT")
HT.Write(eventtype + "HT")
def __return_histogram(self,
d_hist_info,
ignoreUnderflow=True,
useQCDControl=False,
useQCDSystematicControl=False):
'''
Takes basic histogram info and returns histo.
Maybe this can move to ROOT_utilities?
'''
from rootpy.io.file import File
from rootpy.plotting import Hist
from dps.utils.hist_utilities import fix_overflow
f = d_hist_info['input_file']
tree = d_hist_info['tree']
qcd_tree = d_hist_info["qcd_control_region"]
qcd_tree_for_normalisation = d_hist_info["qcd_normalisation_region"]
var = d_hist_info['branch']
bins = d_hist_info['bin_edges']
lumi_scale = d_hist_info['lumi_scale']
scale = d_hist_info['scale']
weights = d_hist_info['weight_branches']
selection = d_hist_info['selection']
if useQCDControl:
# replace SR tree with CR tree
if useQCDSystematicControl:
tree = qcd_tree_for_normalisation
else:
tree = qcd_tree
# Remove the Lepton reweighting for the datadriven qcd (SF not derived for unisolated leptons)
for weight in weights:
if 'Electron' in weight: weights.remove(weight)
elif 'Muon' in weight: weights.remove(weight)
weights = "*".join(weights)
# Selection will return a weight 0 or 1 depending on whether event passes selection
weights_and_selection = '( {0} ) * ( {1} )'.format(weights, selection)
scale *= lumi_scale
root_file = File(f)
root_tree = root_file.Get(tree)
root_histogram = Hist(bins)
# Draw histogram of var for selection into root_histogram
root_tree.Draw(var,
selection=weights_and_selection,
hist=root_histogram)
root_histogram.Scale(scale)
# When a tree is filled with a dummy variable, it will end up in the underflow, so ignore it
if ignoreUnderflow:
root_histogram.SetBinContent(0, 0)
root_histogram.SetBinError(0, 0)
# Fix overflow (Moves entries from overflow bin into last bin i.e. last bin not |..| but |--> )
root_histogram = fix_overflow(root_histogram)
root_file.Close()
return root_histogram
def plot_cmssw_charge_occupancy_variations(REGION, useFullDist=True):
'''
Data highOcc vs SCD vs SCD Po(N)
'''
make_folder_if_not_exists('plots/InputChargePoissonMatching/')
OCC = REGION_DETAILS[REGION]['Occ_Data']
hs_to_plot = []
rs_to_plot = []
occupancies_to_test = []
colors = ['blue', 'red', 'darkgreen', 'magenta']
if useFullDist:
f_hist = 'input/landau_scd_290118_orig.root'
occupancies_to_test = [OCC * 10, OCC * 20, OCC * 50, OCC * 100]
else:
f_hist = 'input/landau_scd_290118_cut.root'
occupancies_to_test = [OCC * 5, OCC * 10, OCC * 20, OCC * 50]
with root_open(f_hist) as f:
h = asrootpy(f.Get(REGION).Clone())
h.SetDirectory(0)
l_edges = list(h.xedges())
# with root_open('input/landau_lowPUTracks_290118_orig.root') as f:
# h_data_PU0 = asrootpy(f.Get(REGION).Clone())
# h_data_PU0.SetDirectory(0)
# h_data_PU0.Scale(1 /h_data_PU0.integral(xbin1=21,xbin2=200))
# hs_to_plot.append({
# 'hist' : h_data_PU0,
# 'label' : 'lowPU Strips from Tracks',
# # 'color' : '0.5',
# 'color' : 'grey',
# 'type' : 'Data'
# })
# with root_open('input/landau_lowPUClusters_290118_orig.root') as f:
# h_data_lowOcc = asrootpy(f.Get(REGION).Clone())
# h_data_lowOcc.SetDirectory(0)
# h_data_lowOcc.Scale(1 /h_data_lowOcc.integral(xbin1=21,xbin2=200))
# hs_to_plot.append({
# 'hist' : h_data_lowOcc,
# 'label' : 'lowOcc Strips from Clusters',
# # 'color' : '0',
# 'color' : 'brown',
# 'type' : 'Data'
# })
with root_open(
'input/landau_clusterData_010218_VFPFix_True_orig.root') as f:
h_data_highOcc = asrootpy(f.Get(REGION).Clone())
h_data_highOcc.SetDirectory(0)
h_data_highOcc.Scale(1 / h_data_highOcc.integral(xbin1=21, xbin2=200))
hs_to_plot.append({
'hist': h_data_highOcc,
'label': 'highOcc Strips from Clusters',
# 'color' : '0',
'color': 'black',
'type': 'Data'
})
hist_scd = Hist(l_edges)
h_tests = []
for occ, col in zip(occupancies_to_test, colors):
h_tmp = {
'occ': occ,
'hist': Hist(l_edges),
'color': col,
}
h_tests.append(h_tmp)
i = 0
while i < 250000:
v = return_strip_charge_from_Poisson(h,
OCC,
add_noise=False,
add_truncation=True)
hist_scd.Fill(v)
for h_test in h_tests:
v_occ = return_strip_charge_from_Poisson(h,
h_test['occ'],
add_noise=False,
add_truncation=True,
cut_charge=True)
if not v_occ < 10000: h_test['hist'].Fill(v_occ)
i = i + 1
# Normalising between 10000-100000
hist_scd.Scale(1 / hist_scd.integral(xbin1=21, xbin2=200))
for h_test in h_tests:
h_test['hist'].Scale(1 / h_test['hist'].integral(xbin1=21, xbin2=200))
scd = ''
if useFullDist:
scd = 'SCD'
else:
scd = 'Cut SCD'
r_scd = h_data_highOcc.Clone()
r_scd.SetDirectory(0)
r_scd.Divide(hist_scd)
hs_to_plot.append({
'hist':
hist_scd,
'label':
'{SCD} sampled Po({OCC})'.format(SCD=scd, OCC=OCC),
'color':
'black',
'type':
'SCD'
})
rs_to_plot.append({
'hist': r_scd,
'label': '',
'color': 'black',
'type': 'Ratio'
})
for h_test in h_tests:
r = h_data_highOcc.Clone()
r.SetDirectory(0)
r.Divide(h_test['hist'])
hs_to_plot.append({
'hist':
h_test['hist'],
'label':
'{SCD} sampled Po({OCC})'.format(SCD=scd, OCC=h_test['occ']),
'color':
h_test['color'],
'line':
'solid',
'type':
'CMSSW'
})
rs_to_plot.append({
'hist': r,
'label': '',
'color': h_test['color'],
'type': 'Ratio'
})
fig = plt.figure()
fig.suptitle(
"Charge Deposition from Simulation using Sampling from {SCD} distribution"
.format(SCD=scd),
fontsize=14,
fontweight='bold')
gs = gridspec.GridSpec(2,
1,
height_ratios=[5, 1],
wspace=0.025,
hspace=0.025)
ax = plt.subplot(gs[0])
plt.title(REGION.replace("_", " ") + " normalised 10,000-70,000",
loc='right')
for h_info in hs_to_plot:
if 'Data' in h_info['type']:
rplt.hist(
h_info['hist'],
label=h_info['label'],
color=h_info['color'],
alpha=0.35,
fill=True,
zorder=0,
)
if 'SCD' in h_info['type']:
rplt.errorbar(
h_info['hist'],
label=h_info['label'],
markerfacecolor=h_info['color'],
markersize=3,
xerr=False,
yerr=False,
elinewidth=0,
emptybins=False,
zorder=len(hs_to_plot),
)
if 'CMSSW' in h_info['type']:
rplt.step(h_info['hist'],
label=h_info['label'],
color=h_info['color'],
linestyle=h_info['line'])
ax.set_ylim([0.0001, 1.])
# ax.set_xlim([10000,70000])
ax.set_xlim([0.1, 70000])
ax.set_yscale("log", nonposy='clip')
ax.set_ylabel('N')
# ax.set_xlabel('Charge (e)')
plt.setp(ax.get_xticklabels(), visible=False)
leg = ax.legend(loc='upper right', numpoints=1, prop={'size': 10}, ncol=2)
leg.draw_frame(False)
ax_ratio = plt.subplot(gs[1])
ax_ratio.axhline(1, color='black')
for r_info in rs_to_plot:
rplt.errorbar(
r_info['hist'],
label=r_info['label'],
markerfacecolor=r_info['color'],
markersize=6,
markeredgewidth=0,
xerr=False,
yerr=False,
elinewidth=0,
emptybins=False,
axes=ax_ratio,
)
ax_ratio.set_ylim([0, 2])
ax_ratio.set_xlim([0.1, 70000])
# ax_ratio.set_xlim([10000,70000])
ax_ratio.set_xlabel('Charge deposited on APV in a bx(e) ')
ax_ratio.set_ylabel(
r'$\frac{\mathrm{Data\ High\ Occ}}{\mathrm{SCD\ Sampling}}$')
gs.tight_layout(fig, rect=[0, 0.03, 1, 0.95])
filename = 'CMSSWSimChargeFrom{SCD}_'.format(
SCD=scd.replace(" ", "")) + REGION
fig.savefig('plots/InputChargePoissonMatching/' + filename + '.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
h_t2 = Hist(nBins, 0, nBins, title=t2Name)
h_t3 = Hist(nBins, 0, nBins, title=t3Name)
h_t4 = Hist(nBins, 0, nBins, title=t4Name)
h_data = Hist(nBins, 0, nBins, title='data')
if useTemplatesFromFile:
templates = getTemplatesFromFile()
for bin in range(1, nBins + 1):
h_t1.SetBinContent(bin, templates[0][bin - 1])
h_t2.SetBinContent(bin, templates[1][bin - 1])
h_t3.SetBinContent(bin, templates[2][bin - 1])
h_t4.SetBinContent(bin, templates[3][bin - 1])
pass
h_t1.Scale(absolute_eta_initialValues[t1Name][whichBinFromFile][0])
h_t2.Scale(absolute_eta_initialValues[t2Name][whichBinFromFile][0])
h_t3.Scale(absolute_eta_initialValues[t3Name][whichBinFromFile][0])
h_t4.Scale(absolute_eta_initialValues[t4Name][whichBinFromFile][0])
else:
# Fill the histograms
h_t1Shape.SetBinContent(1, 20)
h_t1Shape.SetBinContent(2, 20)
h_t1Shape.SetBinContent(3, 20)
h_t1Shape.SetBinContent(4, 50)
h_t1Shape.SetBinContent(5, 50)
h_t1Shape.SetBinContent(6, 100)
h_t1Shape.SetBinContent(7, 100)
h_t1Shape.SetBinContent(8, 50)
h_t1Shape.SetBinContent(9, 50)
h_t1Shape.SetBinContent(10, 40)
def makeDiscr(train_discr_dict, discr_dict, outfile, xtitle="discriminator"):
c = ROOT.TCanvas("c", "c", 800, 500)
ROOT.gStyle.SetOptStat(0)
ROOT.gPad.SetMargin(0.15, 0.1, 0.2, 0.1)
#ROOT.gPad.SetLogy(1)
#ROOT.gPad.SetGrid(1,1)
ROOT.gStyle.SetGridColor(17)
l = TLegend(0.17, 0.75, 0.88, 0.88)
l.SetTextSize(0.055)
l.SetBorderSize(0)
l.SetFillStyle(0)
l.SetNColumns(2)
colors = [2, 1, 4, ROOT.kCyan + 2]
counter = 0
for leg, discr in train_discr_dict.iteritems():
a = Hist(30, 0, 1)
#fill_hist_with_ndarray(a, discr)
a.fill_array(discr)
a.SetLineColor(colors[counter])
a.SetLineWidth(2)
a.GetXaxis().SetTitle(xtitle)
a.GetXaxis().SetLabelSize(0.05)
a.GetXaxis().SetTitleSize(0.06)
a.GetXaxis().SetTitleOffset(1.45)
a.GetYaxis().SetTitle("a.u.")
a.GetYaxis().SetTickSize(0)
a.GetYaxis().SetLabelSize(0)
a.GetYaxis().SetTitleSize(0.06)
a.GetYaxis().SetTitleOffset(0.9)
a.Scale(1. / a.Integral())
#a.GetYaxis().SetRangeUser(0.00001,100)
a.GetYaxis().SetRangeUser(0, 0.9)
if counter == 0: a.draw("hist")
else: a.draw("same hist")
l.AddEntry(a, leg, "l")
counter += 1
counter = 0
for leg, discr in discr_dict.iteritems():
a = Hist(30, 0, 1)
#fill_hist_with_ndarray(a, discr)
a.fill_array(discr)
a.SetLineColor(colors[counter])
a.SetMarkerColor(colors[counter])
a.SetMarkerStyle(34)
a.SetMarkerSize(1.8)
a.SetLineWidth(2)
a.GetXaxis().SetTitle(xtitle)
a.GetXaxis().SetLabelSize(0.05)
a.GetXaxis().SetTitleSize(0.06)
a.GetXaxis().SetTitleOffset(1.45)
a.GetYaxis().SetTitle("a.u.")
a.GetYaxis().SetTickSize(0)
a.GetYaxis().SetLabelSize(0)
a.GetYaxis().SetTitleSize(0.06)
a.GetYaxis().SetTitleOffset(0.9)
a.Scale(1. / a.Integral())
#a.GetYaxis().SetRangeUser(0.00001,100)
a.GetYaxis().SetRangeUser(0, 0.4)
a.draw("same p X0")
l.AddEntry(a, leg, "p")
counter += 1
# counter = 0
# for leg,discr in train_discr_dict.iteritems():
# d = Hist(30, 0, 1)
# d.fill_array(discr)
# d.SetLineColor(colors[counter])
# d.SetLineWidth(2)
# l.AddEntry(d,leg,"l")
#
# b = Hist(30, 0, 1)
# d.fill_array(discr_dict[leg.split(" ")[0] + " test"])
# b.SetLineColor(colors[counter])
# b.SetMarkerColor(colors[counter])
# b.SetMarkerStyle(34)
# b.SetMarkerSize(1.8)
# b.SetLineWidth(2)
# l.AddEntry(b,leg,"p")
# counter += 1
l.Draw("same")
c.SaveAs(outfile)
def run_landaus(title, folder_path, d_mip_variables, data_charge_inputs):
'''
Plot any landaus
'''
print "- - - - - - - - - - - - - - - - - - -"
print "Plotting Data Simulation Comparisons"
print "- - - - - - - - - - - - - - - - - - -"
########################################################################################################################
### Fill ROOTPY Hists
########################################################################################################################
charge_deposited_hist = Hist(data_charge_inputs['edges'])
for v in d_mip_variables['q_Deposited_e']:
charge_deposited_hist.Fill(v)
charge_deposited_hist.Scale(1 / charge_deposited_hist.Integral())
unweighted_charge_deposited_hist = Hist(data_charge_inputs['edges'])
for v in d_mip_variables['q_ClusterDeposited_e']:
unweighted_charge_deposited_hist.Fill(v)
unweighted_charge_deposited_hist.Scale(
1 / unweighted_charge_deposited_hist.Integral())
charge_read_hist = Hist(data_charge_inputs['edges'])
for v in d_mip_variables['q_Read_e']:
charge_read_hist.Fill(v)
charge_read_hist.Scale(1 / charge_read_hist.Integral())
charge_weight_hist = Hist(data_charge_inputs['edges_stripClusterFraction'])
for v in d_mip_variables['q_Weight_e']:
charge_weight_hist.Fill(v)
charge_weight_hist.Scale(1 / charge_weight_hist.Integral())
########################################################################################################################
### Charge Weighting
########################################################################################################################
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
rplt.hist(
data_charge_inputs['hist_stripClusterFraction_normed'],
histtype='step',
facecolor='red',
edgecolor='red',
fill=True,
alpha=0.5,
label='Strip-Cluster Distribution',
)
rplt.hist(
charge_weight_hist,
histtype='step',
facecolor='blue',
edgecolor='blue',
fill=True,
alpha=0.5,
label='Scaling Distribution applied to Simulated Charge Deposition ',
)
ax.set_ylim([0, 0.1])
ax.set_xlabel('Charge [e]')
ax.set_ylabel('N')
fig.suptitle('Strip-Cluster Charge Distribution',
fontsize=14,
fontweight='bold')
plt.title(title, loc='right')
leg = plt.legend(loc='best')
leg.draw_frame(False)
fig.savefig(folder_path + 'MC_Data_ChargeWeighting_Norm.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
# ########################################################################################################################
# ### Data STRIP vs Cluster Charge
# ########################################################################################################################
# fig = plt.figure()
# ax = fig.add_subplot(1, 1, 1)
# rplt.hist(
# data_charge_inputs['hist_clusterCharge'],
# histtype='step',
# facecolor='orange',
# edgecolor='orange',
# fill = True,
# alpha=0.5,
# label='Cluster Charge Distribution in Data',
# )
# rplt.hist(
# data_charge_inputs['hist_stripCharge'],
# histtype='step',
# facecolor='red',
# edgecolor='red',
# fill = True,
# alpha=0.5,
# label='Strip Charge Distribution in Data',
# )
# # ax.set_ylim([0,0.15])
# ax.set_xlabel('Charge [e]')
# ax.set_ylabel('N')
# fig.suptitle('Strip v Cluster Charge Deposition in Data', fontsize=14, fontweight='bold')
# plt.title(title, loc='right')
# leg = plt.legend(loc='best')
# leg.draw_frame(False)
# fig.savefig(folder_path+'Data_StripCluster.pdf', bbox_inches='tight')
# fig.clf()
# plt.close()
# gc.collect()
########################################################################################################################
### Data STRIP vs Cluster Charge
########################################################################################################################
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
rplt.hist(
data_charge_inputs['hist_clusterCharge_normed'],
histtype='step',
facecolor='orange',
edgecolor='orange',
fill=True,
alpha=0.5,
label='Cluster Charge Distribution in Data',
)
rplt.hist(
data_charge_inputs['hist_stripCharge_normed'],
histtype='step',
facecolor='red',
edgecolor='red',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Data',
)
ax.set_ylim([0, 0.15])
ax.set_xlabel('Charge [e]')
ax.set_ylabel('N')
fig.suptitle('Strip v Cluster Charge in Data',
fontsize=14,
fontweight='bold')
plt.title(title, loc='right')
leg = plt.legend(loc='best')
leg.draw_frame(False)
fig.savefig(folder_path + 'Data_StripCluster_Norm.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
########################################################################################################################
### Simulation STRIP vs Cluster Charge
########################################################################################################################
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
rplt.hist(
unweighted_charge_deposited_hist,
histtype='step',
facecolor='green',
edgecolor='green',
fill=True,
alpha=0.5,
label='Cluster Charge Distribution in Simulation',
)
rplt.hist(
charge_deposited_hist,
histtype='step',
facecolor='blue',
edgecolor='blue',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Simulation',
)
ax.set_ylim([0, 0.1])
ax.set_xlabel('Charge [e]')
ax.set_ylabel('N')
fig.suptitle('Strip v Cluster Charge Deposition in Simulation',
fontsize=14,
fontweight='bold')
plt.title(title, loc='right')
leg = plt.legend(loc='best')
leg.draw_frame(False)
fig.savefig(folder_path + 'MC_ChargeDeposition_Norm.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
########################################################################################################################
### Simulation STRIP vs Cluster Charge. Input vs Output Distirbutions
########################################################################################################################
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
rplt.hist(
charge_deposited_hist,
histtype='step',
facecolor='blue',
edgecolor='blue',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Simulation',
)
rplt.hist(
charge_read_hist,
histtype='step',
facecolor='purple',
edgecolor='purple',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Simulation from APV Gain',
)
ax.set_ylim([0, 0.1])
ax.set_xlabel('Charge [e]')
ax.set_ylabel('N')
fig.suptitle(
'Simulated Charge Deposition Comparison with Readout from Gain',
fontsize=14,
fontweight='bold')
plt.title(title, loc='right')
leg = plt.legend(loc='best')
leg.draw_frame(False)
fig.savefig(folder_path + 'MC_ChargeDepositionFromGain_Norm.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
########################################################################################################################
### Strip Charge Deposition From Data vs MC
########################################################################################################################
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
rplt.hist(
charge_read_hist,
histtype='step',
facecolor='blue',
edgecolor='blue',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Simulation',
)
rplt.hist(
data_charge_inputs['hist_stripCharge_normed'],
histtype='step',
facecolor='red',
edgecolor='red',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Data',
)
# plt.axvline(x=7500, linewidth=1, color='r', label = 'Min Threshold')
# plt.axvline(x=1500, linewidth=1, color='g', label = 'Min Threshold')
# plt.axvline(x=3000, linewidth=1, color='b', label = 'Min Threshold')
# plt.axvline(x=2000, linewidth=1, color='orange', label = 'Min Threshold')
ax.set_ylim([0, 0.1])
ax.set_xlabel('Charge [e]')
ax.set_ylabel('N')
fig.suptitle('Strip Charge Deposition Data vs Simulation',
fontsize=14,
fontweight='bold')
plt.title(title, loc='right')
leg = plt.legend(loc='best')
leg.draw_frame(False)
fig.savefig(folder_path + 'MC_Data_StripChargeDeposition_Norm.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
########################################################################################################################
### Cluster Charge Deposition From Data vs MC
########################################################################################################################
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
rplt.hist(
data_charge_inputs['hist_clusterCharge_normed'],
histtype='step',
facecolor='orange',
edgecolor='orange',
fill=True,
alpha=0.5,
label='Cluster Charge Distribution in Data',
)
rplt.hist(
unweighted_charge_deposited_hist,
histtype='step',
facecolor='green',
edgecolor='green',
fill=True,
alpha=0.5,
label='Cluster Charge Distribution in Simulation',
)
ax.set_ylim([0, 0.1])
ax.set_xlabel('Charge [e]')
ax.set_ylabel('N')
fig.suptitle('Cluster Charge Deposition Data vs Simulation',
fontsize=14,
fontweight='bold')
plt.title(title, loc='right')
leg = plt.legend(loc='best')
leg.draw_frame(False)
fig.savefig(folder_path + 'MC_Data_ClusterChargeDeposition_Norm.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
# ########################################################################################################################
# ### Cluster Charge Vs Charge Splitting
# ########################################################################################################################
# fig = plt.figure()
# ax = fig.add_subplot(1, 1, 1)
# plt.scatter(
# d_mip_variables['q_ClusterDeposited_e'],
# d_mip_variables['q_Weight_e'],
# )
# ax.set_xlim([0,8000000])
# ax.set_ylim([0,1])
# ax.set_xlabel('Cluster Charge [e]')
# ax.set_ylabel('Strip Charge [e]')
# # ax.set_ylabel('N')
# fig.suptitle('Cluster Charge vs Strip Charge [Simulation]', fontsize=14, fontweight='bold')
# plt.title(title, loc='right')
# # leg = plt.legend(loc='best')
# # leg.draw_frame(False)
# fig.savefig(folder_path+'TEST.pdf', bbox_inches='tight')
# fig.clf()
# plt.close()
# gc.collect()
########################################################################################################################
### All Charge Distributions
########################################################################################################################
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
rplt.hist(
data_charge_inputs['hist_clusterCharge_normed'],
histtype='step',
facecolor='orange',
edgecolor='orange',
fill=True,
alpha=0.5,
label='Cluster Charge Distribution in Data',
)
rplt.hist(
data_charge_inputs['hist_stripCharge_normed'],
histtype='step',
facecolor='red',
edgecolor='red',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Data',
)
rplt.hist(
unweighted_charge_deposited_hist,
histtype='step',
facecolor='blue',
edgecolor='blue',
fill=True,
alpha=0.5,
label='Cluster Charge Distribution in Simulation',
)
rplt.hist(
charge_read_hist,
histtype='step',
facecolor='purple',
edgecolor='purple',
fill=True,
alpha=0.5,
label='Strip Charge Distribution in Simulation from APV Gain',
)
ax.set_ylim([0, 0.05])
ax.set_xlabel('Charge [e]')
ax.set_ylabel('N')
fig.suptitle('Strip and Cluster Distributions in Simulation and Data',
fontsize=14,
fontweight='bold')
plt.title(title, loc='right')
leg = plt.legend(loc='best')
leg.draw_frame(False)
fig.savefig(folder_path + 'MC_Data_ChargeComparison_Norm.pdf',
bbox_inches='tight')
fig.clf()
plt.close()
gc.collect()
return
