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()
def test_init_from_hist(): h = Hist(100, -10, 10) h.FillRandom('gaus') g = Graph(h)
in_file = root_open(f, "READ") out_file_path = f + ".hists" if args.output_folder != '': ensure_dir(args.output_folder) out_file_path = os.path.join(args.output_folder, os.path.basename(f) + ".hists") if (args.doNotOverwrite and os.path.isfile(out_file_path)): continue out_file = root_open(out_file_path, "RECREATE") tree = in_file.get(args.treename) if (args.hists != None and len(args.hists) > 0): out_file.cd() for hist in args.hists: in_file.Get(hist).Write() if args.copy_mbj_cutflow: cf = in_file.Get('cut_flow') cf2 = Hist(1, 0, 1, name='cutflow') cf2.Sumw2() cf2.SetEntries(cf.GetBinContent(1)) cf2.SetBinContent(1, cf.GetBinContent(2)) cf2.SetBinError( 1, np.sqrt(cf.GetBinContent(1)) * cf.GetBinContent(2) / cf.GetBinContent(1)) allDir = os.path.join(args.outdir, 'all') out_file.mkdir(allDir, recurse=True) try: out_file.cd(allDir) except: pass cf2.Write()
def test_poisson_errors(): h = Hist(20, -3, 3) h.FillRandom('gaus') g = h.poisson_errors()
def test_width(): h = Hist([1, 2, 4, 8]) assert_equal(list(h.xwidth()), [1, 2, 4]) assert_equal(list(h.xwidth(overflow=True)), [float('inf'), 1, 2, 4, float('inf')])
''' Created on 8 Nov 2012 @author: kreczko ''' # @BROKEN from dps.utils.Fitting import CurveFit import numpy as np from rootpy.plotting import Hist import rootpy.plotting.root2matplotlib as rplt import matplotlib.pyplot as plt # create normal distributions mu1, sigma1 = 100, 15 x1 = mu1 + sigma1 * np.random.randn(10000) h1 = Hist(100, 40, 200) map(h1.Fill, x1) hist_fit, bin_centres = CurveFit.fit(h1, 'gaus', [10000,mu1,sigma1]) fig = plt.figure(figsize=(16, 10), dpi=100, facecolor='white') rplt.hist(h1, label=r'data', alpha = 0.7) plt.plot(bin_centres, hist_fit, label='Fitted data') plt.legend() plt.savefig('plots/CurveFit.png')
def test_slice_assign_bad(): hist = Hist(10, 0, 1) hist[:] = range(len(hist) + 1)
#!/usr/bin/env python import numpy as np from rootpy.plotting import Hist, HistStack import rootpy.root2matplotlib as rplt import matplotlib.pyplot as plt # create normal distributions mu1, mu2, sigma = 100, 140, 15 x1 = mu1 + sigma * np.random.randn(10000) x2 = mu2 + sigma * np.random.randn(10000) # create histograms h1 = Hist(100, 40, 160) h2 = Hist(100, 40, 160) # fill the histograms with our distributions map(h1.Fill, x1) map(h2.Fill, x2) # normalize the histograms h1 /= h1.Integral() h2 /= h2.Integral() # set visual attributes h1.SetFillStyle('solid') h1.SetFillColor('green') h1.SetLineColor('green') h2.SetFillStyle('solid') h2.SetFillColor('red') h2.SetLineColor('red')
print delimeter print ' - time length: ' + str( sci_trigger_r_obj.gps_time_length) + ' seconds' print ' - bin width: ' + str(args.bw) + ' seconds' print ' - number of bins: ' + str(nbins) print delimeter ROOT.gStyle.SetOptStat(0) gps_time_span = '%d:%d => %d:%d' % ( int(sci_trigger_r_obj.start_week), int(sci_trigger_r_obj.start_second), int(sci_trigger_r_obj.stop_week), int(sci_trigger_r_obj.stop_second)) trigger_hist = Hist(nbins, 0, sci_trigger_r_obj.gps_time_length, type='D', name='trigger_hist', title='trigger: { ' + gps_time_span + ' }') modules_hist = [ Hist(nbins, 0, sci_trigger_r_obj.gps_time_length, type='D', name='module_hist_' + str(i), title='module CT_' + str(i) + ': { ' + gps_time_span + ' }') for i in xrange(1, 26) ] trigger_hist.SetDirectory(None) trigger_hist.SetMinimum(0) trigger_hist.color = 'red' trigger_hist.markerstyle = 3
matplotlib.use('Agg') # rootpy fod matplotlib import rootpy.plotting.root2matplotlib as rplt import matplotlib.pyplot as plt #pyroot import ROOT ## --file name, Tree name file_name = "ntuple.root" tree_name = "mytree" ## --Hist define h1 = Hist(200, 82, 100) ## --open file and read tree root_file = ROOT.TFile.Open(file_name,'read') tree = root_file.Get(tree_name) ## --start eve. loop for Nevent, event in enumerate(tree): print(Nevent, event.signal) h1.Fill(event.signal) ## --close file root_file.Close() ## --set parametres for plotting
def main(): print("Number of arguments: ", len(sys.argv), "arguments.") filename = sys.argv[1] print("Input file: {}".format(filename)) jetBinBorders = [5, 10, 20, 30, 40, 60, 80, 100, 150, 500] jetPtBins = [(a, b) for a, b in zip(jetBinBorders, jetBinBorders[1:])] JetPtCenter = [7.5, 15, 25, 35, 50, 70, 90, 125, 325] JetPtError = [2.5, 5, 5, 5, 10, 10, 10, 25, 175] Njets = len(jetBinBorders) - 1 Njets = 9 f = root_open(filename, "read") if len(sys.argv) > 2: filename_test = sys.argv[2] f_test = root_open(filename_test) print("Open {} for test data".format(filename_test)) else: f_test = root_open(filename) if len(sys.argv) < 4: f_data = None else: filename_data = sys.argv[3] f_data = root_open(filename_data) if len(sys.argv) > 4: if sys.argv[4] == "MB": do_mb = True do_triggered = False elif sys.argv[4] == "Triggered": do_mb = False do_triggered = True else: do_mb = False do_triggered = False nR = 3 iFinder = 0 iMCFinder = iFinder + nR * 2 base_folder = "AliJJetJtTask/AliJJetJtHistManager" base_folder_trig = "AliJJetJtTask_kEMCEJE/AliJJetJtHistManager" base_folder_MC = "AliJJetJtTask/AliJJetJtMCHistManager" if f_data: numberJetsDataMB = get_numbers(f_data, base_folder, "JetPtBin", iFinder, Njets) numberJetsDataTriggered = get_numbers(f_data, base_folder_trig, "JetPtBin", iFinder, Njets) hTrackJtDataMB = get_hists(f_data, base_folder, "JetConeJtWeightBin", iFinder, Njets) hTrackJtDataTriggered = get_hists(f_data, base_folder_trig, "JetConeJtWeightBin", iFinder, Njets) hTrackJt2DDataMB = get_hists(f_data, base_folder, "JtWeight2D", iFinder) hTrackJt2DDataTriggered = get_hists(f_data, base_folder_trig, "JtWeight2D", iFinder) hJetPtDataMBCoarse = Hist(jetBinBorders) for n, i in zip(numberJetsDataMB, range(1, Njets + 1)): hJetPtDataMBCoarse.SetBinContent(i, n) hJetPtDataTriggeredCoarse = Hist(jetBinBorders) for n, i in zip(numberJetsDataTriggered, range(1, Njets + 1)): hJetPtDataTriggeredCoarse.SetBinContent(i, n) hJetPtDataMB = get_hists(f_data, base_folder, "JetPt", iFinder) hJetPtDataTriggered = get_hists(f_data, base_folder_trig, "JetPt", iFinder) # Get Background distributions hBgJtDataMB = get_hists(f_data, base_folder, "BgJtWeightBin", iFinder, Njets) hBgJtDataTriggered = get_hists(f_data, base_folder_trig, "BgJtWeightBin", iFinder, Njets) # Get number of background jets hBgNumbersDataMB = get_numbers(f_data, base_folder, "BgTrkNumberBin", iFinder, Njets) hBgNumbersDataTriggered = get_numbers(f_data, base_folder_trig, "BgTrkNumberBin", iFinder, Njets) numberJetsMeas = get_numbers(f_test, base_folder, "JetPtBin", iFinder, Njets) numberJetsTrue = get_numbers(f_test, base_folder, "JetPtBin", iMCFinder, Njets) hTrackJtMeas = get_hists(f_test, base_folder, "JetConeJtWeightBin", iFinder, Njets) hTrackJtTrue = get_hists(f_test, base_folder, "JetConeJtWeightBin", iMCFinder, Njets) numberJetsMeasTrain = get_numbers(f, base_folder, "JetPtBin", iFinder, Njets) hTrackJtCorr2D = get_hists(f, base_folder_MC, "TrackJtCorr2D", iFinder, Njets) hTrackJtMeas2D = get_hists(f_test, base_folder, "JtWeight2D", iFinder) hTrackJtTrue2D = get_hists(f_test, base_folder, "JtWeight2D", iMCFinder) hTrackJtMisses2D = get_hists(f, base_folder_MC, "TrackJtMisses2D", iFinder) hTrackJtFakes2D = get_hists(f, base_folder, "JetConeJtUnfBg2D", iFinder) hTrackJtBg = get_hists(f, base_folder, "BgJtWeightBin", iFinder, Njets) hTrackJtBgNumber = get_numbers(f, base_folder, "BgTrkNumberBin", iFinder, Njets) # Get number of background jets hTrackMatchSuccess = get_hists(f, base_folder_MC, "TrackMatchSuccess", iFinder, Njets) LogBinsJt = [ hTrackJtMeas2D.GetXaxis().GetBinLowEdge(iBin) for iBin in range(1, hTrackJtMeas2D.GetNbinsX() + 2) ] for h in hTrackJtCorr2D: print("{}".format(h.GetTitle())) hJetPtMeas = get_hists(f_test, base_folder, "JetPt", iFinder) hJetPtMeasCoarse = Hist(jetBinBorders) for n, i in zip(numberJetsMeas, range(1, Njets + 1)): hJetPtMeasCoarse.SetBinContent(i, n) hJetPtTrue = get_hists(f_test, base_folder, "JetPt", iMCFinder) hJetPtTrueCoarse = Hist(jetBinBorders) for n, i in zip(numberJetsTrue, range(1, Njets + 1)): hJetPtTrueCoarse.SetBinContent(i, n) LogBinsPt = [ hJetPtTrue.GetXaxis().GetBinLowEdge(iBin) for iBin in range(1, hJetPtTrue.GetNbinsX() + 2) ] hJetPtResponse = get_hists(f, base_folder_MC, "JetPtCorr", iFinder) hJetPtResponseCoarse = get_hists(f, base_folder_MC, "JetPtCorrCoarse", iFinder) if False: TrackJtUnfolder = JtUnfolder.JtUnfolder( "TrackJtUnfolder", jetBinBorders=jetBinBorders, Njets=Njets, Iterations=5, Data=True, ) TrackJtUnfolder.setTrackMatch(hTrackMatchSuccess) # TrackJtUnfolder.drawTrackMatch("TrackMatch",'single') TrackJtUnfolder.setPtBins(LogBinsPt) TrackJtUnfolder.setJtBins(LogBinsJt) TrackJtUnfolder.setJtMeas2D(hTrackJtMeas2D) TrackJtUnfolder.setJtTestMeas2D(hTrackJtMeas2D) TrackJtUnfolder.setJtTrue2D(hTrackJtTrue2D) TrackJtUnfolder.setJtTestTrue2D(hTrackJtTrue2D) TrackJtUnfolder.setMisses2D(hTrackJtMisses2D) TrackJtUnfolder.setFakes2D(hTrackJtFakes2D) TrackJtUnfolder.setJetPtMeas(hJetPtMeas) TrackJtUnfolder.setJetPtTrue(hJetPtTrue) TrackJtUnfolder.setJetPtMeasCoarse(hJetPtMeasCoarse) TrackJtUnfolder.setJetPtTrueCoarse(hJetPtTrueCoarse) TrackJtUnfolder.setJetPtResponse( createResponseInverse(hJetPtMeas, hJetPtResponse)) TrackJtUnfolder.setJetPtResponseCoarse( createResponseInverse(hJetPtMeasCoarse, hJetPtResponseCoarse)) TrackJtUnfolder.setNumberJetsMeas(numberJetsMeas) TrackJtUnfolder.setNumberJetsTrue(numberJetsTrue) TrackJtUnfolder.setNumberJetsTestMeas(numberJetsMeas) TrackJtUnfolder.setNumberJetsTestTrue(numberJetsTrue) TrackJtUnfolder.setNumberJetsMeasTrain(sum(numberJetsMeasTrain)) TrackJtUnfolder.set2Dresponse(hTrackJtCorr2D) TrackJtUnfolder.setJtBackground(hTrackJtBg) TrackJtUnfolder.setJtBackgroundNumbers(hTrackJtBgNumber) TrackJtUnfolder.unfold() TrackJtUnfolder.write_files("dataUnfolded.root") # TrackJtUnfolder.plotResponse() # TrackJtUnfolder.plotJetPt() # TrackJtUnfolder.plotJt("PythiaTest", Rebin=4) return if f_data: split_file = splitext(split(filename_data)[1]) suffix = "_unfolded" if do_mb: suffix += "_MB" if do_triggered: suffix += "_triggered" output_file = "output/" + split_file[0] + suffix + split_file[1] if not os.path.exists('output'): os.makedirs('output') if do_mb: MBDataJtUnfolder = JtUnfolder.JtUnfolder( "MBDataUnfolder", jetBinBorders=jetBinBorders, Njets=Njets, Data=True, Iterations=5, ) MBDataJtUnfolder.setPtBins(LogBinsPt) MBDataJtUnfolder.setJtBins(LogBinsJt) MBDataJtUnfolder.setJtMeas2D(hTrackJt2DDataMB) MBDataJtUnfolder.setJetPtMeas(hJetPtDataMB) MBDataJtUnfolder.setJetPtMeasCoarse(hJetPtDataMBCoarse) MBDataJtUnfolder.setNumberJetsMeas(numberJetsDataMB) MBDataJtUnfolder.setJtBackground(hBgJtDataMB) MBDataJtUnfolder.setJtBackgroundNumbers(hBgNumbersDataMB) MBDataJtUnfolder.setJtTrue2D(hTrackJtTrue2D) MBDataJtUnfolder.setJtTestTrue2D(hTrackJtTrue2D) MBDataJtUnfolder.setFakes2D(hTrackJtFakes2D) MBDataJtUnfolder.setMisses2D(hTrackJtMisses2D) MBDataJtUnfolder.setJetPtResponse( createResponseInverse(hJetPtMeas, hJetPtResponse)) MBDataJtUnfolder.setJetPtResponseCoarse( createResponseInverse(hJetPtMeasCoarse, hJetPtResponseCoarse)) MBDataJtUnfolder.setNumberJetsMeasTrain(sum(numberJetsMeasTrain)) MBDataJtUnfolder.set2Dresponse(hTrackJtCorr2D) MBDataJtUnfolder.unfold() MBDataJtUnfolder.write_files(output_file) # MBDataJtUnfolder.plotJt("MBDataUnfolded", Rebin=4) if do_triggered: TriggeredDataJtUnfolder = JtUnfolder.JtUnfolder( "TriggeredDataUnfolder", jetBinBorders=jetBinBorders, Njets=Njets, Data=True, Iterations=5, ) TriggeredDataJtUnfolder.setPtBins(LogBinsPt) TriggeredDataJtUnfolder.setJtBins(LogBinsJt) TriggeredDataJtUnfolder.setJtMeas2D(hTrackJt2DDataTriggered) TriggeredDataJtUnfolder.setJetPtMeas(hJetPtDataTriggered) TriggeredDataJtUnfolder.setJetPtMeasCoarse( hJetPtDataTriggeredCoarse) TriggeredDataJtUnfolder.setNumberJetsMeas(numberJetsDataTriggered) TriggeredDataJtUnfolder.setJtBackground(hBgJtDataTriggered) TriggeredDataJtUnfolder.setJtBackgroundNumbers( hBgNumbersDataTriggered) TriggeredDataJtUnfolder.setJtTrue2D(hTrackJtTrue2D) TriggeredDataJtUnfolder.setJtTestTrue2D(hTrackJtTrue2D) TriggeredDataJtUnfolder.setFakes2D(hTrackJtFakes2D) TriggeredDataJtUnfolder.setMisses2D(hTrackJtMisses2D) TriggeredDataJtUnfolder.setJetPtResponse( createResponseInverse(hJetPtMeas, hJetPtResponse)) TriggeredDataJtUnfolder.setJetPtResponseCoarse( createResponseInverse(hJetPtMeasCoarse, hJetPtResponseCoarse)) TriggeredDataJtUnfolder.setNumberJetsMeasTrain( sum(numberJetsMeasTrain)) TriggeredDataJtUnfolder.set2Dresponse(hTrackJtCorr2D) TriggeredDataJtUnfolder.unfold() TriggeredDataJtUnfolder.write_files(output_file)
def extract_JetBTag(f_tt, f_qcd, f_wjet): # get trees from files t_tt = f_tt.Get("Delphes") t_qcd = f_qcd.Get("Delphes") t_wjet = f_wjet.Get("Delphes") # get number of entries tt_n_entries = t_tt.GetEntries() qcd_n_entries = t_qcd.GetEntries() wjet_n_entries = t_wjet.GetEntries() # define leaves var_tt = "Jet.BTag" var_qcd = "Jet.BTag" var_wjet = "Jet.BTag" leaf_tt = t_tt.GetLeaf(var_tt) leaf_qcd = t_qcd.GetLeaf(var_qcd) leaf_wjet = t_wjet.GetLeaf(var_wjet) # create the histograms loose_tt = Hist(NBINS, NLO, NHI, title='loose_tt', legendstyle='L') medium_tt = Hist(NBINS, NLO, NHI, title='medium_tt', legendstyle='L') tight_tt = Hist(NBINS, NLO, NHI, title='tight_tt', legendstyle='L') loose_qcd = Hist(NBINS, NLO, NHI, title='loose_qcd', legendstyle='L') medium_qcd = Hist(NBINS, NLO, NHI, title='medium_qcd', legendstyle='L') tight_qcd = Hist(NBINS, NLO, NHI, title='tight_qcd', legendstyle='L') loose_wjet = Hist(NBINS, NLO, NHI, title='loose_wjet', legendstyle='L') medium_wjet = Hist(NBINS, NLO, NHI, title='medium_wjet', legendstyle='L') tight_wjet = Hist(NBINS, NLO, NHI, title='tight_wjet', legendstyle='L') # FILLING THE TREE fill_JetBTag_tree(tt_n_entries, t_tt, leaf_tt, loose_tt, medium_tt, tight_tt) fill_JetBTag_tree(qcd_n_entries, t_qcd, leaf_qcd, loose_qcd, medium_qcd, tight_qcd) fill_JetBTag_tree(wjet_n_entries, t_wjet, leaf_wjet, loose_wjet, medium_wjet, tight_wjet) #set line colors loose_tt.SetLineColor('blue') medium_tt.SetLineColor('green') tight_tt.SetLineColor('red') loose_qcd.SetLineColor('blue') medium_qcd.SetLineColor('green') tight_qcd.SetLineColor('red') loose_wjet.SetLineColor('blue') medium_wjet.SetLineColor('green') tight_wjet.SetLineColor('red') #begin drawing stuff c1 = Canvas() tight_tt.SetStats(0) tight_tt.Draw('HIST') medium_tt.Draw('HIST SAME') loose_tt.Draw('HIST SAME') #make legend l1 = Legend([tight_tt, medium_tt, loose_tt], textfont=42, textsize=.03) l1.Draw() #save as pdf c1.SaveAs("../plots/JetBTag_plots/btag_tt.pdf") c2 = Canvas() tight_qcd.SetStats(0) tight_qcd.Draw('HIST') medium_qcd.Draw('HIST SAME') loose_qcd.Draw('HIST SAME') #make legend l2 = Legend([tight_qcd, medium_qcd, loose_qcd], textfont=42, textsize=.03) l2.Draw() #save as pdf c2.SaveAs("../plots/JetBTag_plots/btag_qcd.pdf") c3 = Canvas() tight_wjet.SetStats(0) tight_wjet.Draw('HIST') medium_wjet.Draw('HIST SAME') loose_wjet.Draw('HIST SAME') #make legend l3 = Legend([tight_wjet, medium_wjet, loose_wjet], textfont=42, textsize=.03) l3.Draw() #save as pdf c3.SaveAs("../plots/JetBTag_plots/btag_wjet.pdf") wait(True)
#!/usr/bin/env python """ ============================ Working with ROOT histograms ============================ This example demonstrates how to create and work with ROOT histogram in rootpy. """ print __doc__ from rootpy.plotting import Hist, Hist2D, Hist3D, HistStack, Legend, Canvas from rootpy.interactive import wait import random # create a simple 1D histogram with 10 constant-width bins between 0 and 1 h_simple = Hist(10, 0, 1) print h_simple.name # If the name is not specified, a UUID is used so that ROOT never complains # about two histograms having the same name. # Alternatively you can specify the name (and the title or any other style # attributes) in the constructor: h_simple = Hist(10, -4, 12, name='my hist', title='Some Data', drawstyle='hist', legendstyle='F', fillstyle='/') # fill the histogram
def __init__(self, name, bins, threshold): self._pass = Hist(bins, name=name + '_pass') self._total = Hist(bins, name=name + '_total') self._dist = Hist(bins, name=name + '_dist') self._threshold = threshold self._efficiency = None
def ln_likelihood_full_matching(self, w_value, alpha, zeta, beta, gamma, delta, kappa, eta, lamb, g1_value, extraction_efficiency, gas_gain_value, gas_gain_width, spe_res, s1_acc_par0, s1_acc_par1, s2_acc_par0, s2_acc_par1, scale_par, d_gpu_local_info, draw_fit=False): # ----------------------------------------------- # ----------------------------------------------- # determine prior likelihood and variables # ----------------------------------------------- # ----------------------------------------------- prior_ln_likelihood = 0 matching_ln_likelihood = 0 # get w-value prior lieklihood prior_ln_likelihood += self.get_ln_prior_w_value(w_value) # priors of detector variables prior_ln_likelihood += self.get_ln_prior_g1(g1_value) prior_ln_likelihood += self.get_ln_prior_extraction_efficiency( extraction_efficiency) prior_ln_likelihood += self.get_ln_prior_gas_gain_value(gas_gain_value) prior_ln_likelihood += self.get_ln_prior_gas_gain_width(gas_gain_width) prior_ln_likelihood += self.get_ln_prior_spe_res(spe_res) prior_ln_likelihood += self.get_ln_prior_s1_acc_pars( s1_acc_par0, s1_acc_par1) prior_ln_likelihood += self.get_ln_prior_s2_acc_pars( s2_acc_par0, s2_acc_par1) # get priors from lindhard parameters prior_ln_likelihood += self.get_ln_prior_par_greater_than_zero(alpha) prior_ln_likelihood += self.get_ln_prior_par_greater_than_zero(beta) prior_ln_likelihood += self.get_ln_prior_par_greater_than_zero(gamma) prior_ln_likelihood += self.get_ln_prior_par_greater_than_zero(kappa) prior_ln_likelihood += self.get_ln_prior_par_greater_than_zero(eta) prior_ln_likelihood += self.get_ln_prior_par_greater_than_zero(lamb) prior_ln_likelihood += self.get_ln_prior_zeta(zeta) prior_ln_likelihood += self.get_ln_prior_delta(delta) # if prior is -inf then don't bother with MC #print 'removed prior infinity catch temporarily' if not np.isfinite(prior_ln_likelihood) and not draw_fit: return -np.inf # ----------------------------------------------- # ----------------------------------------------- # run MC # ----------------------------------------------- # ----------------------------------------------- num_trials = np.asarray(self.num_mc_events, dtype=np.int32) num_repetitions = np.asarray(d_gpu_local_info['num_repetitions'], dtype=np.int32) mean_field = np.asarray(self.d_data_parameters['mean_field'], dtype=np.float32) w_value = np.asarray(w_value, dtype=np.float32) alpha = np.asarray(alpha, dtype=np.float32) zeta = np.asarray(zeta, dtype=np.float32) beta = np.asarray(beta, dtype=np.float32) gamma = np.asarray(gamma, dtype=np.float32) delta = np.asarray(delta, dtype=np.float32) kappa = np.asarray(kappa, dtype=np.float32) eta = np.asarray(eta, dtype=np.float32) lamb = np.asarray(lamb, dtype=np.float32) g1_value = np.asarray(g1_value, dtype=np.float32) extraction_efficiency = np.asarray(extraction_efficiency, dtype=np.float32) gas_gain_value = np.asarray(gas_gain_value, dtype=np.float32) gas_gain_width = np.asarray(gas_gain_width, dtype=np.float32) spe_res = np.asarray(spe_res, dtype=np.float32) s1_acc_par0 = np.asarray(s1_acc_par0, dtype=np.float32) s1_acc_par1 = np.asarray(s1_acc_par1, dtype=np.float32) s2_acc_par0 = np.asarray(s2_acc_par0, dtype=np.float32) s2_acc_par1 = np.asarray(s2_acc_par1, dtype=np.float32) # for histogram binning num_bins_s1 = np.asarray(self.s1_settings[0], dtype=np.int32) num_bins_s2 = np.asarray(self.s2_settings[0], dtype=np.int32) a_hist_2d = np.zeros(self.s1_settings[0] * self.s2_settings[0], dtype=np.int32) #print d_gpu_local_info['d_gpu_energy'][degree_setting] l_gpu_args = (d_gpu_local_info['rng_states'], drv.In(num_trials), drv.In(num_repetitions), drv.In(mean_field), d_gpu_local_info['gpu_energies'], drv.In(w_value), drv.In(alpha), drv.In(zeta), drv.In(beta), drv.In(gamma), drv.In(delta), drv.In(kappa), drv.In(eta), drv.In(lamb), drv.In(g1_value), drv.In(extraction_efficiency), drv.In(gas_gain_value), drv.In(gas_gain_width), drv.In(spe_res), drv.In(s1_acc_par0), drv.In(s1_acc_par1), drv.In(s2_acc_par0), drv.In(s2_acc_par1), drv.In(num_bins_s1), d_gpu_local_info['gpu_bin_edges_s1'], drv.In(num_bins_s2), d_gpu_local_info['gpu_bin_edges_s2'], drv.InOut(a_hist_2d)) #print '\n\n\nBefore call...' #print d_gpu_local_info d_gpu_local_info['function_to_call'](*l_gpu_args, **self.d_gpu_scale) #print 'After call...\n\n\n' a_s1_s2_mc = np.reshape(a_hist_2d, (self.s2_settings[0], self.s1_settings[0])).T #print list(a_s1_s2_mc) sum_mc = np.sum(a_s1_s2_mc, dtype=np.float32) if sum_mc == 0: #print 'sum mc == 0' return -np.inf # this forces our scale to be close to 1 (difference comes from acceptance) a_s1_s2_mc = np.multiply( a_s1_s2_mc, float(scale_par) * len(self.a_data_s1) / float(self.num_mc_events * self.num_repetitions)) #'ml' if draw_fit: f, (ax1, ax2) = plt.subplots(2, sharex=True, sharey=True) ax1.set_xlabel('S1 [PE]') ax1.set_ylabel('log(S2/S1)') ax2.set_xlabel('S1 [PE]') ax2.set_ylabel('log(S2/S1)') s1_s2_data_plot = np.rot90(self.d_coincidence_data_information[ self.l_cathode_settings_in_use[0]][degree_setting] ['a_log_s2_s1']) s1_s2_data_plot = np.flipud(s1_s2_data_plot) ax1.pcolormesh(self.a_s1_bin_edges, self.a_log_bin_edges, s1_s2_data_plot) s1_s2_mc_plot = np.rot90(a_s1_s2_mc) s1_s2_mc_plot = np.flipud(s1_s2_mc_plot) #print self.l_s1_settings #print self.l_log_settings #print self.d_coincidence_data_information[self.l_cathode_settings_in_use[0]][self.l_degree_settings_in_use[0]]['a_log_s2_s1'].shape #print a_s1_s2_mc.shape #print s1_s2_data_plot.shape #print s1_s2_mc_plot.shape ax2.pcolormesh(self.a_s1_bin_edges, self.a_log_bin_edges, s1_s2_mc_plot) #plt.colorbar() c1 = Canvas(1400, 400) c1.Divide(2) h_s1_data = Hist(*self.l_s1_settings, name='hS1_draw_data') root_numpy.array2hist( self.d_coincidence_data_information[ self.l_cathode_settings_in_use[0]][degree_setting] ['a_log_s2_s1'].sum(axis=1), h_s1_data) hS1MC = Hist(*self.l_s1_settings, name='hS1_draw_mc') root_numpy.array2hist(a_s1_s2_mc.sum(axis=1), hS1MC) s1_scale_factor = h_s1_data.Integral() / float(hS1MC.Integral()) g_s1_data = neriX_analysis.convert_hist_to_graph_with_poisson_errors( h_s1_data) g_s1_mc = neriX_analysis.convert_hist_to_graph_with_poisson_errors( hS1MC, scale=s1_scale_factor) g_s1_mc.SetFillColor(root.kBlue) g_s1_mc.SetMarkerColor(root.kBlue) g_s1_mc.SetLineColor(root.kBlue) g_s1_mc.SetFillStyle(3005) g_s1_data.SetTitle('S1 Comparison') g_s1_data.GetXaxis().SetTitle('S1 [PE]') g_s1_data.GetYaxis().SetTitle('Counts') g_s1_data.SetLineColor(root.kRed) g_s1_data.SetMarkerSize(0) g_s1_data.GetXaxis().SetRangeUser(self.l_s1_settings[1], self.l_s1_settings[2]) g_s1_data.GetYaxis().SetRangeUser( 0, 1.2 * max(h_s1_data.GetMaximum(), hS1MC.GetMaximum())) c1.cd(1) g_s1_data.Draw('ap') g_s1_mc.Draw('same') g_s1_mc_band = g_s1_mc.Clone() g_s1_mc_band.Draw('3 same') h_s2_data = Hist(*self.l_log_settings, name='h_s2_draw_data') root_numpy.array2hist( self.d_coincidence_data_information[ self.l_cathode_settings_in_use[0]][degree_setting] ['a_log_s2_s1'].sum(axis=0), h_s2_data) h_s2_mc = Hist(*self.l_log_settings, name='h_s2_draw_mc') root_numpy.array2hist(a_s1_s2_mc.sum(axis=0), h_s2_mc) s2_scale_factor = h_s2_data.Integral() / float(h_s2_mc.Integral()) g_s2_data = neriX_analysis.convert_hist_to_graph_with_poisson_errors( h_s2_data) g_s2_mc = neriX_analysis.convert_hist_to_graph_with_poisson_errors( h_s2_mc, scale=s2_scale_factor) g_s2_mc.SetFillColor(root.kBlue) g_s2_mc.SetMarkerColor(root.kBlue) g_s2_mc.SetLineColor(root.kBlue) g_s2_mc.SetFillStyle(3005) g_s2_data.SetTitle('Log(S2/S1) Comparison') g_s2_data.GetXaxis().SetTitle('Log(S2/S1)') g_s2_data.GetYaxis().SetTitle('Counts') g_s2_data.SetLineColor(root.kRed) g_s2_data.SetMarkerSize(0) g_s2_data.GetXaxis().SetRangeUser(self.l_log_settings[1], self.l_log_settings[2]) g_s2_data.GetYaxis().SetRangeUser( 0, 1.2 * max(h_s2_data.GetMaximum(), h_s2_mc.GetMaximum())) c1.cd(2) g_s2_data.Draw('ap') g_s2_mc.Draw('same') g_s2_mc_band = g_s2_mc.Clone() g_s2_mc_band.Draw('3 same') c1.Update() neriX_analysis.save_plot(['temp_results'], c1, '%d_deg_1d_hists' % (degree_setting), batch_mode=True) f.savefig('./temp_results/%d_deg_2d_hist.png' % (degree_setting)) flat_s1_s2_data = np.asarray(self.a_data_hist_s1_s2.flatten(), dtype=np.float32) flat_s1_s2_mc = np.asarray(a_s1_s2_mc.flatten(), dtype=np.float32) logLikelihoodMatching = c_log_likelihood( flat_s1_s2_data, flat_s1_s2_mc, len(flat_s1_s2_data), int(self.num_mc_events * self.num_repetitions), 0.95) #print prior_ln_likelihood #print logLikelihoodMatching #print max(flat_s1_s2_data) #print max(flat_s1_s2_mc) #print '\n\n' if np.isnan(logLikelihoodMatching): return -np.inf else: matching_ln_likelihood += logLikelihoodMatching if self.b_suppress_likelihood: matching_ln_likelihood /= self.ll_suppression_factor total_ln_likelihood = prior_ln_likelihood + matching_ln_likelihood #print total_ln_likelihood if np.isnan(total_ln_likelihood): return -np.inf else: return total_ln_likelihood
def plot_pull(pulls, centre_of_mass, channel, variable, k_value, tau_value, output_folder, output_formats, bin_index=None, n_bins=1): min_x, max_x = min(pulls), max(pulls) abs_max = int(max(abs(min_x), max_x)) if abs_max < 1: abs_max = 1 n_x_bins = 2 * abs_max * 10 # bin width = 0.1 # print(n_x_bins, -abs_max, abs_max) h_pull = Hist(n_x_bins, -abs_max, abs_max) filling = h_pull.Fill stats = 0 for pull_index, pull in enumerate(pulls): if not bin_index is None: matches_bin = (pull_index - bin_index) % (n_bins) == 0 if pull_index < n_bins: # first set correction matches_bin = pull_index == bin_index if not matches_bin: continue filling(pull) stats += 1 # printstats # h_list = hist_to_value_error_tuplelist(h_pull) # printh_list # printlen(hist_data), min(hist_data), max(hist_data) fr = None if bin_index is None: fr = plot_h_pull(h_pull, centre_of_mass, channel, variable, k_value, tau_value, output_folder, output_formats, stats=stats, name='pull_from_files_all_bins_stats_%d' % stats) else: fr = plot_h_pull(h_pull, centre_of_mass, channel, variable, k_value, tau_value, output_folder, output_formats, stats=stats, name='pull_from_files_bin_%d_stats_%d' % (bin_index, stats)) return fr
print "Creating test tree in chaintest1.root" f = root_open("chaintest1.root", "recreate") tree = Tree("test") branches = {'x': 'F', 'y': 'F', 'z': 'F', 'i': 'I'} tree.create_branches(branches) for i in xrange(10000): tree.x = gauss(.5, 1.) tree.y = gauss(.3, 2.) tree.z = gauss(13., 42.) tree.i = i tree.fill() # Make a histogram of x when y > 1 hist1 = Hist(100, -10, 10, name='hist1') tree.Draw('x', 'y > 1', hist=hist1) hist1.SetDirectory(0) # memory resident print "The first tree has %f entries where y > 1" % hist1.Integral() tree.write() f.close() print "Creating test tree in chaintest2.root" f = root_open("chaintest2.root", "recreate") tree = Tree("test") tree.create_branches(branches) for i in xrange(10000): tree.x = gauss(.5, 1.)
def plot_difference(difference, centre_of_mass, channel, variable, k_value, tau_value, output_folder, output_formats): stats = len(difference) values, errors = [], [] add_value = values.append add_error = errors.append for value, error in difference: add_value(value) add_error(error) min_x, max_x = min(values), max(values) abs_max = int(max(abs(min_x), max_x)) # n_x_bins = 2 * abs_max * 10 h_values = Hist(100, -abs_max, abs_max) fill_value = h_values.Fill for value in values: fill_value(value) plt.figure(figsize=(16, 16), dpi=200, facecolor='white') axes = plt.axes() h_values.SetMarkerSize(CMS.data_marker_size) rplt.errorbar(h_values, xerr=True, emptybins=True, axes=axes) channel_label = latex_labels.channel_latex[channel] var_label = latex_labels.variables_latex[variable] title_template = 'SVD unfolding performance for unfolding of {variable}\n' title_template += '$\sqrt{{s}}$ = {com} TeV, {channel}, {value}' title = title_template.format(variable=var_label, com=centre_of_mass, channel=channel_label, value=get_value_title(k_value, tau_value)) plt.xlabel('$\mathrm{unfolded} - \mathrm{true}$', CMS.x_axis_title) plt.ylabel('number of toy experiments', CMS.y_axis_title) plt.tick_params(**CMS.axis_label_major) plt.tick_params(**CMS.axis_label_minor) plt.title(title, CMS.title) plt.tight_layout() for save in output_formats: plt.savefig(output_folder + 'difference_stats_' + str(stats) + '.' + save) min_x, max_x = min(errors), max(errors) h_errors = Hist(1000, min_x, max_x) fill_value = h_errors.Fill for error in errors: fill_value(error) plt.figure(figsize=(16, 16), dpi=200, facecolor='white') axes = plt.axes() h_errors.SetMarkerSize(CMS.data_marker_size) rplt.errorbar(h_errors, xerr=True, emptybins=True, axes=axes) plt.xlabel('$\sigma(\mathrm{unfolded} - \mathrm{true})$', CMS.x_axis_title) plt.ylabel('number of toy experiments', CMS.y_axis_title) plt.tick_params(**CMS.axis_label_major) plt.tick_params(**CMS.axis_label_minor) plt.title(title_template, CMS.title) plt.tight_layout() for save in output_formats: plt.savefig(output_folder + 'difference_errors_stats_' + str(stats) + '.' + save)
def test_uniform(): hist = Hist(10, 0, 1) assert_true(hist.uniform()) hist = Hist2D(10, 0, 1, [1, 10, 100]) assert_false(hist.uniform()) assert_true(hist.uniform(axis=0))
except ValueError: print("\t\tThis exists. Try re-running with -f, --force to overwrite the existing directory or specify a different output directory") sys.exit(1) # guess we're all ok, so cd and continue print("\tCd'ing into {0}".format(args.output)) out_file.cd(args.output) # get the tree if exists tree = getattr(out_file, args.tree_name, None) # no entries, just write empty histograms to file if tree is None or tree.get_entries() == 0: print("\tNo entries in ntuple, writing empty histograms and finishing.") for histName, st3 in boundaries.iteritems(): h = Hist(st3[2], st3[0], st3[1], name=histName) h.write() else: differences = [] #c = ROOT.TCanvas("canvas", "canvas", 500, 500) for subercuts in combinations(supercuts, len(supercuts)-1): # hold the differences and create a text file with them later for reference # use integers to denote them differences.append([x for x in supercuts if x not in subercuts][0]) # get the selection we apply to draw it selection = utils.cuts_to_selection(subercuts) # get the branch we need to draw selection_string = differences[-1]['selections'] print("\tLooking at selection: {0}".format(selection_string))
def test_init_from_graph(): hist = Hist(10, 0, 1) hist.FillRandom('gaus') graph = Graph(hist) hist2 = Hist(graph)
def start(self): self._bs_branchnames = [ "BToPhiMuMu_chi2", "BToPhiMuMu_cos2D", "BToPhiMuMu_eta", "BToPhiMuMu_etaphi_fullfit", "BToPhiMuMu_fit_cos2D", "BToPhiMuMu_fit_eta", "BToPhiMuMu_fit_mass", "BToPhiMuMu_fit_massErr", "BToPhiMuMu_fit_phi", "BToPhiMuMu_fit_pt", "BToPhiMuMu_l_xy", "BToPhiMuMu_l_xy_unc", "BToPhiMuMu_lep1eta_fullfit", "BToPhiMuMu_lep1phi_fullfit", "BToPhiMuMu_lep1pt_fullfit", "BToPhiMuMu_lep2eta_fullfit", "BToPhiMuMu_lep2phi_fullfit", "BToPhiMuMu_lep2pt_fullfit", "BToPhiMuMu_mass", "BToPhiMuMu_max_dr", "BToPhiMuMu_min_dr", "BToPhiMuMu_mll_fullfit", "BToPhiMuMu_mll_llfit", "BToPhiMuMu_mll_raw", "BToPhiMuMu_mphi_fullfit", "BToPhiMuMu_phi", "BToPhiMuMu_phiphi_fullfit", "BToPhiMuMu_pt", "BToPhiMuMu_ptphi_fullfit", "BToPhiMuMu_svprob", "BToPhiMuMu_trk1eta_fullfit", "BToPhiMuMu_trk1phi_fullfit", "BToPhiMuMu_trk1pt_fullfit", "BToPhiMuMu_trk2eta_fullfit", "BToPhiMuMu_trk2phi_fullfit", "BToPhiMuMu_trk2pt_fullfit", "BToPhiMuMu_charge", "BToPhiMuMu_l1_idx", "BToPhiMuMu_l2_idx", "BToPhiMuMu_pdgId", "BToPhiMuMu_phi_idx", "BToPhiMuMu_trk1_idx", "BToPhiMuMu_trk2_idx", ] self._event_branchnames = [ #"nPhi", #"Phi_eta", #"Phi_fitted_eta", #"Phi_fitted_mass", #"Phi_fitted_phi", #"Phi_fitted_pt", #"Phi_mass", #"Phi_phi", #"Phi_pt", #"Phi_svprob", #"Phi_trk_deltaR", #"Phi_charge", #"Phi_pdgId", #"Phi_trk1_idx", #"Phi_trk2_idx", "nMuon", "nBToPhiMuMu", "HLT_Mu7_IP4", "HLT_Mu8_IP6", "HLT_Mu8_IP5", "HLT_Mu8_IP3", "HLT_Mu8p5_IP3p5", "HLT_Mu9_IP6", "HLT_Mu9_IP5", "HLT_Mu9_IP4", "HLT_Mu10p5_IP3p5", "HLT_Mu12_IP6", #"L1_SingleMu7er1p5", #"L1_SingleMu8er1p5", #"L1_SingleMu9er1p5", #"L1_SingleMu10er1p5", #"L1_SingleMu12er1p5", #"L1_SingleMu22", #"nTrigObj", #"TrigObj_pt", #"TrigObj_eta", #"TrigObj_phi", #"TrigObj_l1pt", #"TrigObj_l1pt_2", #"TrigObj_l2pt", #"TrigObj_id", #"TrigObj_l1iso", #"TrigObj_l1charge", #"TrigObj_filterBits", #"nTriggerMuon", #"TriggerMuon_eta", #"TriggerMuon_mass", #"TriggerMuon_phi", #"TriggerMuon_pt", #"TriggerMuon_vx", #"TriggerMuon_vy", #"TriggerMuon_vz", #"TriggerMuon_charge", #"TriggerMuon_pdgId", #"TriggerMuon_trgMuonIndex", "event", ] self._muon_branchnames = [ "Muon_dxy", "Muon_dxyErr", "Muon_dz", "Muon_dzErr", "Muon_eta", "Muon_ip3d", "Muon_mass", "Muon_pfRelIso03_all", "Muon_pfRelIso03_chg", "Muon_pfRelIso04_all", "Muon_phi", "Muon_pt", "Muon_ptErr", "Muon_segmentComp", "Muon_sip3d", "Muon_vx", "Muon_vy", "Muon_vz", "Muon_charge", "Muon_isTriggering", "Muon_nStations", "Muon_pdgId", "Muon_tightCharge", "Muon_highPtId", "Muon_inTimeMuon", "Muon_isGlobal", "Muon_isPFcand", "Muon_isTracker", "Muon_mediumId", "Muon_mediumPromptId", "Muon_miniIsoId", "Muon_multiIsoId", "Muon_mvaId", "Muon_pfIsoId", "Muon_softId", "Muon_softMvaId", "Muon_tightId", "Muon_tkIsoId", "Muon_triggerIdLoose", ] #if self._isMC: # self._input_branches.extend(['GenPart_pdgId', 'GenPart_genPartIdxMother']) self._mu_histograms = {} self._mu_histograms["nMuon"] = Hist(11, -0.5, 10.5, name="nMuon", title="", type="F") self._mu_histograms["nMuon_isTrig"] = Hist(11, -0.5, 10.5, name="nMuon_isTrig", title="", type="F") self._mu_histograms["Muon_pt"] = Hist(100, 0.0, 100.0, name="Muon_pt", title="", type="F") self._mu_histograms["Muon_pt_isTrig"] = Hist(100, 0.0, 100.0, name="Muon_pt_isTrig", title="", type="F") self._histograms = {} for tag_type in ["tag", "probe"]: self._histograms[tag_type] = {} for trig in ["trigpass", "triginclusive"]: self._histograms[tag_type][trig] = {} self._histograms[tag_type][trig]["BToPhiMuMu_chi2"] = Hist( 100, 0.0, 100.0, name="{}_{}_BToPhiMuMu_chi2".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_eta"] = Hist( 50, -5.0, 5.0, name="{}_{}_BToPhiMuMu_eta".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_fit_cos2D"] = Hist( 100, -1., 1., name="{}_{}_BToPhiMuMu_fit_cos2D".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_fit_eta"] = Hist( 50, -5.0, 5.0, name="{}_{}_BToPhiMuMu_fit_eta".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_fit_mass"] = Hist( 100, BS_MASS * 0.9, BS_MASS * 1.1, name="{}_{}_BToPhiMuMu_fit_mass".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_fit_phi"] = Hist( 50, -2.0 * math.pi, 2.0 * math.pi, name="{}_{}_BToPhiMuMu_fit_phi".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_fit_pt"] = Hist( 100, 0.0, 100.0, name="{}_{}_BToPhiMuMu_fit_pt".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_l_xy"] = Hist( 50, -1.0, 4.0, name="{}_{}_BToPhiMuMu_l_xy".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_l_xy_sig"] = Hist( 50, -1.0, 4.0, name="{}_{}_BToPhiMuMu_l_xy_sig".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_lep1eta_fullfit"] = Hist( 50, -5.0, 5.0, name="{}_{}_BToPhiMuMu_lep1eta_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_lep1phi_fullfit"] = Hist( 50, -2.0 * math.pi, 2.0 * math.pi, name="{}_{}_BToPhiMuMu_lep1phi_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_lep1pt_fullfit"] = Hist( 100, 0.0, 100.0, name="{}_{}_BToPhiMuMu_lep1pt_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_lep2eta_fullfit"] = Hist( 50, -5.0, 5.0, name="{}_{}_BToPhiMuMu_lep2eta_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_lep2phi_fullfit"] = Hist( 50, -2.0 * math.pi, 2.0 * math.pi, name="{}_{}_BToPhiMuMu_lep2phi_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_lep2pt_fullfit"] = Hist( 100, 0.0, 100.0, name="{}_{}_BToPhiMuMu_lep2pt_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_mass"] = Hist( 500, BS_MASS * 0.9, BS_MASS * 1.1, name="{}_{}_BToPhiMuMu_mass".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_mll_fullfit"] = Hist( 500, JPSI_1S_MASS * 0.9, JPSI_1S_MASS * 1.1, name="{}_{}_BToPhiMuMu_mll_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_mll_llfit"] = Hist( 500, JPSI_1S_MASS * 0.9, JPSI_1S_MASS * 1.1, name="{}_{}_BToPhiMuMu_mll_llfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_mll_raw"] = Hist( 500, JPSI_1S_MASS * 0.9, JPSI_1S_MASS * 1.1, name="{}_{}_BToPhiMuMu_mll_raw".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_mphi_fullfit"] = Hist( 500, PHI_1020_MASS * 0.9, PHI_1020_MASS * 1.1, name="{}_{}_BToPhiMuMu_mphi_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_phi"] = Hist( 50, -2.0 * math.pi, 2.0 * math.pi, name="{}_{}_BToPhiMuMu_phi".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_etaphi_fullfit"] = Hist( 50, -5.0, 5.0, name="{}_{}_BToPhiMuMu_etaphi_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_phiphi_fullfit"] = Hist( 50, -2.0 * math.pi, 2.0 * math.pi, name="{}_{}_BToPhiMuMu_phiphi_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_pt"] = Hist( 100, 0.0, 100.0, name="{}_{}_BToPhiMuMu_pt".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig][ "BToPhiMuMu_ptphi_fullfit"] = Hist( 100, 0.0, 100.0, name="{}_{}_BToPhiMuMu_ptphi_fullfit".format( tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_svprob"] = Hist( 100, -1.0, 1.0, name="{}_{}_BToPhiMuMu_svprob".format(tag_type, trig), title="", type="F") self._histograms[tag_type][trig]["BToPhiMuMu_charge"] = Hist( 3, -1.5, 1.5, name="{}_{}_BToPhiMuMu_charge".format(tag_type, trig), title="", type="F") self._cutflow_names = [] self._cutflow_names.append("Inclusive") self._cutflow_names.append(self._trigger) self._cutflow_names.append("Tag") self._cutflow_names.append("Tag SV") self._cutflow_names.append("Tag mu-K") self._cutflow_names.append("Tag Jpsi") self._cutflow_names.append("Tag phi") self._cutflow_names.append("Probe") self._cutflow_names.append("Probe SV") self._cutflow_names.append("Probe mu-K") self._cutflow_names.append("Probe Jpsi") self._cutflow_names.append("Probe phi") self._cutflow_counts = {} for name in self._cutflow_names: self._cutflow_counts[name] = 0
def test_init_edge_repeated(): # bin edges must not be repeated Hist([10, 10, 30])
try: print f.a.b.c.d.e.f except AttributeError, e: print e for thing in f.walk(): print thing f.close() # supports with statements with root_open('data.root', 'update') as f: print f # write some histograms h1 = Hist(100, 0, 100, name='h1', type='I') # variable bin widths h2 = Hist2D((0, 3, 5, 20, 50), (10, 20, 30, 40, 1000), name='h2') h1.Write() h2.Write() # file is automatically closed after with statement # retrieve the histograms previously saved with root_open('data.root') as f: h1 = f.h1 # or h1 = f.Get('h1') h2 = f.h2 # or h2 = f.Get('h2')
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
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 test_divide(): Graph.divide(Graph(Hist(10, 0, 1).FillRandom('gaus')), Hist(10, 0, 1).FillRandom('gaus'), 'pois')
try: out_file.cd(innerDir) except: pass # get list of things to draw for toDraw in config['draw']: histName = toDraw['name'] histDimension = len(toDraw['draw'].split(':')) print "\tmaking {4}D histogram {0}\n\t{1} bins from {2} to {3}".format( toDraw['name'], toDraw['nbins'], toDraw['min'], toDraw['max'], histDimension) if histDimension == 1: h = Hist(toDraw['nbins'], toDraw['min'], toDraw['max'], name=histName) elif histDimension == 2: h = Hist2D(toDraw['nbins'][0], toDraw['min'][0], toDraw['max'][0], toDraw['nbins'][1], toDraw['min'][1], toDraw['max'][1], name=histName) elif histDimension == 3: h = Hist2D(toDraw['nbins'][0], toDraw['min'][0], toDraw['max'][0], toDraw['nbins'][1], toDraw['min'][1],
''' return poisson(b, n)/b def generate_n_poisson_weights_for_average(n, n_events_in_bins = [100, 120]): mean = average(n_events_in_bins) return generate_n_poisson_weights(n, mean) if __name__ == '__main__': from array import array from rootpy.plotting import Hist import rootpy.plotting.root2matplotlib as rplt import matplotlib.pyplot as plt from matplotlib.ticker import AutoMinorLocator bins = array('d', [0, 25, 45, 70, 100, 1000]) h_data = Hist(bins.tolist()) h_data.SetBinContent(1, 2146) h_data.SetBinError(1, 145) h_data.SetBinContent(2, 3399) h_data.SetBinError(2, 254) h_data.SetBinContent(3, 3723) h_data.SetBinError(3, 69) h_data.SetBinContent(4, 2256) h_data.SetBinError(4, 53) h_data.SetBinContent(5, 1722) h_data.SetBinError(5, 91) h_data.SetTitle('input distribution') h_new = generate_toy_MC_from_distribution(h_data) h_new.SetTitle('toy MC') fig = plt.figure(figsize=(16, 10), dpi=100, facecolor='white') axes = plt.axes([0.15, 0.15, 0.8, 0.8])
def unfolding_toy_diagnostics(indir, variable): plotter = BasePlotter(defaults={ 'clone': False, 'name_canvas': True, 'show_title': True, 'save': { 'png': True, 'pdf': False } }, ) styles = { 'dots': { 'linestyle': 0, 'markerstyle': 21, 'markercolor': 1 }, 'compare': { 'linesstyle': [1, 0], 'markerstyle': [0, 21], 'markercolor': [2, 1], 'linecolor': [2, 1], 'drawstyle': ['hist', 'pe'], 'legendstyle': ['l', 'p'] } } xaxislabel = set_pretty_label(variable) true_distribution = None curdir = os.getcwd() os.chdir(indir) toydirs = get_immediate_subdirectories(".") methods = [] pulls_lists = {} pull_means_lists = {} pull_mean_errors_lists = {} pull_sums_lists = {} pull_sigmas_lists = {} pull_sigma_errors_lists = {} deltas_lists = {} delta_means_lists = {} delta_mean_errors_lists = {} delta_sigmas_lists = {} delta_sigma_errors_lists = {} ratio_sums_lists = {} nneg_bins_lists = {} unfoldeds_lists = {} unfolded_sigmas_lists = {} taus_lists = {} histos_created = False lists_created = False idir = 0 true_distro = None #loop over toys for directory in toydirs: if not directory.startswith('toy_'): continue os.chdir(directory) log.debug('Inspecting toy %s' % directory) idir = idir + 1 i = 0 if not os.path.isfile("result_unfolding.root"): raise ValueError('root file not found in %s' % os.getcwd()) with io.root_open("result_unfolding.root") as inputfile: log.debug('Iteration %s over the file' % i) i = i + 1 if not methods: keys = [i.name for i in inputfile.keys()] for key in keys: if hasattr(getattr(inputfile, key), "hdata_unfolded"): methods.append(key) unfolded_hists = [ inputfile.get('%s/hdata_unfolded' % i) for i in methods ] unfolded_wps_hists = [ inputfile.get('%s/hdata_unfolded_ps_corrected' % i) for i in methods ] for unf, unfps, method in zip(unfolded_hists, unfolded_wps_hists, methods): unf.name = method unfps.name = method if true_distro is None: true_distribution = inputfile.true_distribution ROOT.TH1.AddDirectory(False) true_distro = true_distribution.Clone() taus = prettyjson.loads(inputfile.best_taus.GetTitle()) if len(taus_lists) == 0: taus_lists = dict((i, []) for i in taus) for i, t in taus.iteritems(): taus_lists[i].append(t) for histo in unfolded_hists: #create pull/delta containers during first iteration name = histo.name nbins = histo.nbins() log.debug("name = %s, n bins = %s" % (name, nbins)) if not lists_created: for ibin in range(1, nbins + 1): outname = "pull_" + name + "_bin" + str(ibin) pulls_lists[outname] = [] outname = "delta_" + name + "_bin" + str(ibin) deltas_lists[outname] = [] outname = "unfolded_" + name + "_bin" + str(ibin) unfoldeds_lists[outname] = [] unfolded_sigmas_lists[outname] = [] outname = "pull_" + name pull_means_lists[outname] = {} pull_mean_errors_lists[outname] = {} pull_sigmas_lists[outname] = {} pull_sigma_errors_lists[outname] = {} outname = "delta_" + name delta_means_lists[outname] = {} delta_mean_errors_lists[outname] = {} delta_sigmas_lists[outname] = {} delta_sigma_errors_lists[outname] = {} for ibin in range(1, nbins + 1): outname = "pull_" + name + "_bin" + str(ibin) unfolded_bin_content = histo.GetBinContent(ibin) unfolded_bin_error = histo.GetBinError(ibin) true_bin_content = true_distro.GetBinContent(ibin) true_bin_error = true_distro.GetBinError(ibin) total_bin_error = math.sqrt(unfolded_bin_error**2) #??? if (total_bin_error != 0): pull = (unfolded_bin_content - true_bin_content) / total_bin_error else: pull = 9999 log.debug( 'unfolded bin content %s +/- %s, true bin content %s, pull %s' % (unfolded_bin_content, unfolded_bin_error, true_bin_content, pull)) pulls_lists[outname].append(pull) outname = "delta_" + name + "_bin" + str(ibin) delta = unfolded_bin_content - true_bin_content log.debug( 'unfolded bin content %s +/- %s, true bin content %s, delta %s' % (unfolded_bin_content, unfolded_bin_error, true_bin_content, delta)) deltas_lists[outname].append(delta) outname = "unfolded_" + name + "_bin" + str(ibin) unfoldeds_lists[outname].append(unfolded_bin_content) unfolded_sigmas_lists[outname].append(unfolded_bin_error) nneg_bins_hists = [ i for i in inputfile.keys() if i.GetName().startswith("nneg_bins") ] nneg_bins_hists = [asrootpy(i.ReadObj()) for i in nneg_bins_hists] for histo in nneg_bins_hists: #create pull/delta containers during first iteration name = histo.name nbins = histo.nbins() log.debug("name = %s, n bins = %s" % (name, nbins)) if not lists_created: outname = name nneg_bins_lists[outname] = [] outname = name nneg_bins_lists[outname].append(histo.GetBinContent(1)) pull_sums_hists = [ i for i in inputfile.keys() if i.GetName().startswith("sum_of_pulls") ] pull_sums_hists = [asrootpy(i.ReadObj()) for i in pull_sums_hists] for histo in pull_sums_hists: #create pull/delta containers during first iteration name = histo.name nbins = histo.nbins() log.debug("name = %s, n bins = %s" % (name, nbins)) if not lists_created: outname = name pull_sums_lists[outname] = [] outname = name pull_sums_lists[outname].append(histo.GetBinContent(1)) ratio_sums_hists = [ i for i in inputfile.keys() if i.GetName().startswith("sum_of_ratios") ] ratio_sums_hists = [ asrootpy(i.ReadObj()) for i in ratio_sums_hists ] for histo in ratio_sums_hists: #create ratio/delta containers during first iteration name = histo.name nbins = histo.nbins() log.debug("name = %s, n bins = %s" % (name, nbins)) if not lists_created: outname = name ratio_sums_lists[outname] = [] outname = name ratio_sums_lists[outname].append(histo.GetBinContent(1)) #after the first iteration on the file all the lists are created lists_created = True os.chdir("..") #create histograms #histo containers taus = {} for name, vals in taus_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0.8 * val_min if val_min > 0 else 1.2 * val_min val_max = max(vals) val_max = 0.8 * val_max if val_max < 0 else 1.2 * val_max if val_min == val_max: if tau_nbins % 2: #if odd val_min, val_max = val_min - 0.01, val_min + 0.01 else: brange = 0.02 bwidth = brange / tau_nbins val_min, val_max = val_min - 0.01 + bwidth / 2., val_min + 0.01 + bwidth / 2. title = '#tau choice - %s ;#tau;N_{toys}' % (name) histo = Hist(tau_nbins, val_min, val_max, name=name, title=title) for val in vals: histo.Fill(val) taus[name] = histo pulls = {} for name, vals in pulls_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0.8 * val_min if val_min > 0 else 1.2 * val_min val_max = max(vals) val_max = 0.8 * val_max if val_max < 0 else 1.2 * val_max abs_max = max(abs(val_min), abs(val_max)) if 'L_curve' in name: method = 'L_curve' binno = name.split('_')[-1] else: _, method, binno = tuple(name.split('_')) title = 'Pulls - %s - %s ;Pull;N_{toys}' % (binno, method) histo = Hist(pull_nbins, -abs_max, abs_max, name=name, title=title) for val in vals: histo.Fill(val) pulls[name] = histo deltas = {} for name, vals in deltas_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0.8 * val_min if val_min > 0 else 1.2 * val_min val_max = max(vals) val_max = 0.8 * val_max if val_max < 0 else 1.2 * val_max if 'L_curve' in name: method = 'L_curve' binno = name.split('_')[-1] else: _, method, binno = tuple(name.split('_')) title = 'Deltas - %s - %s ;Delta;N_{toys}' % (binno, method) histo = Hist(delta_nbins, val_min, val_max, name=name, title=title) for val in vals: histo.Fill(val) deltas[name] = histo unfoldeds = {} for name, vals in unfoldeds_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0.8 * val_min if val_min > 0 else 1.2 * val_min val_max = max(vals) val_max = 0.8 * val_max if val_max < 0 else 1.2 * val_max if 'L_curve' in name: method = 'L_curve' binno = name.split('_')[-1] else: _, method, binno = tuple(name.split('_')) title = 'Unfoldeds - %s - %s ;Unfolded;N_{toys}' % (binno, method) histo = Hist(unfolded_nbins, val_min, val_max, name=name, title=title) for val in vals: histo.Fill(val) unfoldeds[name] = histo nneg_bins = {} for name, vals, in nneg_bins_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0 if val_min > 0 else val_min - 1 val_max = max(vals) val_max = 0 if val_max < 0 else val_max + 1 if 'L_curve' in name: method = 'L_curve' else: set_trace() _, method, _ = tuple(name.split('_')) title = 'N of negative bins - %s ;N. neg bins;N_{toys}' % method histo = Hist(int(val_max - val_min + 1), val_min, val_max, name=name, title=title) for val in vals: histo.Fill(val) nneg_bins[name] = histo pull_sums = {} for name, vals in pull_sums_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0.8 * val_min if val_min > 0 else 1.2 * val_min val_max = max(vals) val_max = 0.8 * val_max if val_max < 0 else 1.2 * val_max if 'L_curve' in name: method = 'L_curve' else: set_trace() _, _, _, _, _, method = tuple(name.split('_')) title = 'Pull sums - %s ;#Sigma(pull)/N_{bins};N_{toys}' % method histo = Hist(unfolded_nbins, val_min, val_max, name=name, title=title) for val in vals: histo.Fill(val) pull_sums[name] = histo ratio_sums = {} for name, vals in ratio_sums_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0.8 * val_min if val_min > 0 else 1.2 * val_min val_max = max(vals) val_max = 0.8 * val_max if val_max < 0 else 1.2 * val_max if 'L_curve' in name: method = 'L_curve' binno = name.split('_')[-1] else: set_trace() _, _, _, _, _, method = tuple(name.split('_')) title = 'Ratio sums - %s;#Sigma(ratio)/N_{bins};N_{toys}' % method histo = Hist(unfolded_nbins, val_min, val_max, name=name, title=title) for val in vals: histo.Fill(val) ratio_sums[name] = histo unfolded_sigmas = {} for name, vals in unfolded_sigmas_lists.iteritems(): ROOT.TH1.AddDirectory(False) #repeat, you never know val_min = min(vals) val_min = 0.8 * val_min if val_min > 0 else 1.2 * val_min val_max = max(vals) val_max = 0.8 * val_max if val_max < 0 else 1.2 * val_max if 'L_curve' in name: method = 'L_curve' binno = name.split('_')[-1] else: _, method, binno = tuple(name.split('_')) title = 'Unfolded uncertainties - %s - %s ;Uncertainty;N_{toys}' % ( binno, method) histo = Hist(unfolded_nbins, val_min, val_max, name=name, title=title) for val in vals: histo.Fill(val) unfolded_sigmas[name] = histo for name, histo in pulls.iteritems(): log.debug("name is %s and object type is %s" % (name, type(histo))) histo.Fit("gaus", 'Q') if not histo.GetFunction("gaus"): log.warning("Function not found for histogram %s" % name) continue mean = histo.GetFunction("gaus").GetParameter(1) meanError = histo.GetFunction("gaus").GetParError(1) sigma = histo.GetFunction("gaus").GetParameter(2) sigmaError = histo.GetFunction("gaus").GetParError(2) general_name, idx = tuple(name.split('_bin')) idx = int(idx) pull_means_lists[general_name][idx] = mean pull_mean_errors_lists[general_name][idx] = meanError pull_sigmas_lists[general_name][idx] = sigma pull_sigma_errors_lists[general_name][idx] = sigmaError for name, histo in deltas.iteritems(): log.debug("name is %s and object type is %s" % (name, type(histo))) histo.Fit("gaus", 'Q') if not histo.GetFunction("gaus"): log.warning("Function not found for histogram %s" % name) continue mean = histo.GetFunction("gaus").GetParameter(1) meanError = histo.GetFunction("gaus").GetParError(1) sigma = histo.GetFunction("gaus").GetParameter(2) sigmaError = histo.GetFunction("gaus").GetParError(2) general_name, idx = tuple(name.split('_bin')) idx = int(idx) delta_means_lists[general_name][idx] = mean delta_mean_errors_lists[general_name][idx] = meanError delta_sigmas_lists[general_name][idx] = sigma delta_sigma_errors_lists[general_name][idx] = sigmaError outfile = rootpy.io.File("unfolding_diagnostics.root", "RECREATE") outfile.cd() pull_means = {} pull_sigmas = {} pull_means_summary = {} pull_sigmas_summary = {} delta_means = {} delta_sigmas = {} delta_means_summary = {} delta_sigmas_summary = {} for outname, pmeans in pull_means_lists.iteritems(): outname_mean = outname + "_mean" outtitle = "Pull means - " + outname + ";Pull mean; N_{toys}" pull_mean_min = min(pmeans.values()) pull_mean_max = max(pmeans.values()) pull_mean_newmin = pull_mean_min - (pull_mean_max - pull_mean_min) * 0.5 pull_mean_newmax = pull_mean_max + (pull_mean_max - pull_mean_min) * 0.5 pull_means[outname] = plotting.Hist(pull_mean_nbins, pull_mean_newmin, pull_mean_newmax, name=outname_mean, title=outtitle) outname_mean_summary = outname + "_mean_summary" outtitle_mean_summary = "Pull mean summary - " + outname histocloned = true_distro.Clone(outname_mean_summary) histocloned.Reset() histocloned.xaxis.title = xaxislabel histocloned.yaxis.title = 'Pull mean' histocloned.title = outtitle_mean_summary pull_means_summary[outname] = histocloned for idx, pmean in pmeans.iteritems(): pull_means[outname].Fill(pmean) histocloned[idx].value = pmean histocloned[idx].error = pull_mean_errors_lists[outname][idx] histocloned.yaxis.SetRangeUser(min(pmeans.values()), max(pmeans.values())) for outname, psigmas in pull_sigmas_lists.iteritems(): outname_sigma = outname + "_sigma" outtitle_sigma = "Pull #sigma's - " + outname + ";Pull #sigma; N_{toys}" pull_sigma_min = min(psigmas.values()) pull_sigma_max = max(psigmas.values()) pull_sigma_newmin = pull_sigma_min - (pull_sigma_max - pull_sigma_min) * 0.5 pull_sigma_newmax = pull_sigma_max + (pull_sigma_max - pull_sigma_min) * 0.5 pull_sigmas[outname] = plotting.Hist(pull_sigma_nbins, pull_sigma_newmin, pull_sigma_newmax, name=outname_sigma, title=outtitle_sigma) outname_sigma_summary = outname + "_sigma_summary" outtitle_sigma_summary = "Pull #sigma summary - " + outname histocloned = true_distro.Clone(outname_sigma_summary) histocloned.Reset() histocloned.xaxis.title = xaxislabel histocloned.yaxis.title = 'Pull #sigma' histocloned.title = outtitle_sigma_summary pull_sigmas_summary[outname] = histocloned for idx, psigma in psigmas.iteritems(): pull_sigmas[outname].Fill(psigma) histocloned[idx].value = psigma histocloned[idx].error = pull_sigma_errors_lists[outname][idx] histocloned.yaxis.SetRangeUser(min(psigmas.values()), max(psigmas.values())) for outname, dmeans in delta_means_lists.iteritems(): outname_mean = outname + "_mean" outtitle = "Delta means - " + outname + ";Delta mean; N_{toys}" delta_mean_min = min(dmeans.values()) delta_mean_max = max(dmeans.values()) delta_mean_newmin = delta_mean_min - (delta_mean_max - delta_mean_min) * 0.5 delta_mean_newmax = delta_mean_max + (delta_mean_max - delta_mean_min) * 0.5 delta_means[outname] = plotting.Hist(delta_mean_nbins, delta_mean_newmin, delta_mean_newmax, name=outname_mean, title=outtitle) outname_mean_summary = outname + "_mean_summary" outtitle_mean_summary = "Delta mean summary - " + outname histocloned = true_distro.Clone(outname_mean_summary) histocloned.Reset() histocloned.xaxis.title = xaxislabel histocloned.yaxis.title = 'Delta mean' histocloned.title = outtitle_mean_summary delta_means_summary[outname] = histocloned for idx, dmean in dmeans.iteritems(): delta_means[outname].Fill(dmean) histocloned[idx].value = dmean histocloned[idx].error = delta_mean_errors_lists[outname][idx] histocloned.yaxis.SetRangeUser(min(dmeans.values()), max(dmeans.values())) for outname, dsigmas in delta_sigmas_lists.iteritems(): outname_sigma = outname + "_sigma" outtitle_sigma = "Delta #sigma's - " + outname + ";Delta #sigma; N_{toys}" delta_sigma_min = min(dsigmas.values()) delta_sigma_max = max(dsigmas.values()) delta_sigma_newmin = delta_sigma_min - (delta_sigma_max - delta_sigma_min) * 0.5 delta_sigma_newmax = delta_sigma_max + (delta_sigma_max - delta_sigma_min) * 0.5 delta_sigmas[outname] = plotting.Hist(delta_sigma_nbins, delta_sigma_newmin, delta_sigma_newmax, name=outname_sigma, title=outtitle_sigma) outname_sigma_summary = outname + "_sigma_summary" outtitle_sigma_summary = "Delta #sigma summary - " + outname histocloned = true_distro.Clone(outname_sigma_summary) histocloned.Reset() histocloned.xaxis.title = xaxislabel histocloned.yaxis.title = 'Delta #sigma' histocloned.title = outtitle_sigma_summary delta_sigmas_summary[outname] = histocloned for idx, dsigma in dsigmas.iteritems(): delta_sigmas[outname].Fill(dsigma) histocloned[idx].value = dsigma histocloned[idx].error = delta_sigma_errors_lists[outname][idx] histocloned.yaxis.SetRangeUser(min(dsigmas.values()), max(dsigmas.values())) unfolded_summary = {} unfolded_average = {} unfolded_envelope = {} for name, histo in unfoldeds.iteritems(): log.debug("name is %s and object type is %s" % (name, type(histo))) histo.Fit("gaus", 'Q') if not histo.GetFunction("gaus"): log.warning("Function not found for histogram %s" % name) continue mean = histo.GetFunction("gaus").GetParameter(1) meanError = histo.GetFunction("gaus").GetParError(1) sigma = histo.GetFunction("gaus").GetParameter(2) sigmaError = histo.GetFunction("gaus").GetParError(2) general_name, idx = tuple(name.split('_bin')) idx = int(idx) if general_name not in unfolded_summary: histo = true_distro.Clone("%s_unfolded_summary" % general_name) outtitle_unfolded_summary = "Unfolded summary - " + general_name histo.Reset() histo.xaxis.title = xaxislabel histo.yaxis.title = 'N_{events}' histo.title = outtitle_unfolded_summary unfolded_summary[general_name] = histo unfolded_envelope[general_name] = histo.Clone( "%s_unfolded_envelope" % general_name) unfolded_average[general_name] = histo.Clone( "%s_unfolded_average" % general_name) unfolded_summary[general_name][idx].value = mean unfolded_summary[general_name][idx].error = meanError unfolded_envelope[general_name][idx].value = mean unfolded_envelope[general_name][idx].error = sigma unfolded_average[general_name][idx].value = mean unfolded_average[general_name][idx].error = \ unfolded_sigmas['%s_bin%i' % (general_name, idx)].GetMean() plotter.set_subdir('taus') for name, histo in taus.iteritems(): #canvas = plotter.create_and_write_canvas_single(0, 21, 1, False, False, histo, write=False) plotter.canvas.cd() histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) info = plotter.make_text_box( 'mode #tau = %.5f' % histo[histo.GetMaximumBin()].x.center, position=(plotter.pad.GetLeftMargin(), plotter.pad.GetTopMargin(), 0.3, 0.025)) info.Draw() plotter.save() histo.Write() plotter.canvas.Write() plotter.set_subdir('pulls') for name, histo in pulls.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() for name, histo in pull_means.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.Write() plotter.save() for name, histo in pull_sigmas.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.Write() plotter.save() plotter.set_subdir('pull_summaries') for name, histo in pull_means_summary.iteritems(): histo = plotter.plot(histo, **styles['dots']) #histo.SetStats(True) line = ROOT.TLine(histo.GetBinLowEdge(1), 0, histo.GetBinLowEdge(histo.GetNbinsX() + 1), 0) line.Draw("same") plotter.save() histo.Write() plotter.canvas.Write() for name, histo in pull_sigmas_summary.iteritems(): histo = plotter.plot(histo, **styles['dots']) #histo.SetStats(True) line = ROOT.TLine(histo.GetBinLowEdge(1), 1, histo.GetBinLowEdge(histo.GetNbinsX() + 1), 1) line.Draw("same") plotter.save() histo.Write() plotter.canvas.Write() plotter.set_subdir('deltas') for name, histo in deltas.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() for name, histo in delta_means.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.Write() plotter.save() for name, histo in delta_sigmas.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.Write() plotter.save() plotter.set_subdir('delta_summaries') for name, histo in delta_means_summary.iteritems(): histo = plotter.plot(histo, **styles['dots']) #histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() for name, histo in delta_sigmas_summary.iteritems(): histo = plotter.plot(histo, **styles['dots']) #histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() plotter.set_subdir('unfolding_unc') for name, histo in unfolded_sigmas.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() plotter.set_subdir('unfolded') for name, histo in unfoldeds.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() plotter.set_subdir('unfolded_summaries') for name, histo in unfolded_summary.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() for name, histo in unfolded_summary.iteritems(): leg = LegendDefinition("Unfolding comparison", 'NE', labels=['Truth', 'Unfolded']) plotter.overlay_and_compare([true_distro], histo, legend_def=leg, **styles['compare']) plotter.canvas.name = 'Pull_' + name plotter.save() plotter.canvas.Write() plotter.overlay_and_compare([true_distro], histo, legend_def=leg, method='ratio', **styles['compare']) plotter.canvas.name = 'Ratio_' + name plotter.save() plotter.canvas.Write() plotter.set_subdir('unfolded_average') for name, histo in unfolded_average.iteritems(): leg = LegendDefinition("Unfolding comparison", 'NE', labels=['Truth', 'Unfolded']) #set_trace() plotter.overlay_and_compare([true_distro], histo, legend_def=leg, **styles['compare']) plotter.canvas.name = 'Pull_' + name plotter.save() plotter.canvas.Write() plotter.overlay_and_compare([true_distro], histo, legend_def=leg, method='ratio', **styles['compare']) plotter.canvas.name = 'Ratio_' + name plotter.save() plotter.canvas.Write() plotter.set_subdir('unfolded_envelope') for name, histo in unfolded_envelope.iteritems(): leg = LegendDefinition("Unfolding comparison", 'NE', labels=['Truth', 'Unfolded']) plotter.overlay_and_compare([true_distro], histo, legend_def=leg, **styles['compare']) plotter.canvas.name = 'Pull_' + name plotter.save() plotter.canvas.Write() plotter.overlay_and_compare([true_distro], histo, legend_def=leg, method='ratio', **styles['compare']) plotter.canvas.name = 'Ratio_' + name plotter.save() plotter.canvas.Write() plotter.set_subdir('figures_of_merit') for name, histo in nneg_bins.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() for name, histo in pull_sums.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() for name, histo in ratio_sums.iteritems(): histo = plotter.plot(histo, **styles['dots']) histo.SetStats(True) plotter.save() histo.Write() plotter.canvas.Write() outfile.close() os.chdir(curdir)