def main(): ############################################################################ # Make a figure on which to plot stuff. # This would be the same as making a TCanvas object. ############################################################################ fig1 = plt.figure(figsize=(8, 6), dpi=100, facecolor='w', edgecolor='k') ############################################################################ # Now divide of the figure as if we were making a bunch of TPad objects. # These are called ``subplots". # # Usage is XYZ: X=how many rows to divide. # Y=how many columns to divide. # Z=which plot to plot based on the first being '1'. # So '111' is just one plot on the main figure. ############################################################################ subplot = fig1.add_subplot(1, 1, 1) ############################################################################ # Generate values drawn from a normal (Gaussian) distribution. ############################################################################ mean = 5.0 sigma = 1.0 values = np.random.normal(mean, sigma, 10000) ############################################################################ # Histogram of the data. ############################################################################ h, xpts, ypts, xpts_err, ypts_err = lch.hist_err(values, bins=50, range=(0.0, 10.0), color='pink') # ############################################################################ # Let's format this histogram. # Note that we will do this by changing the values on the subplot (Axes), # not the histogram object. ############################################################################ subplot.set_xlim(-1, 11) subplot.set_xlabel('x variable', fontsize=20) subplot.set_ylabel('# events', fontsize=20) # Note that we can easily include Latex code subplot.set_title(r'$\mathrm{Gaussian\ distribution:}\ \mu=5,\ \sigma=1$', fontsize=30) # Set the number of tick marks on the x-axis. subplot.locator_params(nbins=8) fit_params, fit_params_errs, cov_mat = lch.fit(lichen.pdf_gaussian(), xpts, ypts, [100.0, 5.0, 1.0], yerr=ypts_err) # Need this command to display the figure. plt.show()
def main(): filenames = sys.argv[1:] print("Will open files:") for f in filenames: print(f) data = tbt.chain_pickle_files(filenames) mupt = data['mupt'] muisPF = data['muisPF'] muist = data['muist'] muiso04 = data['muiso04'] ################################################################################ plt.figure() plt.subplot(3, 3, 1) lch.hist_err(mupt, bins=100, range=(0, 100), color='k') plt.subplot(3, 3, 2) lch.hist_err(muiso04[muiso04 > 0], bins=100, range=(0, .20), color='k') plt.subplot(3, 3, 5) lch.hist_2D(mupt[muiso04 > 0], muiso04[muiso04 > 0], xbins=100, ybins=100, xrange=(0, 100), yrange=(0, .20)) #plt.xlim(50,150) #plt.ylim(0, 3.2) ################################################################################ # Cut on the wmass #index = wmass>70.0 #index *= wmass<95.0 plt.show()
def main(): ############################################################################ # Make a figure on which to plot stuff. # This would be the same as making a TCanvas object. ############################################################################ fig1 = plt.figure(figsize=(8,6),dpi=100,facecolor='w',edgecolor='k') ############################################################################ # Now divide of the figure as if we were making a bunch of TPad objects. # These are called ``subplots". # # Usage is XYZ: X=how many rows to divide. # Y=how many columns to divide. # Z=which plot to plot based on the first being '1'. # So '111' is just one plot on the main figure. ############################################################################ subplot = fig1.add_subplot(1,1,1) ############################################################################ # Generate values drawn from a normal (Gaussian) distribution. ############################################################################ mean = 5.0 sigma = 1.0 values = np.random.normal(mean,sigma,10000) ############################################################################ # Histogram of the data. ############################################################################ h,xpts,ypts,xpts_err,ypts_err = lch.hist_err(values,bins=50,range=(0.0,10.0),color='pink') # ############################################################################ # Let's format this histogram. # Note that we will do this by changing the values on the subplot (Axes), # not the histogram object. ############################################################################ subplot.set_xlim(-1,11) subplot.set_xlabel('x variable',fontsize=20) subplot.set_ylabel('# events',fontsize=20) # Note that we can easily include Latex code subplot.set_title(r'$\mathrm{Gaussian\ distribution:}\ \mu=5,\ \sigma=1$',fontsize=30) # Set the number of tick marks on the x-axis. subplot.locator_params(nbins=8) fit_params,fit_params_errs,cov_mat = lch.fit(lichen.pdf_gaussian(),xpts,ypts,[100.0,5.0,1.0],yerr=ypts_err) # Need this command to display the figure. plt.show()
p4s.append(bjet) p4s.append(jets[i]) p4s.append(jets[j]) m = invmass(p4s) #print("mass: ",m) jet3mass.append(m) jet2mass.append(invmass([jets[i], jets[j]])) muonpt = np.array(muonpt) metpt = np.array(metpt) jetbtag = np.array(jetbtag) jet3mass = np.array(jet3mass) jet2mass = np.array(jet2mass) plt.figure() lch.hist_err(metpt[metpt < 500]) plt.xlabel(r'$mising E_T$') plt.figure() lch.hist_err(muonpt[(muonpt < 200) * (muonpt > 30)]) plt.xlabel(r'$p_T \mu$') plt.figure() lch.hist_err(jetbtag[jetbtag >= 0]) plt.xlabel(r'jets b-tagging') plt.figure() lch.hist_err(jet3mass[jet3mass < 400]) plt.xlabel(r'3-jets mass') plt.figure()
ax0 = fig0.add_subplot(1,2,1) ax1 = fig0.add_subplot(1,2,2) fig0.subplots_adjust(wspace=0.20,hspace=0.10,bottom=0.15,top=0.95,left=0.10,right=0.95) ax0.set_xlim(ranges[0]) #ax0.set_ylim(0.0,50.0) #ax0.set_ylim(0.0,92.0) ax0.set_xlabel("Ionization Energy (keVee)",fontsize=12) ax0.set_ylabel("Events/0.025 keVee",fontsize=12) ax1.set_xlim(ranges[1]) ax1.set_xlabel("Days since 12/4/2009",fontsize=12) ax1.set_ylabel("Event/30.6 days",fontsize=12) lch.hist_err(data[0],bins=nbins[0],range=ranges[0],axes=ax0) h,xpts,ypts,xpts_err,ypts_err = lch.hist_err(data[1],bins=nbins[1],range=ranges[1],axes=ax1) ax1.set_ylim(0.0,600) # Do an acceptance correction of some t-bins by hand. tbwidth = (ranges[1][1]-ranges[1][0])/float(nbins[1]) acc_corr = np.zeros(len(ypts)) # For 15 bins #acc_corr[2] = tbwidth/(tbwidth-7.0) #acc_corr[3] = tbwidth/(tbwidth-6.0) #acc_corr[10] = tbwidth/(tbwidth-3.0) # For 30 bins #acc_corr[4] = tbwidth/(tbwidth-7.0) #acc_corr[6] = tbwidth/(tbwidth-6.0) #acc_corr[20] = tbwidth/(tbwidth-3.0)
elif (jets[k][4] > 1.0): wmass = inv_mass([jets[i], jets[j]]) if wmass > 70 and wmass < 100: invariant_mass_top.append(mass) ntop += 1 ntops.append(ntop) combos.append(ncombos) ################################################################## #### Find number of jets for QCD ################################################################## QCD_jets.append(len(jets)) #plt.figure(figsize=(9,9)) '''plt.figure(1) #plt.subplot(3,3,1) #plt.hist(invariant_mass_W,bins=150,range=(0,400)) lkn.hist_err(invariant_mass_W,bins=200,range=(0,400)) name = r"Hadronic Decay of W $%s$" % (sys.argv[1].split('/')[-1]) plt.title(name) plt.ylabel(r"Frequency") plt.xlabel(r"Invariant Mass")''' '''plt.figure(2) #plt.subplot(1,2,1) plt.hist(invariant_mass_Z,bins=100, range=(0,200)) #lkn.hist_err(invariant_mass_Z,bins=200) plt.xlim([0,200]) #plt.ylim([0,250]) name = r"Drell Yan Decay of Z $%s$" % (sys.argv[1].split('/')[-1])
import numpy as np import lichen.lichen as lch import matplotlib.pyplot as plt import sys vals = np.loadtxt(sys.argv[1]) days = vals[:,0] energies = vals[:,1] risetimes = vals[:,2] plt.figure(figsize=(12,4)) plt.subplot(1,3,1) lch.hist_err(energies,bins=50) plt.xlabel('Recoil energy (keVee)') plt.ylim(0) plt.subplot(1,3,2) lch.hist_err(days,bins=50) plt.xlabel('Days since XXX') plt.ylim(0) plt.subplot(1,3,3) lch.hist_err(risetimes,bins=50,range=(0,6)) plt.xlabel(r'Rise times ($\mu$s)') plt.ylim(0) plt.xlim(0,6) plt.tight_layout()
#print(bcand) for icut, cut in enumerate(cuts): for j, key in enumerate(plotvars.keys()): var = plotvars[key] print(len(var["values"][icut]) / nentries) #exit() for icut, cut in enumerate(cuts): plt.figure(figsize=(10, 6)) for j, key in enumerate(plotvars.keys()): var = plotvars[key] plt.subplot(4, 4, 1 + j) if key == "nphot" or key == "ncharged": lch.hist_err(var["values"][icut], range=var["range"], bins=20, alpha=0.2, markersize=0.5) else: lch.hist_err(var["values"][icut], range=var["range"], bins=50, alpha=0.2, markersize=0.5) plt.xlabel(var["xlabel"], fontsize=12) plt.ylabel(var["ylabel"], fontsize=12) print(len(var["values"][icut])) if icut == len(cuts) - 1: plt.figure(figsize=(10, 6)) plt.subplot(1, 1, 1)
################################################################################ # Generate fake data points and plot them ################################################################################ mu = 1.5 sigma = 0.1 x = np.random.normal(mu, sigma, 70) mylambda = 1.0 k = np.random.exponential(1 / mylambda, 1000) plt.figure() # lch.hist_err(x,bins=50,range=(0,4.0),color='red',ecolor='red') # lch.hist_err(k,bins=50,range=(0,4.0),color='blue',ecolor='blue') total = np.append(x, k) lch.hist_err(total, bins=50, range=(0, 4.0), markersize=2) ################################################################################ # Now fit the data. ################################################################################ m = Minuit( negative_log_likelihood, mu=1.0, limit_mu=(0, 3.0), sigma=1.0, limit_sigma=(0, 3.0), mylambda=1.0, limit_mylambda=(0, 3.0), fraction=0.5, limit_fraction=(0, 3.14), )
notx.append(vertexX) noty.append(vertexY) notz.append(vertexZ) #print(x, y, z) x = np.array(x) y = np.array(y) z = np.array(z) print(len(notx)) plt.figure() ax = plt.axes(projection='3d') ax.scatter(x, y, z, c='r') #ax.scatter(notx,noty,notz,c='b') #plt.show() plt.figure() plt.plot(x, y, '.', alpha=0.1) plt.figure() lch.hist_err(x) plt.figure() lch.hist_err(y) plt.figure() lch.hist_err(z) plt.show()
tree.GetEntry(i) iso = tree.electronTkIso isoH = tree.electronHCIso isoE = tree.electronECIso nelec = tree.nelectron elecPT = tree.electronpt nelecs += nelec for j in range(nelec): #if elecPT[j] >= 30 and elecPT[j] <= 100: isovarE = (iso[j] + isoH[j] + isoE[j]) / elecPT[j] isoVarE.append(isovarE) isovarB = (iso[j] + isoH[j] + max(0., isoE[j] - 1)) / elecPT[j] isoVarB.append(isovarB) #print('Max: ', max(0.,isoE[j]-1)) #print(isoE[j]) print(nelecs) plt.figure() lch.hist_err(isoVarB, bins=100, range=(0, 1)) plt.xlabel('dr03 Barrel Electron Isolation Variable') plt.figure() lch.hist_err(isoVarE, bins=100, range=(0, 1)) plt.xlabel('dr03 Endcap Electron Isolation Variable') plt.show()
# This will find the mean, sum, and stddev of an array z of some peak #index2 = energies>Xlo[3] #index3 = energies<Xhi[3] #index4 = index2*index3 index2 = energies>0.0 index3 = energies<15.0 index4 = index2*index3 print index4 z = energies[index4] t = tdays[index4] # plotting the peak plt.figure(figsize=(8,6)) #plt.hist(z) lch.hist_err(z) #plt.xlabel('amplitude') plt.xlabel('Energy (keVee)') plt.ylabel('number of events') ########################################## # plotting the time for the peak plt.figure() plt.hist(t,bins=100) plt.xlabel('time') plt.ylabel('number of events') for h_l in H_L: tau = h_l / np.log(2) t0 = 0
#print(muonpt[j]) njets = tree.njet jetpt = tree.jetpt nmuons.append(nmuon) njets.append(njet) for m in range(nmuon): mupt.append(muonpt[m]) for j in range(njet): jpt.append(jetpt[j]) mupt = np.array(mupt) plt.figure() lch.hist_err(mupt[mupt > 0], range=(0, 100)) plt.xlabel("Muon p$_T$ (GeV/c)", fontsize=18) #plt.yscale('log',nonposy = 'clip') plt.tight_layout() plt.savefig('muonpt0.png') plt.figure() lch.hist_err(mupt[mupt > 10], range=[0, 100]) plt.xlabel("Muon p$_T$ (GeV/c)", fontsize=18) plt.tight_layout() plt.savefig('muonpt1.png') plt.figure() lch.hist_err(jpt, range=(0, 300)) plt.xlabel("Jet p$_T$ (GeV/c)", fontsize=18) plt.tight_layout()
def main(): ############################################################################ # Parse the command lines. ############################################################################ parser = argparse.ArgumentParser() parser.add_argument('--fit', dest='fit', type=int,\ default=0, help='Which fit to perform (0,1,2)') parser.add_argument('--verbose', dest='verbose', action='store_true',\ default=False, help='Verbose output') parser.add_argument('--rt-parameters', dest='rt_parameters', type=str,\ default='risetime_parameters_risetime_determination_nicole.py', help='File of rise-time parameters determined from wavelet or pulser data.') parser.add_argument('--batch', dest='batch', action='store_true',\ default=False, help='Run in batch mode (exit on completion).') args = parser.parse_args() #tag = 'data_constrained_with_pulser_mean20_sigma20_slowsigfloat' #tag = 'data_constrained_with_pulser' #tag = 'data_constrained_with_simulated_Nicole' ############################################################################ ''' if args.help: parser.print_help() exit(-1) ''' # Read in the parameters from the file passed in on the commandline rt_parameters_filename = args.rt_parameters.rstrip('.py') tag = rt_parameters_filename print(("Rise-time parameters_filename: %s" % (rt_parameters_filename))) rt_parameters_file = __import__(rt_parameters_filename) risetime_parameters = getattr(rt_parameters_file,'risetime_parameters') fast_mean_rel_k,fast_sigma_rel_k,fast_num_rel_k,fast_mean0_k,fast_sigma0_k,fast_num0_k = risetime_parameters() ############################################################################ # Read in the data ############################################################################ infile_name = 'data/LE.txt' #infile_name = 'data/HE.txt' #infile_name = 'data/pulser_data.dat' tdays,energies,rise_times = get_3yr_cogent_data(infile_name,first_event=first_event,calibration=0) print (tdays) print (energies) print (rise_times) print (energies) if args.verbose: print_data(energies,tdays,rise_times) #data = [energies.copy(),tdays.copy()] #print "data before range cuts: ",len(data[0]),len(data[1]) # 3yr data data = [energies.copy(),tdays.copy(),rise_times.copy()] print(("data before range cuts: ",len(data[0]),len(data[1]),len(data[2]))) #exit() ############################################################################ # Declare the ranges. ############################################################################ ranges,subranges,nbins = parameters.fitting_parameters(args.fit) bin_widths = np.ones(len(ranges)) for i,n,r in zip(list(range(len(nbins))),nbins,ranges): bin_widths[i] = (r[1]-r[0])/n # Cut events out that fall outside the range. data = cut_events_outside_range(data,ranges) data = cut_events_outside_subrange(data,subranges[1],data_index=1) if args.verbose: print_data(energies,tdays) print(("data after range cuts: ",len(data[0]),len(data[1]))) nevents = float(len(data[0])) plt.figure() plt.plot(energies,rise_times,'o',markersize=1.5) plt.yscale('log') plt.ylim(0.1,10) plt.figure() plt.plot(tdays,rise_times,'o',markersize=1.5) plt.yscale('log') plt.ylim(0.1,10) ############################################################################ # Plot the data ############################################################################ ############################################################################ # Look at the rise-time information. ############################################################################ # For the data (two lognormals) #starting_params = [-0.6,0.6,0.2*nevents, 0.1,0.8,0.8*nevents] # For the pulser fast rise times (two lognormals) starting_params = [-0.6,0.5,0.6*nevents, 0.5,0.8,0.4*nevents] fit_parameters = [] fit_errors = [] fit_mnerrors = [] nevs = [] axrt = [] elo = 0.0 ehi = 1.0 eoffset = 0.5 ewidth = 0.100 estep = 0.100 #ewidth = 0.150 #estep = 0.150 #ewidth = 0.200 #estep = 0.050 expts = [] figcount = 0 maxrange = int((ranges[0][1]-ranges[0][0])/ewidth) #for i in range(48,-1,-1): for i in range(0,maxrange): #j = 48-i j = i if j%6==0: figrt = plt.figure(figsize=(12,6),dpi=100) axrt.append(figrt.add_subplot(2,3, i%6 + 1)) #figrt = plt.figure(figsize=(6,4),dpi=100) #axrt.append(figrt.add_subplot(1,1,1)) data_to_fit = [] #h,xpts,ypts,xpts_err,ypts_err = lch.hist_err(data[1],bins=nbins[1],range=ranges[1],axes=ax1) if i>=0: elo = i*estep + eoffset ehi = elo + ewidth index0 = data[0]>=elo index1 = data[0]< ehi print((elo,ehi)) index = index0*index1 data_to_fit = data[2][index] if len(data_to_fit)>0: lch.hist_err(data_to_fit,bins=nbins[2],range=ranges[2],axes=axrt[j]) plt.ylim(0) plt.xlim(ranges[2][0],ranges[2][1]) name = "%0.2f-%0.2f" % (elo,ehi) plt.text(0.75,0.75,name,transform=axrt[j].transAxes) print ("=======-------- E BIN ----------===========") print (name) emid = (elo+ehi)/2.0 #print "HERE ------------------------------- emid: ",emid # The entries for the narrow peak parameters. fast_mean0 = expfunc(fast_mean0_k,emid) fast_sigma0 = expfunc(fast_sigma0_k,emid) fast_num0 = expfunc(fast_num0_k,emid) # USE THIS FOR THE GAUSSIAN CONSTRAINT fast_mean0_optimal = fast_mean0 fast_mean0_uncert = 0.30*fast_mean0 fast_sigma0_optimal = fast_sigma0 fast_sigma0_uncert = 0.30*fast_sigma0 # The entries for the relationship between the broad and narrow peak. fast_mean_rel = expfunc(fast_mean_rel_k,emid) fast_sigma_rel = expfunc(fast_sigma_rel_k,emid) fast_logn_num_rel = expfunc(fast_num_rel_k,emid) fast_mean1 = fast_mean0 - fast_mean_rel fast_sigma1 = fast_sigma0 - fast_sigma_rel fast_num1 = fast_num0 / fast_logn_num_rel fast_logn_frac0 = fast_num0/(fast_num0+fast_num1) nevents = len(data_to_fit) print(("Nevents for this fit: ",nevents)) #starting_params = [-0.1,0.8,0.2*nevents, 0.6,0.52,0.8*nevents] print((starting_params[4])) #exit() ############################################################################ # Declare the fit parameters ############################################################################ params_dict = {} params_dict['flag'] = {'fix':True,'start_val':args.fit} params_dict['var_rt'] = {'fix':True,'start_val':0,'limits':(ranges[2][0],ranges[2][1])} params_dict['emid'] = {'fix':True,'start_val':emid,'limits':(ranges[0][0],ranges[0][1])} params_dict['fast_logn_mean0'] = {'fix':False,'start_val':fast_mean0,'limits':(-2,2),'error':0.01} params_dict['fast_logn_sigma0'] = {'fix':False,'start_val':fast_sigma0,'limits':(0.05,30),'error':0.01} params_dict['fast_logn_frac0'] = {'fix':True,'start_val':fast_logn_frac0,'limits':(0.0001,1.0),'error':0.01} #params_dict['fast_num'] = {'fix':False,'start_val':0.5*nevents,'limits':(0.0,1.5*nevents),'error':0.01} params_dict['fast_num'] = {'fix':False,'start_val':starting_params[2],'limits':(0.0,1.5*nevents),'error':0.01} params_dict['fast_logn_sigma0_optimal'] = {'fix':True,'start_val':fast_sigma0_optimal} params_dict['fast_logn_sigma0_uncert'] = {'fix':True,'start_val':fast_sigma0_uncert} params_dict['fast_logn_mean0_optimal'] = {'fix':True,'start_val':fast_mean0_optimal} params_dict['fast_logn_mean0_uncert'] = {'fix':True,'start_val':fast_mean0_uncert} #params_dict['fast_logn_mean1'] = {'fix':False,'start_val':starting_params[0],'limits':(-2,2),'error':0.01} #params_dict['fast_logn_sigma1'] = {'fix':False,'start_val':starting_params[1],'limits':(0.05,30),'error':0.01} #params_dict['fast_num1'] = {'fix':False,'start_val':nevents,'limits':(0.0,1.5*nevents),'error':0.01} # float them params_dict['slow_logn_mean'] = {'fix':False,'start_val':starting_params[3],'limits':(-2,2),'error':0.01} params_dict['slow_logn_sigma'] = {'fix':False,'start_val':starting_params[4],'limits':(0.05,30),'error':0.01} params_dict['slow_num'] = {'fix':False,'start_val':starting_params[5],'limits':(0.0,1.5*nevents),'error':0.01} # Fixed values params_dict['fast_mean_rel_k_0'] = {'fix':True,'start_val':fast_mean_rel_k[0],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_mean_rel_k_1'] = {'fix':True,'start_val':fast_mean_rel_k[1],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_mean_rel_k_2'] = {'fix':True,'start_val':fast_mean_rel_k[2],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_sigma_rel_k_0'] = {'fix':True,'start_val':fast_sigma_rel_k[0],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_sigma_rel_k_1'] = {'fix':True,'start_val':fast_sigma_rel_k[1],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_sigma_rel_k_2'] = {'fix':True,'start_val':fast_sigma_rel_k[2],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_num_rel_k_0'] = {'fix':True,'start_val':fast_num_rel_k[0],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_num_rel_k_1'] = {'fix':True,'start_val':fast_num_rel_k[1],'limits':(-1e6,1e6),'error':0.01} params_dict['fast_num_rel_k_2'] = {'fix':True,'start_val':fast_num_rel_k[2],'limits':(-1e6,1e6),'error':0.01} ''' if i==7: params_dict['slow_logn_mean'] = {'fix':True,'start_val':0.57,'limits':(-2,2),'error':0.01} elif i==8: params_dict['slow_logn_mean'] = {'fix':True,'start_val':0.55,'limits':(-2,2),'error':0.01} ''' # Above some value, lock this down. ''' if elo>=2.2: params_dict['slow_logn_mean'] = {'fix':True,'start_val':0.0,'limits':(-2,2),'error':0.01} params_dict['slow_logn_sigma'] = {'fix':True,'start_val':1.0,'limits':(0.05,30),'error':0.01} params_dict['slow_num'] = {'fix':True,'start_val':1,'limits':(0.0,1.5*nevents),'error':0.01} ''' ''' if i==0: None # From Nicole's simulation. #params_dict['fast_logn_mean'] = {'fix':True,'start_val':-0.10,'limits':(-2,2),'error':0.01} # From Juan #params_dict['fast_logn_mean'] = {'fix':True,'start_val':-0.60,'limits':(-2,2),'error':0.01} #params_dict['slow_logn_sigma'] = {'fix':True,'start_val':0.50,'limits':(0.05,30),'error':0.01} ''' # Try fixing the slow sigma #params_dict['slow_logn_sigma'] = {'fix':True,'start_val':0.60,'limits':(-2,2),'error':0.01} #figrt.subplots_adjust(left=0.07, bottom=0.15, right=0.95, wspace=0.2, hspace=None,top=0.85) #figrt.subplots_adjust(left=0.05, right=0.98) #figrt.subplots_adjust(left=0.15, right=0.98,bottom=0.15) figrt.subplots_adjust(left=0.07, right=0.98,bottom=0.10) #plt.show() #exit() ############################################################################ # Fit ############################################################################ if i>=0 and len(data_to_fit)>0: params_names,kwd = fitutils.dict2kwd(params_dict) #print data_to_fit f = fitutils.Minuit_FCN([[data_to_fit]],params_dict,emlf) # For maximum likelihood method. kwd['errordef'] = 0.5 kwd['print_level'] = 0 #print kwd m = minuit.Minuit(f,**kwd) m.print_param() m.migrad() #m.hesse() m.minos() print ("Finished fit!!\n") values = m.values # Dictionary errors = m.errors # Dictionary mnerrors = m.get_merrors() print ("MNERRORS: ") print (mnerrors) fit_parameters.append(values) fit_errors.append(errors) fit_mnerrors.append(mnerrors) nevs.append(len(data_to_fit)) xpts = np.linspace(ranges[2][0],ranges[2][1],1000) tot_ypts = np.zeros(len(xpts)) # The entries for the relationship between the broad and narrow peak. fast_logn_mean_rel = expfunc(fast_mean_rel_k,values['emid']) fast_logn_sigma_rel = expfunc(fast_sigma_rel_k,values['emid']) fast_logn_num_rel = expfunc(fast_num_rel_k,values['emid']) fast_logn_mean1 = values['fast_logn_mean0'] - fast_logn_mean_rel fast_logn_sigma1 = values['fast_logn_sigma0'] - fast_logn_sigma_rel tot_ypts_fast = np.zeros(len(xpts)) ypts = pdfs.lognormal(xpts,values['fast_logn_mean0'],values['fast_logn_sigma0'],ranges[2][0],ranges[2][1]) y,plot = plot_pdf(xpts,ypts,bin_width=bin_widths[2],scale=values['fast_logn_frac0']*values['fast_num'],fmt='r--',linewidth=2,axes=axrt[j]) tot_ypts += y tot_ypts_fast += y # Only plot the second narrow bump above some value. if emid<=3.9: ypts = pdfs.lognormal(xpts,fast_logn_mean1,fast_logn_sigma1,ranges[2][0],ranges[2][1]) y,plot = plot_pdf(xpts,ypts,bin_width=bin_widths[2],scale=(1.0-values['fast_logn_frac0'])*values['fast_num'],fmt='r--',linewidth=2,axes=axrt[j]) tot_ypts += y tot_ypts_fast += y ypts = pdfs.lognormal(xpts,values['slow_logn_mean'],values['slow_logn_sigma'],ranges[2][0],ranges[2][1]) y,plot = plot_pdf(xpts,ypts,bin_width=bin_widths[2],scale=values['slow_num'],fmt='b-',linewidth=2,axes=axrt[j]) tot_ypts += y axrt[j].plot(xpts,tot_ypts_fast,'r-',linewidth=2) axrt[j].plot(xpts,tot_ypts,'m',linewidth=2) axrt[j].set_ylabel(r'Events') axrt[j].set_xlabel(r'Rise time ($\mu$s)') axrt[j].set_xlim(0,5.0) if j%6==5: name = "Plots/rt_slice_%s_%d.png" % (tag,figcount) plt.savefig(name) figcount += 1 #''' if math.isnan(values['fast_logn_mean0']) == False: starting_params = [ \ values['fast_logn_mean0'], \ values['fast_logn_sigma0'], \ values['fast_num'], \ values['slow_logn_mean'], \ values['slow_logn_sigma'], values['slow_num'] \ ] #''' expts.append((ehi+elo)/2.0) #plt.show() #exit() print (fit_parameters) print (nevs) ypts = [[],[],[],[],[],[]] yerr = [[],[],[],[],[],[]] yerrlo = [[],[],[],[],[],[]] yerrhi = [[],[],[],[],[],[]] npts = [] if len(expts)>0: #for i,fp,fe,n in zip(xrange(len(nevs)),fit_parameters,fit_errors,nevs): for i,fp,fe,n in zip(list(range(len(nevs))),fit_parameters,fit_mnerrors,nevs): print ("----------") #ypts[0].append(fp['fast_logn_mean']) #ypts[1].append(fp['fast_logn_sigma']) #ypts[2].append(fp['fast_num']) #ypts[3].append(fp['slow_logn_mean']) #ypts[4].append(fp['slow_logn_sigma']) #ypts[5].append(fp['slow_num']) pars = ['fast_logn_mean0','fast_logn_sigma0','fast_num',\ 'slow_logn_mean','slow_logn_sigma','slow_num'] for i,p in enumerate(pars): #print "key ",p #if fe.has_key(p): if p in fe: ypts[i].append(fp[p]) #print "val: ",fp[p] yerrlo[i].append(abs(fe[p]['lower'])) yerrhi[i].append(abs(fe[p]['upper'])) elif p=='slow_logn_sigma': ypts[i].append(starting_params[4]) yerrlo[i].append(0.0) yerrhi[i].append(0.0) else: ypts[i].append(0.0) yerrlo[i].append(0.0) yerrhi[i].append(0.0) npts.append(n) for i in range(len(ypts)): ypts[i] = np.array(ypts[i]) yerrlo[i] = np.array(yerrlo[i]) yerrhi[i] = np.array(yerrhi[i]) colors = ['r','b'] labels = ['fast','slow'] # Use all or some of the points nfitpts = len(expts) #xp = np.linspace(min(expts),max(expts),100) print ("herherherkehre") print (nfitpts) print (expts) xp = np.linspace(min(expts),expts[nfitpts-1],100) expts = np.array(expts) yfitpts = [] ''' fvals2 = plt.figure(figsize=(13,6),dpi=100) for k in range(0,3): # Some of the broad rise times are set to 0. #index0s = ypts[3+k]!=0 index0s = np.ones(len(ypts[3+k])).astype(bool) #index0s = np.ones(nfitpts).astype(bool) fvals2.add_subplot(2,3,k+1) tempypts = ypts[0+k]-ypts[3+k] # Fractional error tempyerrlo = np.sqrt((yerrlo[0+k])**2 + (yerrlo[3+k])**2) tempyerrhi = np.sqrt((yerrhi[0+k])**2 + (yerrhi[3+k])**2) if k>1: tempypts = ypts[0+k][index0s]/ypts[3+k][index0s] tempyerrlo = np.sqrt((yerrlo[0+k][index0s]/ypts[3+k][index0s])**2 + (yerrlo[3+k][index0s]*(ypts[0+k][index0s]/(ypts[3+k][index0s]**2)))**2) tempyerrhi = np.sqrt((yerrhi[0+k][index0s]/ypts[3+k][index0s])**2 + (yerrhi[3+k][index0s]*(ypts[0+k][index0s]/(ypts[3+k][index0s]**2)))**2) print expts print index0s print expts[index0s] print tempypts[index0s] print tempyerrlo[index0s] print tempyerrhi[index0s] plt.errorbar(expts[index0s],tempypts[index0s],xerr=0.01,yerr=[tempyerrlo[index0s],tempyerrhi[index0s]],\ fmt='o',ecolor='k',mec='k',mfc='m',label='Ratio') plt.xlim(0.5,3.5) ######################################################################## # Fit to exponentials. ######################################################################## pinit = [1,1,1] if k==0: pinit = [1.0, 1.0, -1.2] elif k==1: pinit = [1.0, -1.0, -0.5] elif k==2: pinit = [-2.0, 1.0, 2.0] index = np.arange(0,len(tempypts)) print "WHHHHYYYYYY" print expts print index print expts[index] print tempypts[index] print tempyerrlo[index] print tempyerrhi[index] if sum(tempypts[index]) > 0: out = leastsq(errfunc, pinit, args=(expts[index], tempypts[index], (tempyerrlo[index]+tempyerrhi[index])/2.0), full_output=1) z = out[0] zcov = out[1] print "Differences and ratios: %d [%f,%f,%f]" % (k,z[0],z[1],z[2]) #print "zcov: ",zcov if zcov is not None: print "Differences and ratios: %d [%f,%f,%f]" % (k,np.sqrt(zcov[0][0]),np.sqrt(zcov[1][1]),np.sqrt(zcov[2][2])) yfitpts = expfunc(z,xp) #print zcov plt.plot(xp,yfitpts,'-',color='m') ''' ######################################################################## # Try to fit the individual distributions. ######################################################################## # To hold the means and widths for the fast and slow rise-time distributions. means = [] sigmas = [] yfitpts = [] for i in range(0,6): yfitpts.append(np.zeros(len(xp))) fvals = plt.figure(figsize=(13,4),dpi=100) for k in range(0,3): fvals.add_subplot(1,3,k+1) for ik in range(0,2): nindex = k+3*ik plt.errorbar(expts,ypts[nindex],xerr=0.01,yerr=[yerrlo[nindex],yerrhi[nindex]],\ fmt='o',ecolor='k',mec='k',mfc=colors[ik],label=labels[ik]) #''' # Use part of the data #index0 = np.arange(0,3) #index1 = np.arange(7,len(expts)) #index = np.append(index0,index1) # Use all or some of the points index = np.arange(0,len(expts)) #index = np.arange(0,20) if ik>0: index = np.arange(0,len(expts)) #print index index = index[index!=7] index = index[index!=8] index = index[index!=17] index = index[index!=18] index = index[index!=19] ######################################################################## # Fit to exponentials. ######################################################################## pinit = [1,1,1] if ik==0 and k==0: pinit = [1.0, 1.0, -1.2] elif ik==0 and k==1: pinit = [4.0, 2.0, 0.0] elif ik==0 and k==2: pinit = [2.0, 2000.0, 300.0] elif ik==1 and k==0: pinit = [3.0, 1.5, 0.5] elif ik==1 and k==1: pinit = [0.5, -0.1] # For linear ft #pinit = [0.0001, 0.0001, starting_params[4]] # For exponential #print "before fit: ",ypts[nindex][index],yerrlo[nindex][index],yerrhi[nindex][index] print(("Fitting data!!!!!! --------------- %d %d" % (k,ik))) #print "before fit: ",ypts[nindex][index] if abs(sum(ypts[nindex][index])) > 0 and k<2: print ("FITTING -----------") #print expts[index] #print ypts[nindex][index] if k==1 and ik==1: ########## FIT WITH LINEAR TERM FOR SLOW SIGMA out = leastsq(errfunc1, pinit, args=(expts[index], ypts[nindex][index], (yerrlo[nindex][index]+yerrhi[nindex][index])/2.0), full_output=1) z = out[0] zcov = out[1] print(("Data points: %d %d [%f,%f]" % (k,ik,z[0],z[1]))) sigmas.append([z[0],z[1]]) ''' if zcov is not None: print "Data points: %d %d [%f,%f]" % (k,ik,np.sqrt(zcov[0][0]),np.sqrt(zcov[1][1])) ''' yfitpts[nindex] = expfunc1(z,xp) #print zcov #print plt.gca() plt.plot(xp,yfitpts[nindex],'-',color=colors[ik]) else: out = leastsq(errfunc, pinit, args=(expts[index], ypts[nindex][index], (yerrlo[nindex][index]+yerrhi[nindex][index])/2.0), full_output=1) z = out[0] zcov = out[1] print(("Data points: %d %d [%f,%f,%f]" % (k,ik,z[0],z[1],z[2]))) if k==1 and ik==0: sigmas.append([z[0],z[1],z[2]]) elif k==0: means.append([z[0],z[1],z[2]]) ''' if zcov is not None: print "Data points: %d %d [%f,%f,%f]" % (k,ik,np.sqrt(zcov[0][0]),np.sqrt(zcov[1][1]),np.sqrt(zcov[2][2])) ''' yfitpts[nindex] = expfunc(z,xp) #print zcov #print plt.gca() plt.plot(xp,yfitpts[nindex],'-',color=colors[ik]) if k==0: plt.ylim(-1.5,1.5) elif k==1: plt.ylim(0.0,1.5) plt.xlabel('Energy (keVee)') if k==0: plt.ylabel(r'Lognormal $\mu$') elif k==1: plt.ylabel(r'Lognormal $\sigma$') elif k==2: plt.ylabel(r'Number of events') plt.legend() #fval ''' fvals.add_subplot(2,3,4) plt.plot(xp,yfitpts[3]-yfitpts[0],'-',color='m') fvals.add_subplot(2,3,5) plt.plot(xp,yfitpts[4]-yfitpts[1],'-',color='m') fvals.add_subplot(2,3,6) plt.plot(xp,yfitpts[5]/yfitpts[2],'-',color='m') ''' fvals.subplots_adjust(left=0.10, right=0.98,bottom=0.15,wspace=0.25,hspace=0.25) name = 'Plots/rt_summary_%s_0.png' % (tag) plt.savefig(name) np.savetxt('rt_parameters.txt',[expts,ypts[0],ypts[1],ypts[2],ypts[3],ypts[4],ypts[5],npts]) #''' #print "Sum ypts[5]: ",sum(ypts[5]) print (means) print (sigmas) print((fast_mean_rel_k,fast_sigma_rel_k,fast_num_rel_k)) outfilename = "risetime_parameters_from_data_%s.py" % (tag) outfile = open(outfilename,'w') outfile.write("def risetime_parameters():\n\n") output = "\n\t%s = [%f,%f,%f]\n" % ("fast_mean_rel_k",fast_mean_rel_k[0],fast_mean_rel_k[1],fast_mean_rel_k[2]) outfile.write(output) output = "\t%s = [%f,%f,%f]\n" % ("fast_sigma_rel_k",fast_sigma_rel_k[0],fast_sigma_rel_k[1],fast_sigma_rel_k[2]) outfile.write(output) output = "\t%s = [%f,%f,%f]\n" % ("fast_num_rel_k",fast_num_rel_k[0],fast_num_rel_k[1],fast_num_rel_k[2]) outfile.write(output) output = "\n\t%s = [%f,%f,%f]\n" % ("mu0",means[0][0],means[0][1],means[0][2]) outfile.write(output) output = "\t%s = [%f,%f,%f]\n" % ("sigma0",sigmas[0][0],sigmas[0][1],sigmas[0][2]) outfile.write(output) output = "\n\t%s = [%f,%f,%f]\n" % ("mu1",means[1][0],means[1][1],means[1][2]) outfile.write(output) output = "\t%s = [%f,%f] # This has only two parameters.\n" % ("sigma1",sigmas[1][0],sigmas[1][1]) outfile.write(output) output = "\n\treturn fast_mean_rel_k,fast_sigma_rel_k,fast_num_rel_k,mu0,sigma0,mu1,sigma1\n" outfile.write(output) if not args.batch: plt.show()
fig0 = plt.figure(figsize=(12,4),dpi=100) ax00 = fig0.add_subplot(1,2,1) ax01 = fig0.add_subplot(1,2,2) ################################################################################ # Generate the fitting templates ################################################################################ mu = 2.0 sigma = 0.2 ngen = 100000 nbins = 100 ranges = [0.0, 5.0] data = np.random.normal(mu,sigma,ngen) h,xpts,ypts,xpts_err,ypts_err = lch.hist_err(data,bins=nbins,range=ranges,axes=ax00) norm = float(sum(ypts)) template0 = [xpts.copy(),ypts.copy()/norm] yexp = stats.expon(loc=0.0,scale=6.0) data = yexp.rvs(ngen) data = data[data<ranges[1]] h,xpts,ypts,xpts_err,ypts_err = lch.hist_err(data,bins=nbins,range=ranges,axes=ax01) norm = float(sum(ypts)) template1 = [xpts.copy(),ypts.copy()/norm] print template0 print template1
tree.GetEntry(i) jetbtag = tree.jetbtag jpt = tree.jetpt njets = tree.njet for j in range(njets): btags.append(jetbtag[j]) jetpt.append(jpt[j]) #print(jetbtag[j]) btags = np.array(btags) jetpt = np.array(jetpt) plt.figure() lch.hist_err(btags, bins=100, range=(0, 1.25)) plt.xlabel("b-tagging variable", fontsize=18) plt.figure() lch.hist_err(btags[jetpt < 30], bins=100, range=(0, 1.25)) plt.xlabel("CSV2 b-tag output, jet p$_T < $ 30", fontsize=18) plt.savefig('/home/me25hage/Top_BNV/test/images/btagminus30.png') #plt.savefig('btagminus.png') plt.figure() #lch.hist_err(btags[jetpt>=30],bins=100,range=(0,1.25)) plt.hist(btags[jetpt >= 30], bins=100, range=(0, 1.25)) plt.xlabel("CSV2 b-tag output, jet p$_T >= $ 30", fontsize=18) plt.savefig("/home/me25hage/Top_BNV/test/images/btagplus30.png") plt.figure()
t0=d_tools.return_top_decays(pdgs) top_pt.append(pts[t0[0][0]]) top_pt.append(pts[t0[1][0]]) W_pt.append(pts[t0[0][1]]) W_pt.append(pts[t0[1][1]]) bottom_pt.append(pts[t0[0][2]]) bottom_pt.append(pts[t0[1][2]]) plt.figure(1) #plt.hist(top_pt,bins=50) lkn.hist_err(top_pt,bins=50, range=[400,600]) plt.title(r"$t$ $\bar{t}$ $p$$_t$") '''plt.figure(2) #plt.hist(W_pt,bins=50) lkn.hist_err(W_pt,bins=50) plt.title("W and Anti_W Pt")''' plt.figure(3) #plt.hist(bottom_pt,bins=50) lkn.hist_err(bottom_pt,bins=50) plt.title(r"$b$ $\bar{b}$ $p$$_t$") plt.figure (4) #plt.hist(muon_pt,bins=50)
top=0.95, left=0.10, right=0.95) ax0.set_xlim(ranges[0]) #ax0.set_ylim(0.0,50.0) #ax0.set_ylim(0.0,92.0) ax0.set_xlabel("Ionization Energy (keVee)", fontsize=12) ax0.set_ylabel("Events/0.025 keVee", fontsize=12) ax1.set_xlim(ranges[1]) ax1.set_xlabel("Days since 12/4/2009", fontsize=12) ax1.set_ylabel("Event/30.6 days", fontsize=12) lch.hist_err(data[0], bins=nbins[0], range=ranges[0], axes=ax0) h, xpts, ypts, xpts_err, ypts_err = lch.hist_err(data[1], bins=nbins[1], range=ranges[1], axes=ax1) ax1.set_ylim(0.0, 600) # Do an acceptance correction of some t-bins by hand. tbwidth = (ranges[1][1] - ranges[1][0]) / float(nbins[1]) acc_corr = np.zeros(len(ypts)) # For 15 bins #acc_corr[2] = tbwidth/(tbwidth-7.0) #acc_corr[3] = tbwidth/(tbwidth-6.0) #acc_corr[10] = tbwidth/(tbwidth-3.0) # For 30 bins
ntops.append(ntop) combos.append(ncombos) ################################################################## #### Find number of jets for QCD ################################################################## QCD_jets.append(len(jets)) #plt.figure(figsize=(9,9)) '''plt.figure(1) #plt.subplot(3,3,1) #plt.hist(invariant_mass_W,bins=150,range=(0,400)) lkn.hist_err(invariant_mass_W,bins=200,range=(0,400)) name = r"Hadronic Decay of W $%s$" % (sys.argv[1].split('/')[-1]) plt.title(name) plt.ylabel(r"Frequency") plt.xlabel(r"Invariant Mass")''' '''plt.figure(2) #plt.subplot(1,2,1) plt.hist(invariant_mass_Z,bins=100, range=(0,200)) #lkn.hist_err(invariant_mass_Z,bins=200) plt.xlim([0,200]) #plt.ylim([0,250])
#find the percentage of top quark events that #have a pt>400 count = 0 for pt in top_pt: if pt > 400: count += 1 fraction = float(count)/len(top_pt) print "Fraction of top with pt>400: %f" % (fraction) ''' ###################################################### tag = sys.argv[1].split('/')[-1].split('.')[0] plt.figure() lch.hist_err(top_mass,bins=50,range=(0,500)) plt.title("%s: Top Mass" % (tag)) ''' plt.figure() plt.subplot(121) lch.hist_err(top_momentum,bins=50,range=(0,1500)) plt.title("%s: Top momentum" % (tag)) plt.subplot(122) lch.hist_err(top_pt,bins=50,range=(0,400)) plt.title("%s: Top pt" % (tag)) '''
xlo = 0.133 xhi = 0.1470 mu = (xlo + xhi) / 2 sigma = 0.0085 slope = 0.5 # Index the range of energies index0 = energies > xlo index1 = energies < xhi index = index0 * index1 x = energies[index] plt.figure() lch.hist_err(x, bins=50) ################################################################################ # Now fit the data. # Mean # width # slope # number of events in Gaussian # number of events in background ################################################################################ npts = len(x) print "npts: ", npts params_starting_vals = [mu, sigma, slope, 0.95 * npts, 0.05 * npts] fixed_parameters = [xlo, xhi, npts] params_final_vals = optimize.fmin(negative_log_likelihood, params_starting_vals[:],
tdays,energies = cu.get_cogent_data(infile_name,first_event=first_event,calibration=999) # peaks go from high amplitued to low amplitude xlo = [0.170,0.1566,0.1475,0.1330,0.120,0.106,0.106,0.106,0.97,0.088,0.080,0.073] xhi = [0.178,0.1690,0.1565,0.1470,0.124,0.116,0.116,0.116,0.104,0.95,0.087,0.080] index0 = energies>xlo[-1] index1 = energies<xhi[0] index = index0*index1 x = energies[index] print x plt.figure() lch.hist_err(x,bins=200) ################################################################################ # Now fit the data. # Mean # width # slope # number of events in Gaussian # number of events in background ################################################################################ npts = len(x) print "npts: ",npts mu = np.ones(len(xlo)) sigma = np.ones(len(xlo)) nsig = np.ones(len(xlo))
for i in range(nmuon): v = tree.muonpt[i] #print(v) values.append(v) for i in range(njet): v = tree.jetpt[i] #print(v) valuesjet.append(v) values = np.array(values) valuesjet = np.array(valuesjet) valueselectron = np.array(valueselectron) plt.figure() lch.hist_err(values[values < 200]) plt.xlabel(r'$p_T \mu$') plt.figure() lch.hist_err(valuesjet[valuesjet < 200]) plt.xlabel(r'$p_T {\rm jets}$') plt.figure() lch.hist_err(valueselectron[valueselectron < 200]) plt.xlabel(r'$p_T e$') plt.figure() plt.subplot(1, 2, 1) lch.hist_err(valuesmet[0]) plt.subplot(1, 2, 2) lch.hist_err(valuesmet[1])
plots = [numMuons, muonPX, muonPY, muonPZ, muonPT, muonE, muonPhi, muonEta] titles = [ "numMuons", "muonPX", "muonPY", "muonPZ", "muonPT", "muonE", "muonPhi", "muonEta" ] bins = 50 plt.figure(figsize=(10, len(plots) * 5)) plt.subplots_adjust(hspace=.75) for i, m in enumerate(plots): plot = plots[i] plt.subplot(len(plots) / 2 + 4, 2, i + 1) plt.hist(plot, bins) lch.hist_err(plot, bins) plt.title(titles[i]) etaDiff = [] for e in range(len(muonEta)): etaDiff.append(muonEta[e] - etaFunction[e]) plt.subplot(len(plots) / 2 + 4, 2, i + 2) plt.hist(etaDiff, bins) lch.hist_err(etaDiff, bins) plt.title("Eta Difference") phiDiff = [] for p in range(len(muonPhi)):
def main(): #lumi_file_name = 'lumi_info.pkl' #lumi_info = pickle.load( open( lumi_file_name, "rb" ) ) filenames = sys.argv[1:] #data,tot_lumi = tbt.chain_pickle_files(filenames,lumi_info) #print("tot_lumi: ",tot_lumi) T = ROOT.TChain("T") print("Will open files:") for f in filenames: print(f) T.Add(f) ntops = [] topmass = [] wmass = [] csvs = [] angles = [] dRs = [] wH = [] njets = [] leadmupt = [] leadmueta = [] subleadmupt = [] subleadmueta = [] metpt = [] triggers = [[], [], [], []] nentries = T.GetEntries() for i in range(nentries): T.GetEntry(i) njets.append(T.njet) ntop = T.ntop ntops.append(ntop) for n in range(ntop): topmass.append(T.topmass[n]) wmass.append(T.wmass[n]) dRs.append(T.wdR[n]) wH.append(T.wH[n]) angles.append(T.wangle[n]) for n in range(T.njet): csvs.append(T.jetcsv[n]) leadmupt.append(T.leadmupt) leadmueta.append(T.leadmueta) subleadmupt.append(T.subleadmupt) subleadmueta.append(T.subleadmueta) metpt.append(T.METpt) triggers[0].append(T.trig_HLT_IsoMu24_accept) triggers[1].append(T.trig_HLT_IsoTkMu24_accept) triggers[2].append(T.trig_HLT_IsoMu22_eta2p1_accept) triggers[3].append(T.trig_HLT_IsoTkMu22_eta2p1_accept) ntops = np.array(ntops) topmass = np.array(topmass) wmass = np.array(wmass) csvs = np.array(csvs) angles = np.array(angles) dRs = np.array(dRs) wH = np.array(wH) njets = np.array(njets) leadmupt = np.array(leadmupt) leadmueta = np.array(leadmueta) subleadmupt = np.array(subleadmupt) subleadmueta = np.array(subleadmueta) metpt = np.array(metpt) triggers[0] = np.array(triggers[0]) triggers[1] = np.array(triggers[1]) triggers[2] = np.array(triggers[2]) triggers[3] = np.array(triggers[3]) ''' for a in zip(topmass, wmass, csvs, angles, dRs, njets): print(a) a = np.array(a) ''' ################################################################################ plt.figure() plt.subplot(3, 3, 1) lch.hist_err(topmass, bins=100, range=(0, 600), color='k') plt.xlabel('Top Mass (GeV)') plt.subplot(3, 3, 2) lch.hist_err(wmass, bins=100, range=(0, 300), color='k') plt.xlabel('W Mass (GeV)') plt.subplot(3, 3, 3) lch.hist_err(csvs, bins=110, range=(-11, 1.1), color='k') plt.xlabel('CSV variable') plt.subplot(3, 3, 4) lch.hist_err(angles, bins=100, range=(0, 3.2), color='k') plt.xlabel('Angles') plt.subplot(3, 3, 5) #plt.plot(wmass,angles,'.',markersize=0.5,alpha=0.2) lch.hist_2D(wmass, angles, xbins=100, ybins=100, xrange=(0, 300), yrange=(0, 3.14)) plt.xlim(50, 150) plt.ylim(0, 3.2) plt.xlabel('W Mass') plt.ylabel('Angles') plt.subplot(3, 3, 6) lch.hist_err(dRs, bins=100, range=(0, 3.2), color='k') plt.xlabel('dRs') plt.subplot(3, 3, 7) lch.hist_2D(dRs, angles, xbins=100, ybins=100, xrange=(0, 6.28), yrange=(0, 3.14)) plt.xlabel('dRs') plt.ylabel('Angles') plt.subplot(3, 3, 8) lch.hist_err(wH, bins=100, range=(0, 250), color='k') plt.xlabel('scalar H') plt.subplot(3, 3, 9) lch.hist_err(ntops, bins=6, range=(0, 6), color='k') plt.xlabel('ntops') plt.tight_layout() ################################################################################ # Cut on the wmass index = wmass > 70.0 index *= wmass < 95.0 #index = (np.abs(angles - dRs)<=0.45) plt.figure() plt.title('W Mass Cuts') plt.subplot(3, 3, 1) lch.hist_err(topmass[index], bins=100, range=(0, 600), color='k') plt.xlabel('Top Mass (GeV)') plt.subplot(3, 3, 2) lch.hist_err(wmass[index], bins=100, range=(0, 300), color='k') plt.xlabel('W Mass (GeV)') plt.subplot(3, 3, 4) lch.hist_err(angles[index], bins=100, range=(0, 3.2), color='k') plt.xlabel('Angles') plt.subplot(3, 3, 5) #plt.plot(wmass[index],angles[index],'.',markersize=0.5,alpha=0.2) lch.hist_2D(wmass[index], angles[index], xbins=100, ybins=100, xrange=(0, 300), yrange=(0, 3.14)) plt.xlim(50, 150) plt.ylim(0, 3.2) plt.xlabel('W Mass') plt.ylabel('Angles') plt.subplot(3, 3, 6) lch.hist_err(dRs[index], bins=100, range=(0, 3.2), color='k') plt.xlabel('dRs') plt.subplot(3, 3, 7) lch.hist_2D(dRs[index], angles[index], xbins=100, ybins=100, xrange=(0, 6.28), yrange=(0, 3.14)) plt.xlabel('dRs') plt.ylabel('Angles') plt.subplot(3, 3, 8) lch.hist_err(wH[index], bins=100, range=(0, 250), color='k') plt.xlabel('scalar H') plt.tight_layout() ############################################################################ # Muons ############################################################################ plt.figure() plt.subplot(3, 3, 1) lch.hist_err(leadmupt, bins=100, range=(0, 250), color='k') plt.xlabel(r'Leading muon p$_{T}$ (GeV/c)') plt.subplot(3, 3, 2) lch.hist_err(leadmueta, bins=100, range=(-3.0, 3.0), color='k') plt.xlabel(r'Leading muon $\eta$ (GeV/c)') plt.subplot(3, 3, 4) lch.hist_err(subleadmupt, bins=100, range=(0, 250), color='k') plt.xlabel(r'Sub-leading muon p$_{T}$ (GeV/c)') plt.subplot(3, 3, 5) lch.hist_err(subleadmueta, bins=100, range=(-3.0, 3.0), color='k') plt.xlabel(r'Sub-leading muon $\eta$ (GeV/c)') plt.subplot(3, 3, 7) lch.hist_err(metpt, bins=100, range=(0.0, 100.0), color='k') plt.xlabel(r'Missing E$_T$ (GeV)') plt.tight_layout() ''' # For talk plt.figure() lch.hist_err(topmass[index],bins=100,range=(0,600),color='k') plt.hist(topmass[index],bins=100,range=(0,600),color='grey',alpha=0.2) plt.xlabel(r'Top candidate with W-mass cut (GeV/c$^2$)',fontsize=14) plt.tight_layout() plt.savefig('top.png') plt.figure() lch.hist_err(wmass,bins=100,range=(0,300),color='k') plt.hist(wmass,bins=100,range=(0,300),color='grey',alpha=0.2) plt.xlabel(r'W candidate (GeV/c$^2$)',fontsize=14) plt.tight_layout() plt.savefig('W.png') plt.figure() lch.hist_err(csvs,bins=110,range=(0,1.1),color='k') plt.hist(csvs,bins=100,range=(0,1.1),color='grey',alpha=0.2) plt.xlabel(r'CSVv2 variable',fontsize=14) plt.tight_layout() plt.savefig('csvv2.png') ''' ############################################################################ # Triggers ############################################################################ plt.figure() plt.subplot(5, 4, 1) lch.hist_err(triggers[0], bins=2, range=(0, 2), color='k') plt.xlabel(r'Trigger 0') plt.subplot(5, 4, 2) lch.hist_err(triggers[1], bins=2, range=(0, 2), color='k') plt.xlabel(r'Trigger 1') plt.subplot(5, 4, 3) lch.hist_err(triggers[2], bins=2, range=(0, 2), color='k') plt.xlabel(r'Trigger 2') plt.subplot(5, 4, 4) lch.hist_err(triggers[3], bins=2, range=(0, 2), color='k') plt.xlabel(r'Trigger 3') for i in range(0, 4): for j in range(0, 4): plt.subplot(5, 4, 5 + i * 4 + j) lch.hist_err(triggers[i][triggers[j] == 1], bins=2, range=(0, 2)) plt.tight_layout() plt.show()
p_photons[npp] = p npp += 1 p = mets(met) p_met[nm] = p nm += 1 ########################################################################### tag = sys.argv[1].split('/')[-1].split('.')[0] print "Making the plots....." # Histograms of momentum plt.figure() plt.subplot(321) lch.hist_err(p_jets[p_jets>-999],bins=50,range=(0,400),fmt='o',markersize=5,color='black',ecolor='black') plt.title("%s: Jet momentum" % (tag)) plt.locator_params(nbins=6) #plt.xlabel("Momentum") plt.subplot(322) lch.hist_err(p_muons[p_muons>-999],bins=50,range=(0,300),fmt='o',markersize=5,color='red',ecolor='red') plt.title("%s: Muon momentum" % (tag)) #plt.xlabel("Momentum") plt.subplot(323) lch.hist_err(p_electrons[p_electrons>-999],bins=50,range=(0,200),fmt='o',markersize=5,color='green',ecolor='green') plt.title("%s: Electron momentum" % (tag)) #plt.xlabel("Momentum") plt.subplot(324)
#print days #print energies #print risetimes days = org_days[index] energies = org_energies[index] risetimes = org_risetimes[index] #print days if sys.argv[2]=="0" or sys.argv[2]=="2": ################################################################################ fig = plt.figure(figsize=(8,4)) ret,xpts,ypts,xpts_err,ypts_err = lch.hist_err(energies,bins=enbins,linewidth=2,range=(elo,ehi)) name = "# interactions/ %0.2f keVee" % (ewidth) plt.ylabel(name,fontsize=14) plt.xlabel('Recoil energy (keVee)',fontsize=18) plt.ylim(0,25) # This might have to be changed for sliding or discrete plt.xlim(elo,ehi) if sys.argv[2]=="2": plt.yscale('log') plt.ylim(20) plt.tight_layout() name = "animation_plots/cogent_data_energy_%s_%04d.png" % (tag,i) plt.savefig(name) del ret,xpts,ypts,xpts_err,ypts_err ################################################################################
val = deltat_range*np.random.rand()+deltat_min prob = pdfs.pdf_bmixing(val,[gamma,p_over_q,deltaM,deltaG,q1,q2]) test = max_prob*np.random.rand() if test<prob: events[i] = np.append(events[i],val) n += 1 subplots[0][i].set_xlim(0) for i in range(0,4): #subplots[1][i].hist(events[i],bins=50) figs[1].add_subplot(2,2,i+1) lch.hist_err(events[i],bins=50) subplots[1][i].set_xlim(deltat_min,deltat_max) subplots[1][i].set_ylim(0) #subplots[1][i].set_ylim(0,nevents/16) Npp = len(events[0]) Nmm = len(events[1]) Npm = len(events[2]) Nmp = len(events[3]) print "%d %d %d %d" % (Npp,Nmm,Npm,Nmp) Acp = (Npp-Nmm)/float(Npp+Nmm) deltaAcp = np.sqrt((sqrt(Npp)/Npp)**2 + (sqrt(Nmm)/Nmm)**2) print "Acp: %f +/- %f" % (Acp,deltaAcp)
# find left over jets that correspond to those with highest pt other_jets = m1[m0 == mass0[i]] other_pt = pt1[m0 == mass0[i]] # sort jets that are left to find highest pt index = np.argsort(other_pt)[-1] mass1[i] = other_jets[index] i += 1 count += 1 + nvalues_for_this_event print "Events: ", len(mass0[mass0 > 0]) plt.figure() lch.hist_err(mass0[mass0 > 0], bins=125, range=(0, 1000)) plt.xlabel("mass0") # plot of highest pt plt.figure() lch.hist_err(pt0_max[pt0_max > 0], bins=125, range=(0, 1000)) plt.xlabel("pt0_max") plt.figure() lch.hist_err(mass1[mass1 > 0], bins=125, range=(0, 1000)) plt.xlabel("mass1") plt.figure() lch.hist_2D(mass0, mass1, xbins=100, ybins=100, xrange=(0, 500), yrange=(0, 500)) plt.xlabel("mass0") plt.ylabel("mass1")
#print(genpt[i]) topPT.append(genpt[i]) ''' print("The percent of boosted tops is: ", numBoosted/nentries*100) print("The percent of muon decays is: ", muonCount/nentries*100) print("The percent of electron decays is: ", electronCount/nentries*100) print("The percent of tau decays is: ", tauCount/nentries*100) pltLabels = ["$\Delta E (GeV)$","$\Delta p_x (GeV/c)$","$\Delta p_y (GeV/c)$","$\Delta p_z (GeV/c)$"] #T plt.figure() for j in range(0,4): plt.subplot(2,2,j+1) plt.xlabel(pltLabels[j],fontsize=18) lch.hist_err(diffs[j],bins=125,range=(-1,1)) plt.tight_layout() plt.suptitle('Top') plt.subplots_adjust(top = 0.88) #Tbar plt.figure() for j in range(0,4): plt.subplot(2,2,j+1) plt.xlabel(pltLabels[j] + 'tbar',fontsize=18) lch.hist_err(diffsBar[j],bins=125,range=(-1,1)) plt.tight_layout() plt.suptitle('tbar') plt.subplots_adjust(top = 0.88) #W q q
tops = [] for i in range(nentries): tree.GetEntry(i) njets = tree.njet jetpt = tree.jetpt jeteta = tree.jeteta jetphi = tree.jetphi jete = tree.jete jetp4s = [] if (njets >= 3): for jet in range(njets): jetx, jety, jetz = PTtoXYZ(jetpt[jet], jeteta[jet], jetphi[jet]) p4 = [jete[jet], jetx, jety, jetz] jetp4s.append(p4) for j in range(njets): k = j + 1 while (k < njets): top = invmass(jetp4s[j] + jetp4s[k]) #print(top) k += 1 #if (top <= 200 and top >= 150): # print(top) tops.append(top) plt.figure() lch.hist_err(tops, bins=200) plt.xlabel("Inv mass of 2 jets $(GeV/c^2)$") plt.show()
import numpy as np import matplotlib.pylab as plt import lichen.lichen as lch f = ROOT.TFile(sys.argv[1]) tree = f.Get("TreeSemiLept") nentries = tree.GetEntries() numMuons = [] muonPX = [] muonPY = [] muonPZ = [] for entry in range(nentries): tree.GetEntry(entry) nmuon = tree.nmuon numMuons.append(nmuon) for i in range(nmuon): x = tree.muonpx[i] muonPX.append(x) plt.subplot(211) lch.hist_err(numMuons) plt.subplot(212) lch.hist_err(muonPX) plt.show()
# by the detector first_event = 2750361.2 # We need to give the full path to the directory. This will obviously be # different on your machine, so you will want to edit this by hand. infile_name = '/Users/lm27apic/Documents/Dark_Matter_Research/dark_matter_data/low_gain.txt' #infile_name = '/home/bellis/matts-work-environment/PyROOT/CoGeNT/data/low_gain.txt' #infile_name = '/home/bellis/matts-work-environment/PyROOT/CoGeNT/data/high_gain.txt' tdays,energies = cu.get_cogent_data(infile_name,first_event=first_event,calibration=0) index0 = energies>0.0 index1 = energies<13.0 print len(energies) print len(index0) print len(index1) index = index0*index1 x = energies[index] plt.figure() lch.hist_err(x,bins=250,range=(0.5,12.0)) plt.xlabel('Energy (keVee)',fontsize=18) plt.ylabel('Number of Events',fontsize=18) #plt.annotate('The K-shell decays',xy=(10.8,295),xytext=(10.8,310),arrowprops=dict(arrowstyle='->')) plt.xlim(0.5,12.0) plt.yscale('log') plt.ylim(10) plt.savefig('fulldata.png') plt.show()
fig0 = plt.figure(figsize=(12,4),dpi=100) ax0 = fig0.add_subplot(1,2,1) ax1 = fig0.add_subplot(1,2,2) ax0.set_xlim(ranges[0]) #ax0.set_ylim(0.0,50.0) #ax0.set_ylim(0.0,92.0) ax0.set_xlabel("Ionization Energy (keVee)",fontsize=12) ax0.set_ylabel("Events/0.025 keVee",fontsize=12) ax1.set_xlim(ranges[1]) ax1.set_xlabel("Days since 12/4/2009",fontsize=12) ax1.set_ylabel("Event/30.6 days",fontsize=12) lch.hist_err(data[0],bins=nbins[0],range=ranges[0],axes=ax0) h,xpts,ypts,xpts_err,ypts_err = lch.hist_err(data[1],bins=nbins[1],range=ranges[1],axes=ax1) # Do an acceptance correction of some t-bins by hand. tbwidth = (ranges[1][1]-ranges[1][0])/float(nbins[1]) acc_corr = np.zeros(len(ypts)) # For 15 bins #acc_corr[2] = tbwidth/(tbwidth-7.0) #acc_corr[3] = tbwidth/(tbwidth-6.0) #acc_corr[10] = tbwidth/(tbwidth-3.0) # For 30 bins #acc_corr[4] = tbwidth/(tbwidth-7.0) #acc_corr[6] = tbwidth/(tbwidth-6.0) #acc_corr[20] = tbwidth/(tbwidth-3.0) # For 30 bins,full dataset acc_corr[2] = tbwidth/(tbwidth-7.0)
jetjeceta[jet], jetjecphi[jet]) p4JEC = [jetjece[jet], jetxJEC, jetyJEC, jetzJEC] jetp4JEC.append(p4JEC) if btag: for b in range(len(btagJets)): for j in range(0, len(jetp4) - 1): for k in range(j + 1, len(jetp4)): top.append(invmass([btagJets[b], jetp4[j], jetp4[k]])) topJEC.append( invmass([btagJetsJEC[b], jetp4JEC[j], jetp4JEC[k]])) #print("---------") #print(btagJetsJEC[b],jetp4JEC[j],jetp4JEC[k]) twoJets.append(invmass([jetp4[j], jetp4[k]])) twoJetsJEC.append(invmass([jetp4JEC[j], jetp4JEC[k]])) plt.figure() lch.hist_err(top, bins=100, range=(0, 400), color='red', label='Before') lch.hist_err(topJEC, bins=100, range=(0, 400), color='blue', label='After') plt.xlabel("Invariant mass of 3 jets (GeV/c$^2$)", fontsize=18) plt.legend() plt.figure() lch.hist_err(twoJets, bins=100, range=(0, 250), color='red', label='Before') lch.hist_err(twoJetsJEC, bins=100, range=(0, 250), color='blue', label='After') plt.xlabel("Invariant mass of 2 jets (GeV/c$^2$)", fontsize=18) plt.legend() plt.show()
####################################################### #find the percentage of top quark events that #have a pt>400 count = 0 for pt in top_pt: if pt > 400: count += 1 fraction = float(count)/len(top_pt) print "Fraction of top with pt>400: %f" % (fraction) ###################################################### tag = sys.argv[1].split('/')[-1].split('.')[0] plt.figure() lch.hist_err(top_mass,bins=50,range=(0,500)) plt.title("%s: Top Mass" % (tag)) plt.figure() plt.subplot(121) lch.hist_err(top_momentum,bins=50,range=(0,1500)) plt.title("%s: Top momentum" % (tag)) plt.subplot(122) lch.hist_err(top_pt,bins=50,range=(0,400)) plt.title("%s: Top pt" % (tag)) plt.show()
#print "%-5d %-5d %8.5f" % (pdg,status,pt) t0 = d_tools.return_top_decays(pdgs) top_pt.append(pts[t0[0][0]]) top_pt.append(pts[t0[1][0]]) W_pt.append(pts[t0[0][1]]) W_pt.append(pts[t0[1][1]]) bottom_pt.append(pts[t0[0][2]]) bottom_pt.append(pts[t0[1][2]]) plt.figure(1) #plt.hist(top_pt,bins=50) lkn.hist_err(top_pt, bins=50, range=[400, 600]) plt.title(r"$t$ $\bar{t}$ $p$$_t$") '''plt.figure(2) #plt.hist(W_pt,bins=50) lkn.hist_err(W_pt,bins=50) plt.title("W and Anti_W Pt")''' plt.figure(3) #plt.hist(bottom_pt,bins=50) lkn.hist_err(bottom_pt, bins=50) plt.title(r"$b$ $\bar{b}$ $p$$_t$") plt.figure(4) #plt.hist(muon_pt,bins=50) lkn.hist_err(muon_pt, bins=50) plt.title(r"$Muon$ $p$$_t$")
def main(): lumi_file_name = 'lumi_info.pkl' lumi_info = pickle.load(open(lumi_file_name, "rb")) filenames = sys.argv[1:] print("Will open files:") for f in filenames: print(f) data, tot_lumi = tbt.chain_pickle_files(filenames, lumi_info) print("tot_lumi: ", tot_lumi) topmass = data['topmass'] wmass = data['wmass'] csvs = data['csvs'] angles = data['angles'] dRs = data['dRs'] #njets = data['njets'] njets = data['njets'] ################################################################################ plt.figure() plt.subplot(3, 3, 1) lch.hist_err(topmass, bins=100, range=(0, 600), color='k') plt.xlabel('Top Mass (GeV)') plt.subplot(3, 3, 2) lch.hist_err(wmass, bins=100, range=(0, 300), color='k') plt.xlabel('W Mass (GeV)') plt.subplot(3, 3, 3) lch.hist_err(csvs, bins=110, range=(0, 1.1), color='k') plt.xlabel('Isolation Variable') plt.subplot(3, 3, 4) lch.hist_err(angles, bins=100, range=(0, 3.2), color='k') plt.xlabel('Angles') plt.subplot(3, 3, 5) #plt.plot(wmass,angles,'.',markersize=0.5,alpha=0.2) lch.hist_2D(wmass, angles, xbins=100, ybins=100, xrange=(0, 300), yrange=(0, 3.14)) plt.xlim(50, 150) plt.ylim(0, 3.2) plt.xlabel('W Mass') plt.ylabel('Angles') plt.subplot(3, 3, 6) lch.hist_err(dRs, bins=100, range=(0, 3.2), color='k') plt.xlabel('dRs') plt.subplot(3, 3, 7) lch.hist_2D(dRs, angles, xbins=100, ybins=100, xrange=(0, 6.28), yrange=(0, 3.14)) plt.xlabel('dRs') plt.ylabel('Angles') ################################################################################ # Cut on the wmass index = wmass > 70.0 index *= wmass < 95.0 plt.figure() plt.title('W Mass Cuts') plt.subplot(3, 3, 1) lch.hist_err(topmass[index], bins=100, range=(0, 600), color='k') plt.xlabel('Top Mass (GeV)') plt.subplot(3, 3, 2) lch.hist_err(wmass[index], bins=100, range=(0, 300), color='k') plt.xlabel('W Mass (GeV)') plt.subplot(3, 3, 4) lch.hist_err(angles[index], bins=100, range=(0, 3.2), color='k') plt.xlabel('Angles') plt.subplot(3, 3, 5) #plt.plot(wmass[index],angles[index],'.',markersize=0.5,alpha=0.2) lch.hist_2D(wmass[index], angles[index], xbins=100, ybins=100, xrange=(0, 300), yrange=(0, 3.14)) plt.xlim(50, 150) plt.ylim(0, 3.2) plt.xlabel('W Mass') plt.ylabel('Angles') plt.subplot(3, 3, 6) lch.hist_err(dRs[index], bins=100, range=(0, 3.2), color='k') plt.xlabel('dRs') plt.subplot(3, 3, 7) lch.hist_2D(dRs[index], angles[index], xbins=100, ybins=100, xrange=(0, 6.28), yrange=(0, 3.14)) plt.xlabel('dRs') plt.ylabel('Angles') ''' # For talk plt.figure() lch.hist_err(topmass[index],bins=100,range=(0,600),color='k') plt.hist(topmass[index],bins=100,range=(0,600),color='grey',alpha=0.2) plt.xlabel(r'Top candidate with W-mass cut (GeV/c$^2$)',fontsize=14) plt.tight_layout() plt.savefig('top.png') plt.figure() lch.hist_err(wmass,bins=100,range=(0,300),color='k') plt.hist(wmass,bins=100,range=(0,300),color='grey',alpha=0.2) plt.xlabel(r'W candidate (GeV/c$^2$)',fontsize=14) plt.tight_layout() plt.savefig('W.png') plt.figure() lch.hist_err(csvs,bins=110,range=(0,1.1),color='k') plt.hist(csvs,bins=100,range=(0,1.1),color='grey',alpha=0.2) plt.xlabel(r'CSVv2 variable',fontsize=14) plt.tight_layout() plt.savefig('csvv2.png') ''' plt.show() return data
################################################################################ def negative_log_likelihood(p, x, y): # Here you need to code up the sum of all of the negative log likelihoods (pdf) # for each data point. ret = np.sum(-1*np.log(pdf(p,x))) return ret ################################################################################ # Generate some fake data points ################################################################################ mu = 5.0 sigma = 0.5 x = np.random.normal(mu,sigma,1000) plt.figure() lch.hist_err(x,bins=25) print x #plt.figure() #prob = mygauss(x,mu,1.0) #lch.hist_err(prob,bins=25) #print prob #plt.show() # Now fit the data. params_starting_vals = [1.0,1.0] params_final_vals = optimize.fmin(negative_log_likelihood, params_starting_vals[:],args=(x,x),full_output=True) print "Final values" print params_final_vals fit_mu = params_final_vals[0][0]
cut_bkg = cut_events_outside_subrange(cut_ranges_bkg,subranges[1],data_index=1) print(len(cut_bkg[0])) #cut_bkg = np.array(cut_bkg) #cut_bkg.transpose() #print cut_bkg new_bkgs.append(cut_bkg) for j in range(3): plt.subplot(1,3,j+1) #print cv #print data[j][0:10] if cv>0: lch.hist_err(data[j],color=bkg_colors[i],ecolor=bkg_colors[i]) plt.tight_layout() print("HERE A") fig2 = plt.figure(figsize=(12,6)) for j in range(3): plt.subplot(1,3,j+1) data = [] colors = [] weights = [] for k in range(0,5): #print new_bkgs[k] if len(new_bkgs[k][j])>0: data.append(new_bkgs[k][j])
xlo = 0.133 xhi = 0.1470 mu = (xlo + xhi) / 2 sigma = 0.0085 slope = 0.5 # Index the range of energies index0 = energies>xlo index1 = energies<xhi index = index0*index1 x = energies[index] plt.figure() lch.hist_err(x,bins=50) ################################################################################ # Now fit the data. # Mean # width # slope # number of events in Gaussian # number of events in background ################################################################################ npts = len(x) print "npts: ",npts params_starting_vals = [mu, sigma, slope, 0.95*npts, 0.05*npts] fixed_parameters = [xlo,xhi,npts] params_final_vals = optimize.fmin(negative_log_likelihood, params_starting_vals[:],args=(x,fixed_parameters),full_output=True,maxiter=10000)
############################################################################ # Plot the data ############################################################################ #### THIS PART IS FOR TALKS fig1 = plt.figure(figsize=(10,4),dpi=100) ax11 = fig1.add_subplot(1,1,1) fig1.subplots_adjust(left=0.08,right=0.95,bottom=0.15,top=0.95) ax11.set_xlim(ranges[0]) #ax11.set_ylim(0.0,50.0) #ax11.set_ylim(0.0,92.0) ax11.set_xlabel("Ionization Energy (keVee)",fontsize=12) ax11.set_ylabel("Events",fontsize=12) lch.hist_err(data[0],bins=nbins[0],range=ranges[0],axes=ax11) plt.savefig('cogent_full_range_0.png') ax11.annotate(r'K-shell decays', xy=(9.5,350), xytext=(6,500), arrowprops=dict(facecolor='black', shrink=0.05),color='red',fontsize=24) ax11.annotate(r'L-shell decays', xy=(1.5,300), xytext=(2,650), arrowprops=dict(facecolor='black', shrink=0.05),color='red',fontsize=24) plt.savefig('cogent_full_range_1.png') ax11.annotate(r'Low-mass WIMPs', xy=(2.0,200), xytext=(4,350), arrowprops=dict(facecolor='black', shrink=0.05),color='black',fontsize=24) plt.savefig('cogent_full_range_2.png') plt.show() exit() fig0 = plt.figure(figsize=(12,4),dpi=100)
#Finding top pt top_pt.append(pts[t0[0][0]]) top_pt.append(pts[t0[1][0]]) #Finding W pt W_pt.append(pts[t0[0][1]]) W_pt.append(pts[t0[1][1]]) #Finding bottom pt bottom_pt.append(pts[t0[0][2]]) bottom_pt.append(pts[t0[1][2]]) plt.figure(1) #plt.hist(top_pt,bins=50) lkn.hist_err(top_pt, bins=100, range=(0, 300)) plt.title(r"Top and Antitop p$_T$") plt.xlabel(r"p$_T$(GeV/c)") plt.figure(2) #plt.hist(W_pt,bins=50) lkn.hist_err(W_pt, bins=100, range=(0, 300)) plt.title(r"W and Anti_W p$_T$") plt.xlabel(r"p$_T$(GeV/c)") plt.figure(3) #plt.hist(bottom_pt,bins=50) lkn.hist_err(bottom_pt, bins=100, range=(0, 300)) plt.title(r"B and Anti_b p$_T$") plt.xlabel(r"p$_T$(GeV/c)")
def main(): ############################################################################ # Make a figure on which to plot stuff. # This would be the same as making a TCanvas object. ############################################################################ figs = [] subplots = [] for i in xrange(2): figs.append(plt.figure(figsize=(8,6),dpi=100,facecolor='w',edgecolor='k')) subplots.append([]) for j in range(0,4): subplots[i].append(figs[i].add_subplot(2,2,j+1)) ############################################################################ # Generate values drawn from a normal (Gaussian) distribution. ############################################################################ deltat_min = -20 deltat_max = 20 deltat_range = deltat_max-deltat_min deltat_mc = [] for i in range(0,4): deltat_mc.append(deltat_range*np.random.rand(10000) + deltat_min) print "deltat MC: %d" % (len(deltat_mc)) deltat = np.linspace(deltat_min,deltat_max,1000) gamma = 1.0/1.547 p_over_q = 1.01 A = 1.0 deltaM = 0.4 deltaG = 0.0 charges = [[+1,+1], [-1,-1], [+1,-1], [-1,+1]] maxes = [] for i in range(0,4): q1 = charges[i][0] q2 = charges[i][1] N = pdfs.pdf_bmixing(deltat,[gamma,p_over_q,deltaM,deltaG,q1,q2]) maxes.append(max(N)) subplots[0][i].plot(deltat,N,'-',markersize=2) max_prob = max(maxes) #''' events = [np.array([]),np.array([]),np.array([]),np.array([])] n=0 nevents = 1000 print "Generating %d events." % (nevents) while n<nevents: if n%1000==0: print n for i in range(0,4): q1 = charges[i][0] q2 = charges[i][1] val = deltat_range*np.random.rand()+deltat_min prob = pdfs.pdf_bmixing(val,[gamma,p_over_q,deltaM,deltaG,q1,q2]) test = max_prob*np.random.rand() if test<prob: events[i] = np.append(events[i],val) n += 1 for i in range(0,4): #subplots[1][i].hist(events[i],bins=50) figs[1].add_subplot(2,2,i+1) lch.hist_err(events[i],bins=50) subplots[1][i].set_xlim(deltat_min,deltat_max) subplots[1][i].set_ylim(0) #subplots[1][i].set_ylim(0,nevents/16) Npp = len(events[0]) Nmm = len(events[1]) Npm = len(events[2]) Nmp = len(events[3]) print "%d %d %d %d" % (Npp,Nmm,Npm,Nmp) Acp = (Npp-Nmm)/float(Npp+Nmm) deltaAcp = np.sqrt((sqrt(Npp)/Npp)**2 + (sqrt(Nmm)/Nmm)**2) print "Acp: %f +/- %f" % (Acp,deltaAcp) Acp = 2*(1-np.abs(1.0/p_over_q)) print "Acp: %f" % (Acp) #''' # Fit function. gamma = 1.0/1.547 p_over_q = 1.01 A = 1.0 deltaM = 0.4 deltaG = 0.0 #N = pdfs.pdf_bmixing(deltat,[gamma,p_over_q,deltaM,deltaG,q1,q2]) n0 = Npp n1 = Nmm n2 = Npm n3 = Nmp p0 = [gamma,p_over_q,deltaM,deltaG,n0,n1,n2,n3] print p0 #p1 = sp.optimize.fmin(pdfs.extended_maximum_likelihood_function,p0,args=(events,deltat_mc), maxiter=10000, maxfun=10000) #print p1 data = [events,deltat_mc] m = minuit.Minuit(pdfs.extended_maximum_likelihood_function_minuit,p=p0) print m.values m.migrad() # Need this command to display the figure. plt.show()
if abs(pdgs[t0[0][3]]) > 6 and abs(pdgs[t0[1][3]]) < 6: if pdgs[t0[0][3]] == -11 or pdgs[t0[0][3]] == -13: dR_mu_b = d_tools.delta_R(etas, phis, t0[0][2], t0[0][3]) del_R_mu_b.append(dR_mu_b[0]) elif pdgs[t0[1][4]] == 11 or pdgs[t0[1][4]] == 13: dR_mu_b = d_tools.delta_R(etas, phis, t0[0][2], t0[0][4]) del_R_mu_b.append(dR_mu_b[0]) plt.figure(1) #plt.hist(del_R_top_antitop,bins=50) nbins = 100 lorange = 0 hirange = 8 binwidth = (hirange - lorange) / float(nbins) lkn.hist_err(del_R_top_antitop, bins=nbins, range=(lorange, hirange)) #plt.axis([0, 8, 0, 8]) plt.title(r" $\Delta R$ between $t$ and $\bar{t}$", fontsize=24) plt.xlabel(r"$\Delta$R", fontsize=24) label = r"Entries/%3.2f" % (binwidth) plt.ylabel(label, fontsize=24) plt.figure(2) plt.subplot(2, 1, 1) #plt.hist(del_R_W_B,bins=50) lkn.hist_err(del_R_W_B, bins=100, range=(0, 8)) #plt.axis([0, 8, 0, 8]) plt.title(r"W and B $\Delta$R") #plt.xlabel(r"$\Delta$R") plt.subplot(2, 1, 2)
def main(): ############################################################################ # Parse the command lines. ############################################################################ parser = argparse.ArgumentParser() parser.add_argument('--fit', dest='fit', type=int,\ default=0, help='Which fit to perform (0,1,2)') parser.add_argument('--verbose', dest='verbose', action='store_true',\ default=False, help='Verbose output') parser.add_argument('--dataset', dest='dataset', type=str,\ default='nicole', help='Dataset to use in fitting. Nicoles simulated (nicole) or Juans pulser (juan)') parser.add_argument('--batch', dest='batch', action='store_true',\ default=False, help='Run in batch mode (exit on completion).') args = parser.parse_args() ############################################################################ #tag = 'pulser_onelognormal' #tag = 'pulser' #tag = 'pulser_zoomed_in' #tag = 'pulser_simulated_Nicole' #tag = 'pulser_simulated_Nicole_zoomed_in' #tag = 'pulser_simulated_Nicole_onelognormal' #tag = 'pulser_simulated_Nicole_no_fit' tag = "risetime_determination_%s" % (args.dataset) outfilename = "risetime_parameters_%s.py" % (tag) outfile = open(outfilename,'w') outfile.write("def risetime_parameters():\n\n") ''' if args.help: parser.print_help() exit(-1) ''' ############################################################################ # Read in the data ############################################################################ infile_name = 'data/pulser_data_325ns.dat' # SIMULATED DATA FROM NICOLE if args.dataset=='nicole': infile_name = 'data/pulser_data_325ns.dat' # SIMULATED DATA FROM NICOLE elif args.dataset=='juan': infile_name = 'data/pulser_data.dat' # FROM JUAN, 8/2/13, manually scanned pulser runs. tdays,energies,rise_times = get_3yr_cogent_data(infile_name,first_event=first_event,calibration=0) print (tdays) print (energies) print (rise_times) print (energies) if args.verbose: print_data(energies,tdays,rise_times) data = [energies.copy(),tdays.copy(),rise_times.copy()] print(("data before range cuts: ",len(data[0]),len(data[1]),len(data[2]))) ############################################################################ # Declare the ranges. ############################################################################ ranges,subranges,nbins = parameters.fitting_parameters(args.fit) bin_widths = np.ones(len(ranges)) for i,n,r in zip(list(range(len(nbins))),nbins,ranges): bin_widths[i] = (r[1]-r[0])/n # Cut events out that fall outside the range. data = cut_events_outside_range(data,ranges) data = cut_events_outside_subrange(data,subranges[1],data_index=1) if args.verbose: print_data(energies,tdays) print(("data after range cuts: ",len(data[0]),len(data[1]))) nevents = float(len(data[0])) ''' plt.figure() plt.plot(energies,rise_times,'o',markersize=1.5) plt.yscale('log') plt.ylim(0.1,10) plt.figure() plt.plot(tdays,rise_times,'o',markersize=1.5) plt.yscale('log') plt.ylim(0.1,10) ''' ############################################################################ # Plot the data ############################################################################ ############################################################################ # Look at the rise-time information. ############################################################################ # Will use this later when trying to figure out the energy dependence of # the log-normal parameters. # define our (line) fitting function expfunc = lambda p, x: p[1]*np.exp(-p[0]*x) + p[2] errfunc = lambda p, x, y, err: (y - expfunc(p, x)) / err ############################################################################ # Starting values for fits. ############################################################################ # For the data (two lognormals) #starting_params = [-0.6,0.6,0.2*nevents, 0.1,0.8,0.8*nevents] # For the pulser fast rise times (two lognormals) starting_params = [-0.6,0.5,0.6*nevents, 0.5,0.8,0.4*nevents] fit_parameters = [] fit_errors = [] fit_mnerrors = [] nevs = [] axrt = [] elo = 0.0 ehi = 1.0 eoffset = 0.5 ewidth = 0.15 estep = 0.15 #ewidth = 0.200 #estep = 0.050 expts = [] figcount = 0 for i in range(0,24): j = i if j%6==0: figrt = plt.figure(figsize=(12,6),dpi=100) axrt.append(figrt.add_subplot(2,3, i%6 + 1)) #figrt = plt.figure(figsize=(6,4),dpi=100) #axrt.append(figrt.add_subplot(1,1,1)) data_to_fit = [] #h,xpts,ypts,xpts_err,ypts_err = lch.hist_err(data[1],bins=nbins[1],range=ranges[1],axes=ax1) if i>=0: elo = i*estep + eoffset ehi = elo + ewidth index0 = data[0]>=elo index1 = data[0]< ehi print((elo,ehi)) index = index0*index1 data_to_fit = data[2][index] if len(data_to_fit)>0: lch.hist_err(data_to_fit,bins=nbins[2],range=ranges[2],axes=axrt[j]) plt.ylim(0) plt.xlim(ranges[2][0],ranges[2][1]) name = "Energy: %0.2f-%0.2f (keVee)" % (elo,ehi) plt.text(0.20,0.75,name,transform=axrt[j].transAxes) print ("=======-------- E BIN ----------===========") print (name) nevents = len(data_to_fit) print(("Nevents for this fit: ",nevents)) #starting_params = [-0.6,0.6,0.2*nevents, 0.6,0.55,0.8*nevents] # For pulser fits #starting_params = [-0.1,0.8,0.2*nevents, 0.6,0.55,0.8*nevents] ''' if i==0: starting_params = [-0.6,0.6,0.2*nevents, 0.6,0.55,0.8*nevents] ''' ''' if elo>=1.0 and elo<1.2: starting_params = [0.1,0.2,0.3*nevents, 0.2,3.0,0.7*nevents] ''' ############################################################################ # Declare the fit parameters ############################################################################ params_dict = {} params_dict['flag'] = {'fix':True,'start_val':args.fit} params_dict['var_rt'] = {'fix':True,'start_val':0,'limits':(ranges[2][0],ranges[2][1])} #params_dict['fast_logn_mean'] = {'fix':False,'start_val':0.005,'limits':(-2,2),'error':0.1} #params_dict['fast_logn_sigma'] = {'fix':False,'start_val':0.5,'limits':(0.01,5),'error':0.1} #params_dict['fast_num'] = {'fix':False,'start_val':0.2*nevents,'limits':(0.0,1.5*nevents),'error':0.1} #params_dict['slow_logn_mean'] = {'fix':False,'start_val':0.5,'limits':(-2,2),'error':0.1} #params_dict['slow_logn_sigma'] = {'fix':False,'start_val':1.0,'limits':(0.01,5),'error':0.1} #params_dict['slow_num'] = {'fix':False,'start_val':0.8*nevents,'limits':(0.0,1.5*nevents),'error':0.1} #starting_params = [1.0,1.2,0.6*nevents, 0.1,0.8,0.4*nevents] # Worked for 1.0-1.25 #params_dict['fast_logn_mean'] = {'fix':False,'start_val':1.000,'limits':(-2,2),'error':0.1} #params_dict['fast_logn_sigma'] = {'fix':False,'start_val':1.2,'limits':(0.01,5),'error':0.1} #params_dict['fast_num'] = {'fix':False,'start_val':0.6*nevents,'limits':(0.0,1.5*nevents),'error':0.1} #params_dict['slow_logn_mean'] = {'fix':False,'start_val':0.1,'limits':(-2,2),'error':0.1} #params_dict['slow_logn_sigma'] = {'fix':False,'start_val':0.8,'limits':(0.01,5),'error':0.1} #params_dict['slow_num'] = {'fix':False,'start_val':0.4*nevents,'limits':(0.0,1.5*nevents),'error':0.1} params_dict['fast_logn_mean'] = {'fix':False,'start_val':starting_params[0],'limits':(-2,2),'error':0.01} params_dict['fast_logn_sigma'] = {'fix':False,'start_val':starting_params[1],'limits':(0.05,30),'error':0.01} params_dict['fast_num'] = {'fix':False,'start_val':nevents,'limits':(0.0,1.5*nevents),'error':0.01} #params_dict['slow_logn_mean'] = {'fix':False,'start_val':starting_params[3],'limits':(-2,2),'error':0.01} #params_dict['slow_logn_sigma'] = {'fix':False,'start_val':starting_params[4],'limits':(0.05,30),'error':0.01} #params_dict['slow_num'] = {'fix':False,'start_val':starting_params[5],'limits':(0.0,1.5*nevents),'error':0.01} # For the pulser fits #params_dict['slow_logn_mean'] = {'fix':True,'start_val':0.000,'limits':(-0.002,0.002),'error':0.000001} #params_dict['slow_logn_sigma'] = {'fix':True,'start_val':1.000,'limits':(0.9005,1.002),'error':0.000001} #params_dict['slow_num'] = {'fix':True,'start_val':0.001,'limits':(0.0,0.002),'error':0.000001} # float them params_dict['slow_logn_mean'] = {'fix':False,'start_val':starting_params[3],'limits':(-2,2),'error':0.01} params_dict['slow_logn_sigma'] = {'fix':False,'start_val':starting_params[4],'limits':(0.05,30),'error':0.01} params_dict['slow_num'] = {'fix':False,'start_val':starting_params[5],'limits':(0.0,1.5*nevents),'error':0.01} # To try one lognormal #params_dict['slow_logn_mean'] = {'fix':True,'start_val':starting_params[3],'limits':(-2,2),'error':0.01} #params_dict['slow_logn_sigma'] = {'fix':True,'start_val':starting_params[4],'limits':(0.05,30),'error':0.01} #params_dict['slow_num'] = {'fix':True,'start_val':0.1,'limits':(0.0,1.5*nevents),'error':0.01} # Above some value, lock down the second log normal, as the distribution is pretty well # fit with just one log-normal. elomax = 2.8 if args.dataset=='nicole': elomax = 2.8 elif args.dataset=='juan': elomax = 2.2 if elo>=elomax: params_dict['slow_logn_mean'] = {'fix':True,'start_val':0.0,'limits':(-2,2),'error':0.01} params_dict['slow_logn_sigma'] = {'fix':True,'start_val':1.0,'limits':(0.05,30),'error':0.01} params_dict['slow_num'] = {'fix':True,'start_val':1,'limits':(0.0,1.5*nevents),'error':0.01} ''' if i==0: None # From Nicole's simulation. #params_dict['fast_logn_mean'] = {'fix':True,'start_val':-0.10,'limits':(-2,2),'error':0.01} # From Juan #params_dict['fast_logn_mean'] = {'fix':True,'start_val':-0.60,'limits':(-2,2),'error':0.01} #params_dict['slow_logn_sigma'] = {'fix':True,'start_val':0.50,'limits':(0.05,30),'error':0.01} ''' # Try fixing the slow sigma #params_dict['slow_logn_sigma'] = {'fix':True,'start_val':0.52,'limits':(-2,2),'error':0.01} #figrt.subplots_adjust(left=0.07, bottom=0.15, right=0.95, wspace=0.2, hspace=None,top=0.85) #figrt.subplots_adjust(left=0.05, right=0.98) #figrt.subplots_adjust(left=0.15, right=0.98,bottom=0.15) figrt.subplots_adjust(left=0.07, right=0.98,bottom=0.10) #plt.show() #exit() ############################################################################ # Fit ############################################################################ if i>=0 and len(data_to_fit)>0: params_names,kwd = fitutils.dict2kwd(params_dict) #print data_to_fit f = fitutils.Minuit_FCN([[data_to_fit]],params_dict,emlf) # For maximum likelihood method. kwd['errordef'] = 0.5 kwd['print_level'] = 0 #print kwd m = minuit.Minuit(f,**kwd) m.print_param() m.migrad() #m.hesse() m.minos() print ("Finished fit!!\n") values = m.values # Dictionary errors = m.errors # Dictionary mnerrors = m.get_merrors() print ("MNERRORS: ") print (mnerrors) fit_parameters.append(values) fit_errors.append(errors) fit_mnerrors.append(mnerrors) nevs.append(len(data_to_fit)) xpts = np.linspace(ranges[2][0],ranges[2][1],1000) tot_ypts = np.zeros(len(xpts)) ypts = pdfs.lognormal(xpts,values['fast_logn_mean'],values['fast_logn_sigma'],ranges[2][0],ranges[2][1]) y,plot = plot_pdf(xpts,ypts,bin_width=bin_widths[2],scale=values['fast_num'],fmt='r--',linewidth=2,axes=axrt[j]) tot_ypts += y ypts = pdfs.lognormal(xpts,values['slow_logn_mean'],values['slow_logn_sigma'],ranges[2][0],ranges[2][1]) y,plot = plot_pdf(xpts,ypts,bin_width=bin_widths[2],scale=values['slow_num'],fmt='r:',linewidth=2,axes=axrt[j]) tot_ypts += y axrt[j].plot(xpts,tot_ypts,'r',linewidth=2) axrt[j].set_ylabel(r'Events') axrt[j].set_xlabel(r'Rise time ($\mu$s)') axrt[j].set_xlim(0,5.0) ''' name = "Plots/rt_slice_%d.png" % (figcount) if j%6==5: plt.savefig(name) figcount += 1 ''' #''' if math.isnan(values['fast_logn_mean']) == False: starting_params = [ \ values['fast_logn_mean'], \ values['fast_logn_sigma'], \ values['fast_num'], \ values['slow_logn_mean'], \ values['slow_logn_sigma'], values['slow_num'] \ ] #''' expts.append((ehi+elo)/2.0) if j%6==5: name = "Plots/rt_slice_%s_%d.png" % (tag,j/6) plt.savefig(name) print (fit_parameters) print (nevs) ypts = [[],[],[],[],[],[]] yerr = [[],[],[],[],[],[]] yerrlo = [[],[],[],[],[],[]] yerrhi = [[],[],[],[],[],[]] npts = [] if len(expts)>0: #for i,fp,fe,n in zip(range(len(nevs)),fit_parameters,fit_errors,nevs): for i,fp,fe,n in zip(list(range(len(nevs))),fit_parameters,fit_mnerrors,nevs): print ("----------") #ypts[0].append(fp['fast_logn_mean']) #ypts[1].append(fp['fast_logn_sigma']) #ypts[2].append(fp['fast_num']) #ypts[3].append(fp['slow_logn_mean']) #ypts[4].append(fp['slow_logn_sigma']) #ypts[5].append(fp['slow_num']) pars = ['fast_logn_mean','fast_logn_sigma','fast_num',\ 'slow_logn_mean','slow_logn_sigma','slow_num'] for i,p in enumerate(pars): if p in fe: #if fe.has_key(p): ypts[i].append(fp[p]) yerrlo[i].append(abs(fe[p]['lower'])) yerrhi[i].append(abs(fe[p]['upper'])) else: ypts[i].append(0.0) yerrlo[i].append(0.0) yerrhi[i].append(0.0) npts.append(n) for i in range(len(ypts)): ypts[i] = np.array(ypts[i]) yerrlo[i] = np.array(yerrlo[i]) yerrhi[i] = np.array(yerrhi[i]) colors = ['r','b'] labels = ['narrow','wide'] ######################################################################## # Use all or some of the points in the fit. ######################################################################## index = np.arange(1,16) if args.dataset=='nicole': index = np.arange(1,16) elif args.dataset=='juan': index = np.arange(0,9) #xp = np.linspace(min(expts),max(expts),100) xp = np.linspace(min(expts),expts[17],100) if args.dataset=='nicole': xp = np.linspace(min(expts),expts[17],100) elif args.dataset=='juan': xp = np.linspace(min(expts),expts[8],100) expts = np.array(expts) fvals2 = plt.figure(figsize=(13,4),dpi=100) yfitpts = [] for k in range(0,3): # Some of the broad rise times are set to 0. #index0s = ypts[3+k]!=0 #index0s = np.ones(len(ypts[3+k])).astype(bool) index0s = np.ones(16).astype(bool) fvals2.add_subplot(1,3,k+1) tempypts = ypts[0+k]-ypts[3+k] # Fractional error tempyerrlo = np.sqrt((yerrlo[0+k])**2 + (yerrlo[3+k])**2) tempyerrhi = np.sqrt((yerrhi[0+k])**2 + (yerrhi[3+k])**2) if k>1: tempypts = ypts[0+k][index0s]/ypts[3+k][index0s] tempyerrlo = np.sqrt((yerrlo[0+k][index0s]/ypts[3+k][index0s])**2 + (yerrlo[3+k][index0s]*(ypts[0+k][index0s]/(ypts[3+k][index0s]**2)))**2) tempyerrhi = np.sqrt((yerrhi[0+k][index0s]/ypts[3+k][index0s])**2 + (yerrhi[3+k][index0s]*(ypts[0+k][index0s]/(ypts[3+k][index0s]**2)))**2) plt.errorbar(expts[index0s],tempypts[index0s],xerr=0.01,yerr=[tempyerrlo[index0s],tempyerrhi[index0s]],\ fmt='o',ecolor='k',mec='k',mfc='m',label='Ratio') if k==0: plt.ylabel(r'$\Delta \mu$') elif k==1: plt.ylabel(r'$\Delta \sigma$') elif k==2: plt.ylabel(r'# wide/# narrow') plt.xlim(0.5,3.5) plt.xlabel('Energy (keVee)') ######################################################################## # Fit to exponentials. ######################################################################## # Choose appropriate starting values, depending on the dataset. pinit = [1,1,1] if args.dataset=='nicole': if k==0: pinit = [1.0, 1.0, -1.2] elif k==1: #pinit = [1.0, -1.0, -0.5] pinit = [-3.0,0.0015,-0.4] elif k==2: pinit = [-2.0, 1.0, 2.0] elif args.dataset=='juan': if k==0: pinit = [1.0, 1.0, -1.2] elif k==1: #pinit = [1.0, -1.0, -0.5] pinit = [-3.0,0.0015,-0.4] elif k==2: pinit = [-2.0, 1.0, 2.0] out = leastsq(errfunc, pinit, args=(expts[index], tempypts[index], (tempyerrlo[index]+tempyerrhi[index])/2.0), full_output=1) z = out[0] zcov = out[1] #print "Differences and ratios: %d [%f,%f,%f]" % (k,z[0],z[1],z[2]) variable = None if (k==0): variable = "fast_mean_rel_k" if (k==1): variable = "fast_sigma_rel_k" elif (k==2): variable = "fast_num_rel_k" output = "\t%s = [%f,%f,%f]\n" % (variable,z[0],z[1],z[2]) print (output) outfile.write(output) #print "zcov: ",zcov ''' if zcov is not None: print "Differences and ratios: %d [%f,%f,%f]" % (k,np.sqrt(zcov[0][0]),np.sqrt(zcov[1][1]),np.sqrt(zcov[2][2])) ''' yfitpts = expfunc(z,xp) #print zcov plt.plot(xp,yfitpts,'-',color='m') fvals2.subplots_adjust(left=0.10, right=0.98,bottom=0.15,wspace=0.25,hspace=0.25) name = 'Plots/rt_summary_%s_1.png' % (tag) plt.savefig(name) outfile.write("\n") ######################################################################## # Try to fit the individual distributions. ######################################################################## yfitpts = [] for i in range(0,6): yfitpts.append(np.zeros(len(xp))) fvals = plt.figure(figsize=(13,4),dpi=100) for k in range(0,3): fvals.add_subplot(1,3,k+1) for ik in range(0,2): nindex = k+3*ik #print "HERERERERE" #print ypts[nindex] #print ypts[nindex][ypts[nindex]!=0] print((len(yerrlo[nindex][ypts[nindex]!=0]))) print((len(yerrhi[nindex][ypts[nindex]!=0]))) plt.errorbar(expts[ypts[nindex]!=0],ypts[nindex][ypts[nindex]!=0],xerr=0.01,yerr=[yerrlo[nindex][ypts[nindex]!=0],yerrhi[nindex][ypts[nindex]!=0]],\ fmt='o',ecolor='k',mec='k',mfc=colors[ik],label=labels[ik]) #''' # Use part of the data #index0 = np.arange(0,3) #index1 = np.arange(7,len(expts)) #index = np.append(index0,index1) # Use all or some of the points index = np.arange(1,16) if args.dataset=='nicole': index = np.arange(1,15) elif args.dataset=='juan': index = np.arange(0,7) ######################################################################## # Fit to exponentials. ######################################################################## pinit = [1,1,1] if ik==0 and k==0: pinit = [1.0, 1.0, -1.2] elif ik==0 and k==1: pinit = [4.0, 2.0, 0.0] elif ik==0 and k==2: pinit = [2.0, 2000.0, 300.0] elif ik==1: pinit = [3.0, 1.5, 0.5] out = leastsq(errfunc, pinit, args=(expts[index], ypts[nindex][index], (yerrlo[nindex][index]+yerrhi[nindex][index])/2.0), full_output=1) z = out[0] zcov = out[1] variable = None if (k==0): variable = "fast_mean0_k" if (k==1): variable = "fast_sigma0_k" elif (k==2): variable = "fast_num0_k" #print "Data points: %d %d [%f,%f,%f]" % (k,ik,z[0],z[1],z[2]) if (ik==0): output = "\t%s = [%f,%f,%f]\n" % (variable,z[0],z[1],z[2]) outfile.write(output) print (output) #print "Data points: %d %d [%f,%f,%f]" % (k,ik,np.sqrt(zcov[0][0]),np.sqrt(zcov[1][1]),np.sqrt(zcov[2][2])) yfitpts[nindex] = expfunc(z,xp) #print zcov plt.plot(xp,yfitpts[nindex],'-',color=colors[ik]) #''' if k==0: plt.ylim(-1.5,1.5) elif k==1: plt.ylim(0,1.5) plt.xlabel('Energy (keVee)') if k==0: plt.ylabel(r'Lognormal $\mu$') elif k==1: plt.ylabel(r'Lognormal $\sigma$') elif k==2: plt.ylabel(r'Number of events') plt.legend() #fval ''' fvals.add_subplot(2,3,4) plt.plot(xp,yfitpts[3]-yfitpts[0],'-',color='m') fvals.add_subplot(2,3,5) plt.plot(xp,yfitpts[4]-yfitpts[1],'-',color='m') fvals.add_subplot(2,3,6) plt.plot(xp,yfitpts[5]/yfitpts[2],'-',color='m') ''' fvals.subplots_adjust(left=0.10, right=0.98,bottom=0.15,wspace=0.25,hspace=0.25) name = 'Plots/rt_summary_%s_0.png' % (tag) plt.savefig(name) np.savetxt('rt_parameters.txt',[expts,ypts[0],ypts[1],ypts[2],ypts[3],ypts[4],ypts[5],npts]) #''' #print "Sum ypts[5]: ",sum(ypts[5]) outfile.write("\n\treturn fast_mean_rel_k,fast_sigma_rel_k,fast_num_rel_k,fast_mean0_k,fast_sigma0_k,fast_num0_k\n") if not args.batch: plt.show()
def main(): lumi_file_name = 'lumi_info.pkl' lumi_info = pickle.load(open(lumi_file_name, "rb")) filenames = sys.argv[1:] MCfiles = [] DATAfiles = [] for filename in filenames: filename2 = filename.split('/')[-1] if filename2.split('DATASET')[0] == 'MC_': #print('**********************************') MCfiles.append(filename) else: DATAfiles.append(filename) ''' for filename in MCfiles: print('MC: ', filename) for filename in DATAfiles: print('DATA: ', filename) ''' mcdata = [] #print("Will open files:") mcInfo = tbt.csvtodict("MCinfo.csv") weights = [] mcEvents = [] crosssection = [] data, tot_lumi = tbt.chain_pickle_files(DATAfiles, lumi_info) print("tot_lumi: ", tot_lumi) for f in MCfiles: #print('f', f) mcdataTMP, tot_lumiMC = tbt.chain_pickle_files(f) mcdata.append(mcdataTMP) fnew = f.split('DATASET_crab_')[1].split('_NFILES')[0] nfiles = int(f.split('NFILES_')[1].split('_')[1].split('.')[0]) - int( f.split('NFILES_')[1].split('_')[0]) crosssection = 1000 * (float(mcInfo[fnew]['cross_section']) ) # Convert from pb to fb mcEvents = (float(mcInfo[fnew]['total_events'])) print("crosssection: ", crosssection) print("MCEvents/crosssection: ", mcEvents / crosssection) print("MCEvents: ", mcEvents) print("tot_lumi: ", tot_lumi) print("nfiles: ", nfiles) print("nfiles_tot: ", mcInfo[fnew]['nfiles']) weights.append((crosssection * tot_lumi) / (nfiles * mcEvents / float(mcInfo[fnew]['nfiles']))) topmassDATA = data['topmass'] wmassDATA = data['wmass'] csvsDATA = data['csvs'] anglesDATA = data['angles'] dRsDATA = data['dRs'] #njets = data['njets'] njetsDATA = data['njets'] leadmuptDATA = data['leadmupt'] leadmuetaDATA = data['leadmueta'] topmassMC = [] wmassMC = [] csvsMC = [] anglesMC = [] dRsMC = [] #njets = [] njetsMC = [] leadmuptMC = [] leadmuetaMC = [] for mc in mcdata: topmassMC.append(mc['topmass']) wmassMC.append(mc['wmass']) csvsMC.append(mc['csvs']) anglesMC.append(mc['angles']) dRsMC.append(mc['dRs']) #njets.append(mc['njets']) njetsMC.append(mc['njets']) leadmuptMC.append(mc['leadmupt']) leadmuetaMC.append(mc['leadmueta']) print('Weights', weights) bins = 100 hweights = [] for w, d in zip(weights, [topmassMC[0], topmassMC[1]]): print('weighting: ', w, len(d)) hweights.append(w * np.ones(len(d))) plt.figure() vals = [topmassMC[0], topmassMC[1]] hw = weights_for_histos(weights, vals) plt.hist(vals, bins, range=(0, 1600), weights=hw, stacked=True) lch.hist_err(topmassDATA, bins, range=(0, 1600)) plt.figure() vals = [leadmuptMC[0], leadmuptMC[1]] hw = weights_for_histos(weights, vals) plt.hist(vals, bins, range=(0, 200), weights=hw, stacked=True) lch.hist_err(leadmuptDATA, bins, range=(0, 200)) plt.figure() vals = [leadmuetaMC[0], leadmuetaMC[1]] hw = weights_for_histos(weights, vals) plt.hist(vals, bins, range=(-3, 3), weights=hw, stacked=True) lch.hist_err(leadmuetaDATA, bins, range=(-3, 3)) print(mcdata[0].keys()) plt.figure() plt.subplot(2, 2, 1) plt.hist(mcdata[0]["trig_HLT_IsoMu24_accept"]) plt.subplot(2, 2, 2) plt.hist(mcdata[0]["trig_HLT_IsoTkMu24_accept"]) plt.subplot(2, 2, 3) plt.hist(mcdata[0]["trig_HLT_IsoMu22_eta2p1_accept"]) plt.subplot(2, 2, 4) plt.hist(mcdata[0]["trig_HLT_IsoTkMu22_eta2p1_accept"]) ''' #lch.hist_err(topmass,bins=100,range=(0,600),color='k') plt.xlabel('Top Mass (GeV)') plt.subplot(3,3,2) #lch.hist_err(wmass,bins=100,range=(0,300),color='k') plt.xlabel('W Mass (GeV)') plt.subplot(3,3,3) #lch.hist_err(csvs,bins=110,range=(0,1.1),color='k') plt.xlabel('Isolation Variable') plt.subplot(3,3,4) #lch.hist_err(angles,bins=100,range=(0, 3.2),color='k') plt.xlabel('Angles') plt.subplot(3,3,5) #plt.plot(wmass,angles,'.',markersize=0.5,alpha=0.2) #lch.hist_2D(wmass,angles,xbins=100,ybins=100,xrange=(0,300),yrange=(0,3.14)) plt.xlim(50,150) plt.ylim(0, 3.2) plt.xlabel('W Mass') plt.ylabel('Angles') plt.subplot(3,3,6) #lch.hist_err(dRs,bins=100,range=(0, 3.2),color='k') plt.xlabel('dRs') plt.subplot(3,3,7) #lch.hist_2D(dRs,angles,xbins=100,ybins=100,xrange=(0,6.28),yrange=(0,3.14)) plt.xlabel('dRs') plt.ylabel('Angles') ''' ################################################################################ # Cut on the wmass #index = wmass>70.0 #index *= wmass<95.0 ''' plt.figure() plt.title('W Mass Cuts') plt.subplot(3,3,1) #lch.hist_err(topmass[index],bins=100,range=(0,600),color='k') plt.xlabel('Top Mass (GeV)') plt.subplot(3,3,2) #lch.hist_err(wmass[index],bins=100,range=(0,300),color='k') plt.xlabel('W Mass (GeV)') plt.subplot(3,3,4) #lch.hist_err(angles[index],bins=100,range=(0,3.2),color='k') plt.xlabel('Angles') plt.subplot(3,3,5) #plt.plot(wmass[index],angles[index],'.',markersize=0.5,alpha=0.2) #lch.hist_2D(wmass[index],angles[index],xbins=100,ybins=100,xrange=(0,300),yrange=(0,3.14)) plt.xlim(50,150) plt.ylim(0, 3.2) plt.xlabel('W Mass') plt.ylabel('Angles') plt.subplot(3,3,6) #lch.hist_err(dRs[index],bins=100,range=(0, 3.2),color='k') plt.xlabel('dRs') plt.subplot(3,3,7) #lch.hist_2D(dRs[index],angles[index],xbins=100,ybins=100,xrange=(0,6.28),yrange=(0,3.14)) plt.xlabel('dRs') plt.ylabel('Angles') # For talk plt.figure() #lch.hist_err(topmass[index],bins=100,range=(0,600),color='k') plt.hist(topmass[index],bins=100,range=(0,600),color='grey',alpha=0.2) plt.xlabel(r'Top candidate with W-mass cut (GeV/c$^2$)',fontsize=14) plt.tight_layout() plt.savefig('top.png') plt.figure() #lch.hist_err(wmass,bins=100,range=(0,300),color='k') plt.hist(wmass,bins=100,range=(0,300),color='grey',alpha=0.2) plt.xlabel(r'W candidate (GeV/c$^2$)',fontsize=14) plt.tight_layout() plt.savefig('W.png') plt.figure() #lch.hist_err(csvs,bins=110,range=(0,1.1),color='k') plt.hist(csvs,bins=100,range=(0,1.1),color='grey',alpha=0.2) plt.xlabel(r'CSVv2 variable',fontsize=14) plt.tight_layout() plt.savefig('csvv2.png') ''' plt.show() return data
elif pdgs[t0[1][4]]==11 or pdgs[t0[1][4]]==13: dR_mu_b=d_tools.delta_R(etas,phis,t0[0][2],t0[0][4]) del_R_mu_b.append(dR_mu_b[0]) plt.figure(1) #plt.hist(del_R_top_antitop,bins=50) nbins=100; lorange=0; hirange=8 binwidth = (hirange-lorange)/float(nbins) lkn.hist_err(del_R_top_antitop,bins=nbins,range=(lorange,hirange)) #plt.axis([0, 8, 0, 8]) plt.title(r" $\Delta R$ between $t$ and $\bar{t}$",fontsize=24) plt.xlabel(r"$\Delta$R",fontsize=24) label = r"Entries/%3.2f" % (binwidth) plt.ylabel(label,fontsize=24) plt.figure(2) plt.subplot(2, 1, 1) #plt.hist(del_R_W_B,bins=50) lkn.hist_err(del_R_W_B,bins=100,range=(0,8)) #plt.axis([0, 8, 0, 8]) plt.title(r"W and B $\Delta$R") #plt.xlabel(r"$\Delta$R") plt.subplot(2, 1, 2)