def plot_histo(dat,fig_idx,user_label='histo',clearFigure=True,user_xlim=[0,100],user_bin_width=0.01, scale_factor=1, user_color=None): fig = plt.figure(num=fig_idx) if clearFigure: fig.clear() ax = fig.gca() xs, ys = bin_dat(dat,isBinAligned=True,bin_width=user_bin_width,user_roi=user_xlim) # ys_sm = ppd.do_smooth_with_gaussian(ys, std=5) if user_color is None: ax.plot(xs,scale_factor*ys,label=user_label,linewidth=1) else: ax.plot(xs,scale_factor*ys,label=user_label,linewidth=1, color=user_color) ax.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax.grid() fig.tight_layout() fig.canvas.manager.window.raise_() ax.set_yscale('log') ax.legend() plt.pause(0.1) return ax
def do_counting(epos, pk_params, glob_bg_param): xs, _ = bin_dat(epos['m2q'],user_roi=[0,150],isBinAligned=True) glob_bg = physics_bg(xs,glob_bg_param) cts = np.full(pk_params.size,-1,dtype=[('total','f4'), ('local_bg','f4'), ('global_bg','f4')]) for idx,pk_param in enumerate(pk_params): pk_rng = [pk_param['pre_rng'],pk_param['post_rng']] # print('pk rng',pk_rng) local_bg_cts = pk_param['loc_bg']*(pk_rng[1]-pk_rng[0])/0.001 global_bg_cts = np.sum(glob_bg[(xs>=pk_rng[0]) & (xs<=pk_rng[1])]) tot_cts = np.sum((epos['m2q']>=pk_rng[0]) & (epos['m2q']<=pk_rng[1])) # print('tot counts',tot_cts) cts['total'][idx] = tot_cts cts['local_bg'][idx] = local_bg_cts cts['global_bg'][idx] = global_bg_cts return cts
def log_xcorr_est_c(ref_m2q, tof): # This assumes that the t0 is not crazy off l_ref = np.log10(ref_m2q[ref_m2q > 0.5]) tmp = np.square(tof) # PROBLEM HERE... new 4000 goes out to 40 us and 3000 went to 5 us! c_est = np.max(ref_m2q) / np.max(tmp) tmp = tmp * c_est l_q = np.log10(tmp[tmp > 0.5]) xs_l_ref, ys_l_ref = bin_dat(l_ref, 0.01, user_roi=[-0.5, 4], isBinAligned=True, isDensity=True) ys_l_ref = ys_l_ref - medfilt(ys_l_ref, kernel_size=15) xs_l_q, ys_l_q = bin_dat(l_q, 0.01, user_roi=[-0.5, 4], isBinAligned=True, isDensity=True) ys_l_q = ys_l_q - medfilt(ys_l_q, kernel_size=15) res = np.convolve(ys_l_ref, ys_l_q[::-1], mode='same') # We know the remaining shift should be small N4 = res.size // 4 res[0:N4] = 0 res[3 * N4:-1] = 0 x_c = np.mean(xs_l_q) x_max = xs_l_q[np.argmax(res)] c_refine = 10**(x_c - x_max) c_guess = c_est / c_refine # fig = plt.figure(num=113) # fig.clear() # ax = fig.gca() # # ax.plot(xs_l_ref,res,label='conv') # plt.pause(1) return c_guess
def plot_spectrum_gory_detail(epos, user_roi, pk_params, bg_rois, glob_bg_param, is_peak, fig_idx): from histogram_functions import bin_dat import peak_param_determination as ppd xs, ys = bin_dat(epos['m2q'], user_roi=user_roi, isBinAligned=True) #ys_sm = ppd.do_smooth_with_gaussian(ys,30) ys_sm = ppd.moving_average(ys, 30) glob_bg = ppd.physics_bg(xs, glob_bg_param) fig = plt.figure(num=fig_idx) fig.clear() ax = fig.gca() ax.plot(xs, ys_sm, label='hist') ax.plot(xs, glob_bg, label='global bg') ax.set(xlabel='m/z (Da)', ylabel='counts') ax.grid() fig.tight_layout() fig.canvas.manager.window.raise_() ax.set_yscale('log') ax.legend() for idx, pk_param in enumerate(pk_params): if is_peak[idx]: ax.plot( np.array([1, 1]) * pk_param['pre_rng'], np.array([0.5, (pk_param['amp'] + pk_param['off'])]), 'k--') ax.plot( np.array([1, 1]) * pk_param['post_rng'], np.array([0.5, (pk_param['amp'] + pk_param['off'])]), 'k--') ax.plot( np.array([1, 1]) * pk_param['pre_bg_rng'], np.array([0.5, (pk_param['amp'] + pk_param['off'])]), 'm--') ax.plot( np.array([1, 1]) * pk_param['post_bg_rng'], np.array([0.5, (pk_param['amp'] + pk_param['off'])]), 'm--') ax.plot( np.array([pk_param['pre_bg_rng'], pk_param['post_bg_rng']]), np.ones(2) * pk_param['loc_bg'], 'g--') else: ax.plot( np.array([1, 1]) * pk_param['x0_mean_shift'], np.array([0.5, (pk_param['amp'] + pk_param['off'])]), 'r--') for roi in bg_rois: xbox = np.array([roi[0], roi[0], roi[1], roi[1]]) ybox = np.array([0.1, np.max(ys_sm) / 10, np.max(ys_sm) / 10, 0.1]) ax.fill(xbox, ybox, 'b', alpha=0.2) plt.pause(0.1) return None
def bin_and_smooth_spectrum(epos, user_roi, bin_wid_mDa=30, smooth_wid_mDa=-1): from histogram_functions import bin_dat import peak_param_determination as ppd xs, ys = bin_dat(epos['m2q'], user_roi=user_roi, isBinAligned=True, bin_width=bin_wid_mDa / 1000.0) if smooth_wid_mDa > 0: ys_sm = ppd.moving_average(ys, smooth_wid) * smooth_wid else: ys_sm = ys return (xs, ys_sm)
def get_wid(tof, t_guess, t_width): t_ms = ppd.mean_shift_peak_location(tof, user_std=1, user_x0=t_guess) xs, ys = bin_dat(tof, bin_width=0.1, user_roi=[t_ms - t_width / 2, t_ms + t_width / 2], isBinAligned=False, isDensity=False) pk_idx = np.argmin(np.abs(t_ms - xs)) pk_val = ys[pk_idx] fig = plt.figure(num=89, figsize=(FIGURE_SCALE_FACTOR * 3.14961, FIGURE_SCALE_FACTOR * 3.14961 * 0.7)) fig.clear() ax = fig.gca() ax.plot(xs, ys, '-') plt.pause(2) rhs = 1e6 for idx in np.arange(pk_idx, ys.size): if ys[idx] < 0.5 * pk_val: # compute x1 = xs[idx - 1] x2 = xs[idx] y1 = ys[idx - 1] y2 = ys[idx] m = (y2 - y1) / (x2 - x1) b = y1 - m * x1 rhs = (0.5 * pk_val - b) / m break lhs = -1e6 for idx in np.arange(pk_idx, 0, -1): if ys[idx] < 0.5 * pk_val: # compute x1 = xs[idx + 1] x2 = xs[idx] y1 = ys[idx + 1] y2 = ys[idx] m = (y2 - y1) / (x2 - x1) b = y1 - m * x1 lhs = (0.5 * pk_val - b) / m break wid = rhs - lhs return wid
def do_chi2v3(tof, tof_roi, N_lower, N_upper): tof1 = tof[0::2] tof1_idxs = np.array(range(0, tof1.size)) * 2 tof2 = tof[1::2] tof2_idxs = np.array(range(0, tof2.size)) * 2 + 1 N = N_upper - N_lower + 1 slicings = np.logspace(N_lower, N_upper, N, base=2) opt_res = np.zeros(N) time_res = np.zeros(N) for idx, cts_per_slice in enumerate(slicings): t_start = time.time() pointwise_scales, piecewise_scales = scaling_correction.get_all_scale_coeffs( tof1, m2q_roi=tof_roi, cts_per_slice=cts_per_slice, max_scale=1.075, delta_ly=1e-4) t_end = time.time() time_res[idx] = t_end - t_start print('Total Time = ', time_res[idx]) f = scipy.interpolate.interp1d(tof1_idxs, pointwise_scales, fill_value='extrapolate') # Compute corrected data tof_corr = tof1 / f(tof1_idxs) _, ys = bin_dat(tof_corr, isBinAligned=True, bin_width=0.1, user_roi=tof_roi) opt_res[idx] = chi2(ys) print(opt_res[idx]) print(slicings) print(opt_res / np.max(opt_res)) print(time_res) return (slicings, opt_res)
def do_chi2(tof, tof_roi, N_lower, N_upper): tof1 = tof[0::2] tof2 = tof[1::2] N = N_upper - N_lower + 1 slicings = np.logspace(N_lower, N_upper, N, base=2) opt_res = np.zeros(N) time_res = np.zeros(N) for idx, cts_per_slice in enumerate(slicings): t_start = time.time() pointwise_scales, piecewise_scales = scaling_correction.get_all_scale_coeffs( tof1, m2q_roi=tof_roi, cts_per_slice=cts_per_slice, max_scale=1.075, delta_ly=2e-4) t_end = time.time() time_res[idx] = t_end - t_start print('Total Time = ', time_res[idx]) # Compute corrected data tof_corr = tof2 / pointwise_scales _, ys = bin_dat(tof_corr, isBinAligned=True, bin_width=0.1, user_roi=tof_roi) opt_res[idx] = chi2(ys) print(opt_res[idx]) print(slicings) print(opt_res / np.max(opt_res)) print(time_res) return (slicings, opt_res / np.max(opt_res))
def sio2_R45_histo(): def shaded_plot(ax, x, y, idx, col_idx=None, min_val=None): if col_idx is None: col_idx = idx if min_val is None: min_val = np.min(y) sc = 150 cols = [ '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf' ] xlim = ax.get_xlim() idxs = np.nonzero((x >= xlim[0]) & (x <= xlim[1])) ax.fill_between(x[idxs], y[idxs], min_val, color=cols[col_idx], linestyle='None', lw=0) # ax.plot(x,y+idx*sc, color='k') return fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_04472-v03.epos" epos = apt_fileio.read_epos_numpy(fn) epos = epos[25000:] epos = epos[:400000] # Voltage and bowl correct ToF data p_volt = np.array([]) p_bowl = np.array([]) t_i = time.time() tof_corr, p_volt, p_bowl = do_voltage_and_bowl(epos, p_volt, p_bowl) print("time to voltage and bowl correct: " + str(time.time() - t_i) + " seconds") # fake_tof = np.sqrt((296/312)*epos['m2q']/1.393e-4) m2q_roi = [0.8, 80] m2q_to_tof = 613 / np.sqrt(59) tof_roi = [m2q_roi[0] * m2q_to_tof, m2q_roi[1] * m2q_to_tof] cts_per_slice = 2**7 #m2q_roi = [0.9,190] # tof_roi = [0, 1000] t_start = time.time() pointwise_scales, piecewise_scales = scaling_correction.get_all_scale_coeffs( tof_corr, m2q_roi=tof_roi, cts_per_slice=cts_per_slice, max_scale=1.075) t_end = time.time() print('Total Time = ', t_end - t_start) # fake_tof_corr = fake_tof/np.sqrt(pointwise_scales) q_tof_corr = tof_corr / pointwise_scales OVERALL_CALIB_FACTOR = 1.0047693561704287 m2q_corr = OVERALL_CALIB_FACTOR * m2q_to_tof**-2 * q_tof_corr**2 m2q_vbcorr = OVERALL_CALIB_FACTOR * m2q_to_tof**-2 * tof_corr**2 fig = plt.figure(constrained_layout=True, figsize=(FIGURE_SCALE_FACTOR * 3.14961, FIGURE_SCALE_FACTOR * 3.14961), num=7, dpi=100) plt.clf() gs = plt.GridSpec(2, 3, figure=fig) ax0 = fig.add_subplot(gs[0, :]) # identical to ax1 = plt.subplot(gs.new_subplotspec((0, 0), colspan=3)) ax1 = fig.add_subplot(gs[1, 0:2]) #ax2 = fig.add_subplot(gs[1,1]) ax3 = fig.add_subplot(gs[1, 2]) dat = m2q_vbcorr user_bin_width = 0.02 user_xlim = [0, 65] ax0.set(xlim=user_xlim) dat = m2q_corr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax0, xs, 100 * (1 + ys), 1, min_val=100) dat = m2q_vbcorr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax0, xs, 1 + ys, 0, min_val=1) ax0.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax0.set_yscale('log') # user_bin_width = 0.02 user_xlim = [13, 19] ax1.set(xlim=user_xlim) dat = m2q_corr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax1, xs, 100 * (1 + ys), 1, min_val=100) dat = m2q_vbcorr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax1, xs, 1 + ys, 0, min_val=1) ax1.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax1.set_yscale('log') # # ##user_bin_width = 0.01 #user_xlim = [30,34] #ax2.set(xlim=user_xlim) # # #dat = m2q_corr #xs, ys = bin_dat(dat,isBinAligned=True,bin_width=user_bin_width,user_roi=user_xlim) #shaded_plot(ax2,xs,100*(1+ys),1,min_val=100) # # #dat = epos['m2q'] #xs, ys = bin_dat(dat,isBinAligned=True,bin_width=user_bin_width,user_roi=user_xlim) #shaded_plot(ax2,xs,1+ys,0,min_val=1) # # #ax2.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) #ax2.set_yscale('log') #user_bin_width = 0.01 user_xlim = [58, 64] ax3.set(xlim=user_xlim) dat = m2q_corr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax3, xs, 100 * (1 + ys), 1, min_val=100) dat = m2q_vbcorr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax3, xs, 1 + ys, 0, min_val=1) ax3.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax3.set_yscale('log') ax0.set(ylim=[1, None]) ax1.set(ylim=[1, None]) # ax2.set(ylim=[1,None]) ax3.set(ylim=[1, None]) fig.tight_layout() fig.savefig( r'Q:\users\bwc\APT\scale_corr_paper\SiO2_NUV_corrected_hist.pdf', format='pdf', dpi=600) return 0
gs = plt.GridSpec(2, 3, figure=fig) ax0 = fig.add_subplot(gs[0, :]) # identical to ax1 = plt.subplot(gs.new_subplotspec((0, 0), colspan=3)) ax1 = fig.add_subplot(gs[1, 0:2]) #ax2 = fig.add_subplot(gs[1,1]) ax3 = fig.add_subplot(gs[1, 2]) dat = epos['m2q'] user_bin_width = 0.03 user_xlim = [0, 65] ax0.set(xlim=user_xlim) dat = m2q_corr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax0, xs, 100 * (1 + ys), 1, min_val=100) dat = epos['m2q'] xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax0, xs, 1 + ys, 0, min_val=1) ax0.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax0.set_yscale('log') user_bin_width = 0.01 user_xlim = [13, 19]
2 * ed['N'].isotopes[14][0], (1 / 2) * ed['Ga'].isotopes[69][0], (1 / 2) * ed['Ga'].isotopes[71][0], ed['Ga'].isotopes[69][0], ed['Ga'].isotopes[71][0] ]) # Perform 'linearization' m2q calibration m2q_corr2 = m2q_calib.calibrate_m2q_by_peak_location(m2q_corr, ref_pk_m2qs) # Plot the reference spectrum, (c, t0) corr spectrum and linearized spectrum # to confirm that mass calibration went ok # Save the data as a new epos file full_roi = np.array([0, 100]) xs_full_1mDa, ys_full_1mDa = bin_dat(m2q_corr, user_roi=full_roi, isBinAligned=True) ys_full_5mDa_sm = ppd.do_smooth_with_gaussian(ys_full_1mDa, std=5) xs_full_1mDa_ref, ys_full_1mDa_ref = bin_dat(ref_epos['m2q'], user_roi=full_roi, isBinAligned=True) ys_full_5mDa_sm_ref = ppd.do_smooth_with_gaussian(ys_full_1mDa_ref, std=5) fig = plt.figure(num=1) fig.clear() ax = plt.axes() ax.plot(xs_full_1mDa_ref, ys_full_5mDa_sm_ref, label='ref') ax.plot(xs_full_1mDa, ys_full_5mDa_sm, label='dat') # Perform linear calibration over known peaks
def testing(): # Load data # fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_00504-v56.epos" # fn = r"\\cfs2w.campus.nist.gov\647\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_04472-v02_allVfromAnn.epos" fn = r"C:\Users\bwc\Documents\NetBeansProjects\R44_03115\recons\recon-v02\default\R44_03115-v02.epos" epos = apt_fileio.read_epos_numpy(fn) # epos = epos[0:1000000] epos1 = epos[0:-1:2] epos2 = epos[1::2] N_lower = 8 N_upper = 16 N = N_upper-N_lower+1 slicings = np.logspace(N_lower,N_upper,N,base=2) opt_res = np.zeros(N) time_res = np.zeros(N) for idx,cts_per_slice in enumerate(slicings): m2q_roi = [0.9,180] import time t_start = time.time() pointwise_scales,piecewise_scales = get_all_scale_coeffs(epos1['m2q'], m2q_roi=m2q_roi, cts_per_slice=cts_per_slice, max_scale=1.15) t_end = time.time() time_res[idx] = t_end-t_start print('Total Time = ',time_res[idx]) # Compute corrected data m2q_corr = epos2['m2q']/pointwise_scales _, ys = bin_dat(m2q_corr,isBinAligned=True,bin_width=0.01,user_roi=[0,250]) opt_res[idx] = chi2(ys) # ys = ys/np.sum(ys) # opt_res[idx] = np.sum(np.square(ys)) # opt_res[idx] = test_1d_vec(m2q_corr[(m2q_corr>0.8) & (m2q_corr<80)]) print(opt_res[idx]) print(slicings) print(opt_res/np.max(opt_res)) print(time_res) fig = plt.figure(num=666) fig.clear() ax = fig.gca() ax.plot(tmpx,tmpy,'s-', markersize=8,label='SiO2') ax.plot(slicings,opt_res/np.max(opt_res),'o-', markersize=8,label='ceria') ax.set(xlabel='N (events per chunk)', ylabel='compactness metric (normalized)') ax.set_xscale('log') ax.legend() ax.set_xlim(5,1e5) ax.set_ylim(0.15, 1.05) fig.tight_layout() return 0
def __main__(): plt.close('all') # # Load data fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_00504-v56.epos" fn = r"\\cfs2w.campus.nist.gov\647\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_04472-v02_allVfromAnn.epos" #fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\GaN epos files\R20_07148-v01_vbm_corr.epos" #fn = r"D:\Users\clifford\Documents\Python Scripts\NIST_DATA\R20_07094-v03.epos" #fn = r"D:\Users\clifford\Documents\Python Scripts\NIST_DATA\R45_04472-v03.epos" #fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\Final EPOS for APL Mat Paper\R20_07263-v02.epos" #fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\Final EPOS for APL Mat Paper\R20_07080-v01.epos" #fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\Final EPOS for APL Mat Paper\R20_07086-v01.epos" #fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\Final EPOS for APL Mat Paper\R20_07276-v03.epos" # fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_04472-v03.epos" #fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_04472-v02.epos" # fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\GaN epos files\R20_07148-v01.epos" # Mg doped # fn = fn[:-5]+'_vbm_corr.epos' epos = apt_fileio.read_epos_numpy(fn) # plotting_stuff.plot_TOF_vs_time(epos['m2q'],epos,1,clearFigure=True,user_ylim=[0,150]) # epos = epos[0:2**20] cts_per_slice=2**10 m2q_roi = [0.8,75] import time t_start = time.time() pointwise_scales,piecewise_scales = get_all_scale_coeffs(epos['m2q'], m2q_roi=m2q_roi, cts_per_slice=cts_per_slice, max_scale=1.15) t_end = time.time() print('Total Time = ',t_end-t_start) # Plot histogram in log space lys_corr = np.log(epos['m2q'])-np.log(pointwise_scales) N,x_edges,ly_edges = create_histogram(lys_corr,y_roi=m2q_roi,cts_per_slice=cts_per_slice) # fig = plt.figure(figsize=(8,8)) # plt.imshow(np.log1p(np.transpose(N)), aspect='auto', interpolation='none', # extent=extents(x_edges) + extents(ly_edges), origin='lower') # # Compute corrected data m2q_corr = epos['m2q']/pointwise_scales # Plot data uncorrected and corrected TEST_PEAK = 32 ax = plotting_stuff.plot_TOF_vs_time(epos['m2q'],epos,111,clearFigure=True,user_ylim=[0,75]) ax.plot(pointwise_scales*TEST_PEAK) plotting_stuff.plot_TOF_vs_time(m2q_corr,epos,222,clearFigure=True,user_ylim=[0,75]) # Plot histograms uncorrected and corrected plotting_stuff.plot_histo(m2q_corr,333,user_xlim=[0, 75],user_bin_width=0.01) plotting_stuff.plot_histo(epos['m2q'],333,user_xlim=[0, 75],clearFigure=False,user_bin_width=0.01) # epos['m2q'] = m2q_corr # apt_fileio.write_epos_numpy(epos,'Q:\\NIST_Projects\\EUV_APT_IMS\\BWC\\GaN epos files\\R20_07148-v01_vbmq_corr.epos') _, ys = bin_dat(m2q_corr,isBinAligned=True,bin_width=0.01,user_roi=[0,75]) print(np.sum(np.square(ys))) return 0
def ceria_histo(): def shaded_plot(ax, x, y, idx, col_idx=None, min_val=None): if col_idx is None: col_idx = idx if min_val is None: min_val = np.min(y) cols = [ '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf' ] xlim = ax.get_xlim() idxs = np.nonzero((x >= xlim[0]) & (x <= xlim[1])) ax.fill_between(x[idxs], y[idxs], min_val, color=cols[col_idx], linestyle='None', lw=0) # ax.plot(x,y+idx*sc, color='k') return fn = r"Q:\NIST_Projects\EUV_APT_IMS\BWC\R45_data\R45_00504-v56.epos" epos = apt_fileio.read_epos_numpy(fn) red_epos = epos[100000::10] # Voltage and bowl correct ToF data p_volt = np.array([]) p_bowl = np.array([]) t_i = time.time() _, p_volt, p_bowl = do_voltage_and_bowl(red_epos, p_volt, p_bowl) print("time to voltage and bowl correct: " + str(time.time() - t_i) + " seconds") tof_vcorr = voltage_and_bowl.mod_full_voltage_correction( p_volt, epos['tof'], epos['v_dc']) tof_corr = voltage_and_bowl.mod_geometric_bowl_correction( p_bowl, tof_vcorr, epos['x_det'], epos['y_det']) m2q_roi = [10, 250] m2q_to_tof = 1025 / np.sqrt(172) tof_roi = [m2q_roi[0] * m2q_to_tof, m2q_roi[1] * m2q_to_tof] tof_roi = [200, 1200] cts_per_slice = 2**9 #m2q_roi = [0.9,190] # tof_roi = [0, 1000] t_start = time.time() pointwise_scales, piecewise_scales = scaling_correction.get_all_scale_coeffs( tof_corr, m2q_roi=tof_roi, cts_per_slice=cts_per_slice, max_scale=1.075) t_end = time.time() print('Total Time = ', t_end - t_start) # fake_tof_corr = fake_tof/np.sqrt(pointwise_scales) q_tof_corr = tof_corr / pointwise_scales OVERALL_CALIB_FACTOR = 0.9956265249773827 m2q_corr = OVERALL_CALIB_FACTOR * m2q_to_tof**-2 * q_tof_corr**2 m2q_vbcorr = OVERALL_CALIB_FACTOR * m2q_to_tof**-2 * tof_corr**2 fig = plt.figure(constrained_layout=True, figsize=(FIGURE_SCALE_FACTOR * 3.14961, FIGURE_SCALE_FACTOR * 3.14961), num=8, dpi=100) plt.clf() gs = plt.GridSpec(2, 4, figure=fig) ax0 = fig.add_subplot(gs[0, :]) # identical to ax1 = plt.subplot(gs.new_subplotspec((0, 0), colspan=3)) ax1 = fig.add_subplot(gs[1, 0:2]) #ax2 = fig.add_subplot(gs[1,1]) ax3 = fig.add_subplot(gs[1, 2:4]) dat = m2q_vbcorr user_bin_width = 0.02 user_xlim = [0, 200] ax0.set(xlim=user_xlim) dat = m2q_corr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax0, xs, 10 * (1 + ys), 1, min_val=10) dat = m2q_vbcorr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax0, xs, 1 + ys, 0, min_val=1) ax0.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax0.set_yscale('log') ax0.set(ylim=[10, None]) # user_bin_width = 0.02 user_xlim = [75, 85] ax1.set(xlim=user_xlim) dat = m2q_corr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax1, xs, 10 * (1 + ys), 1, min_val=10) dat = m2q_vbcorr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax1, xs, 1 + ys, 0, min_val=1) ax1.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax1.set_yscale('log') ax1.set(ylim=[10, None]) # # ##user_bin_width = 0.01 #user_xlim = [30,34] #ax2.set(xlim=user_xlim) # # #dat = m2q_corr #xs, ys = bin_dat(dat,isBinAligned=True,bin_width=user_bin_width,user_roi=user_xlim) #shaded_plot(ax2,xs,100*(1+ys),1,min_val=100) # # #dat = epos['m2q'] #xs, ys = bin_dat(dat,isBinAligned=True,bin_width=user_bin_width,user_roi=user_xlim) #shaded_plot(ax2,xs,1+ys,0,min_val=1) # # #ax2.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) #ax2.set_yscale('log') # user_bin_width = 0.03 user_xlim = [154, 170] ax3.set(xlim=user_xlim) dat = m2q_corr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax3, xs, 10 * (1 + ys), 1, min_val=10) dat = m2q_vbcorr xs, ys = bin_dat(dat, isBinAligned=True, bin_width=user_bin_width, user_roi=user_xlim) shaded_plot(ax3, xs, 1 + ys, 0, min_val=1) ax3.set(xlabel='m/z (Da)', ylabel='counts', xlim=user_xlim) ax3.set_yscale('log') ax3.set(ylim=[10, 1e4]) ax3.set_xticks(np.arange(154, 170 + 1, 4)) fig.tight_layout() fig.savefig( r'Q:\users\bwc\APT\scale_corr_paper\Ceria_NUV_corrected_hist.pdf', format='pdf', dpi=600) return 0
def get_peak_ranges(epos, peak_m2qs,peak_height_fraction=0.01, glob_bg_param=0): # Initialize a peak paramter array pk_params = np.full(peak_m2qs.size,-1,dtype=[('x0_nominal','f4'), ('x0_g_fit','f4'), ('x0_mean_shift','f4'), ('std_fit','f4'), ('off','f4'), ('amp','f4'), ('pre_rng','f4'), ('post_rng','f4'), ('pre_bg_rng','f4'), ('post_bg_rng','f4'), ('loc_bg','f4')]) pk_params['x0_nominal'] = peak_m2qs full_roi = np.array([0, 150]) xs_full_1mDa, ys_full_1mDa = bin_dat(epos['m2q'],user_roi=full_roi,isBinAligned=True) ys_full_5mDa_sm = do_smooth_with_gaussian(ys_full_1mDa, std=5) N_kern = 250; ys_full_fwd_sm = forward_moving_average(ys_full_1mDa,n=N_kern) ys_full_bwd_sm = forward_moving_average(ys_full_1mDa,n=N_kern,reverse=True) ys_glob_bg_1mDa = physics_bg(xs_full_1mDa,glob_bg_param) # Get estiamtes for x0, amp, std_fit for idx,pk_param in enumerate(pk_params): # Select peak roi roi_half_wid = 0.5 pk_roi = np.array([-roi_half_wid, roi_half_wid])+pk_param['x0_nominal'] pk_dat = epos['m2q'][(epos['m2q']>pk_roi[0]) & (epos['m2q']<pk_roi[1])] # Fit to gaussian smooth_param = 5 popt = fit_to_g_off(pk_dat,user_std=smooth_param) pk_param['amp'] = popt[0] pk_param['x0_g_fit'] = popt[1] pk_param['std_fit'] = popt[2] pk_param['off'] = popt[3] # print('gaussian peak loc',pk_param['x0_g_fit']) pk_param['x0_mean_shift'] = mean_shift_peak_location(pk_dat,user_std=pk_param['std_fit'],user_x0=pk_param['x0_g_fit']) # ax = plt.gca() # ax.plot(np.array([1,1])*pk_param['x0_mean_shift'],np.array([0, pk_param['amp']+pk_param['off']]),'k--') # plt.pause(0.001) # plt.pause(2) # select starting locations pk_idx = np.argmin(np.abs(pk_param['x0_mean_shift']-xs_full_1mDa)) pk_lhs_idx = np.argmin(np.abs((pk_param['x0_mean_shift']-pk_param['std_fit'])-xs_full_1mDa)) pk_rhs_idx = np.argmin(np.abs((pk_param['x0_mean_shift']+pk_param['std_fit'])-xs_full_1mDa)) # Create a peak amplitude estimate. I use the average of the gaussian amplitude and the 5 mDa smoothed data. # Notice the gaussian amplitude has the baseline removed, and therefor I subtract the global background from the smoothed data. pk_amp = 0.5*(pk_param['amp'] + ys_full_5mDa_sm[pk_idx]-ys_glob_bg_1mDa[pk_idx]) curr_val = ys_full_5mDa_sm[pk_idx] for i in np.arange(pk_lhs_idx,-1,-1): curr_val = ys_full_5mDa_sm[i] # Note that the global background is subtracted off the current value. One day I should make this more general... if ((curr_val-ys_glob_bg_1mDa[i]) < peak_height_fraction*pk_amp) and (pk_param['pre_rng']<0): # This is a range limit pk_param['pre_rng'] = xs_full_1mDa[i] if curr_val<ys_full_bwd_sm[i]: # Assume we are at the prepeak baseline noise if pk_param['pre_rng']<0: pk_param['pre_rng'] = xs_full_1mDa[i] pk_param['pre_bg_rng'] = xs_full_1mDa[i] break curr_val = ys_full_5mDa_sm[pk_idx] for i in np.arange(pk_rhs_idx,xs_full_1mDa.size): curr_val = ys_full_5mDa_sm[i] if ((curr_val-ys_glob_bg_1mDa[i]) < peak_height_fraction*pk_amp) and (pk_param['post_rng']<0): # This is a range limit pk_param['post_rng'] = xs_full_1mDa[i] if curr_val<ys_full_fwd_sm[i]: # Assume we are at the prepeak baseline noise if pk_param['post_rng']<0: pk_param['post_rng'] = xs_full_1mDa[i] pk_param['post_bg_rng'] = xs_full_1mDa[i] break pre_pk_rng = [pk_param['pre_bg_rng']-0.22,pk_param['pre_bg_rng']-0.02] pk_param['loc_bg'] = np.sum((epos['m2q']>=pre_pk_rng[0]) & (epos['m2q']<=pre_pk_rng[1]))*0.001/(pre_pk_rng[1]-pre_pk_rng[0]) # ax.plot(np.array([1,1])*pk_param['pre_rng'] ,np.array([0,1])*(pk_param['amp']+pk_param['off']),'k--') # ax.plot(np.array([1,1])*pk_param['post_rng'] ,np.array([0,1])*(pk_param['amp']+pk_param['off']),'k--') # # ax.plot(np.array([1,1])*(pk_param['x0']+1*pk_param['std_fit']) ,np.array([np.min(ys_smoothed),np.max(ys_smoothed)]),'k--') # # ax.plot(np.array([1,1])*(pk_param['x0']+5*pk_param['std_fit']),np.array([np.min(ys_smoothed),np.max(ys_smoothed)]),'k--') # plt.pause(0.1) # ax.clear() # ax.plot(xs_full_1mDa,ys_full_5mDa_sm,label='5 mDa smooth') # for idx,pk_param in enumerate(pk_params): # ax.plot(np.array([1,1])*pk_param['pre_rng'] ,np.array([0.5,(pk_param['amp']+pk_param['off'])]),'k--') # ax.plot(np.array([1,1])*pk_param['post_rng'] ,np.array([0.5,(pk_param['amp']+pk_param['off'])]),'k--') # ax.plot(np.array([1,1])*pk_param['pre_bg_rng'] ,np.array([0.5,(pk_param['amp']+pk_param['off'])]),'r--') # ax.plot(np.array([1,1])*pk_param['post_bg_rng'] ,np.array([0.5,(pk_param['amp']+pk_param['off'])]),'r--') # # ax.set_yscale('log') # ax.set(ylim=[0.1,1000]) return pk_params
print('Total Ranged Ions: ' + str(np.sum(cts['total']))) print('Total Ranged Local Background Ions: ' + str(np.sum(cts['local_bg']))) print('Total Ranged Global Background Ions: ' + str(np.sum(cts['global_bg']))) print('Total Ions: ' + str(epos.size)) print('Overall CSR (no bg) : ' + str(np.sum(cts['total'][Ga2p_idxs]) / np.sum(cts['total'][Ga1p_idxs]))) print('Overall CSR (local bg) : ' + str( (np.sum(cts['total'][Ga2p_idxs]) - np.sum(cts['local_bg'][Ga2p_idxs])) / (np.sum(cts['total'][Ga1p_idxs]) - np.sum(cts['local_bg'][Ga1p_idxs])))) print('Overall CSR (global bg): ' + str( (np.sum(cts['total'][Ga2p_idxs]) - np.sum(cts['global_bg'][Ga2p_idxs])) / (np.sum(cts['total'][Ga1p_idxs]) - np.sum(cts['global_bg'][Ga1p_idxs])))) # Plot all the things xs, ys = bin_dat(epos['m2q'], user_roi=[0.5, 100], isBinAligned=True) #ys_sm = ppd.do_smooth_with_gaussian(ys,10) ys_sm = ppd.moving_average(ys, 10) glob_bg = ppd.physics_bg(xs, glob_bg_param) fig = plt.figure(num=100) fig.clear() ax = fig.gca() ax.plot(xs, ys_sm, label='hist') ax.plot(xs, glob_bg, label='global bg') ax.set(xlabel='m/z (Da)', ylabel='counts') ax.grid() fig.tight_layout()
" seconds") # Find c and t0 for ToF data based on aligning to reference spectrum m2q_corr, p_m2q = m2q_calib.align_m2q_to_ref_m2q(ref_epos['m2q'], tof_corr, nom_voltage=np.mean( epos['v_dc'])) print(p_m2q) plotting_stuff.plot_histo(ref_epos['m2q'], 4, user_label='ref') plotting_stuff.plot_histo(m2q_corr[m2q_corr.size // 2:-1], 4, clearFigure=False, user_label='[c,t0] corr') xs, ys = bin_dat(tof_corr, isDensity=True, bin_width=0.25) bg_lvl = np.mean(ys[(xs > 1000) & (xs < 3500)]) idxs = np.nonzero((xs > 200) & (xs < 1000)) xs = xs[idxs] ys = ys[idxs] fig = plt.figure(num=113) fig.clear() ax = fig.gca() ax.plot(xs, np.cumsum(ys**2)) ax.plot(xs, np.cumsum((ys - bg_lvl)**2)) # Read in data
def fit_to_g_off(dat, user_std, user_p0=np.array([])): if dat.size<32: raise Exception('NEED MORE COUNTS IN PEAK') std = user_std xs,ys = bin_dat(dat) ys_smoothed = do_smooth_with_gaussian(ys,std) opt_fun = lambda p: np.sum(np.square(pk_mod_fun(xs, *p)-ys_smoothed)) # def resid_func(p): # return pk_mod_fun(xs,*p)-ys_smoothed N4 = ys_smoothed.size//4 mx_idx = np.argmax(ys_smoothed[N4:(3*N4)])+N4 if(user_p0.size == 0): p0 = np.array([ys_smoothed[mx_idx]-np.min(ys_smoothed), xs[mx_idx], 0.015, np.percentile(ys_smoothed,20)]) else: p0 = user_p0 # b_model2(x,amp_g,x0,sigma,b): lbs = np.array([0, np.percentile(xs,10), 0.005, 0]) ubs = np.array([2*p0[0], np.percentile(xs,90), 0.50, p0[0]]) # Force in bounds p_guess = np.sort(np.c_[lbs,p0,ubs])[:,1] # popt2, pcov = = curve_fit(pk_mod_fun, xs, ys_smoothed, p0=p_guess, bounds=(lbs,ubs), verbose=2, ftol=1e-12, max_nfev=2048) # popt2, pcov = = curve_fit(pk_mod_fun, xs, ys_smoothed) # bnds = ((0,2*p0[0]), # (np.percentile(xs,10),np.percentile(xs,90)), # (0.007,0.1), # (0,p0[0])) # # opts = {'xatol' : 1e-5, # 'fatol' : 1e-12, # 'maxiter' : 1024, # 'maxfev' : 1024, # 'disp' : True} ret_dict = constrNM(opt_fun,p_guess,lbs,ubs,xtol=1e-5, ftol=1e-12, maxiter=1024, maxfun=1024, full_output=1, disp=0) # print(p_guess) # print(ret_dict['xopt']) # res = minimize(opt_fun, # p_guess, # options=opts, ## bounds=bnds, # method='Nelder-Mead') # # if res.x[1]<np.percentile(xs,10) or res.x[1]>np.percentile(xs,90): # res.x = p_guess # print(np.abs(res.x)) # popt2 = least_squares(resid_func, x0=p0, bounds=(lbs,ubs), verbose=2, ftol=1e-12, max_nfev=2048) # curve_fit(pk_mod_fun, xs, ys_smoothed, p0=p0) # popt = least_squares(resid_func, p0, verbose=0, ftol=1e-12, max_nfev=2048) # # fig = plt.figure(num=999) # fig.clear() # ax = plt.axes() # # ax.plot(xs,ys,'.',label='raw') # ax.plot(xs,ys_smoothed,label='smoothed') # # mod_y = pk_mod_fun(xs,*p_guess) # ax.plot(xs,mod_y,label='guess') # # # mod_y = pk_mod_fun(xs,*res.x) # # ax.plot(xs,mod_y,label='fit') # # ax.legend() # # # # plt.pause(.001) # # # Find halfway down and up each side # max_idx = np.argmax(N) # max_val = N[max_idx] # # lhs_dat = N[0:max_idx] # rhs_dat = N[max_idx:] # # lhs_idx = np.argmin(np.abs(lhs_dat-max_val/2)) # rhs_idx = np.argmin(np.abs(rhs_dat-max_val/2))+max_idx ## # hwhm_est = (x[rhs_idx]-x[lhs_idx])/2 # # return np.abs(ret_dict['xopt'])
opt_res[idx] = chi2(ys) print(opt_res[idx]) print(slicings) print(opt_res / np.max(opt_res)) print(time_res) return (slicings, opt_res) x, y = do_chi2v3(varying_tof, tof_roi, 3, 10) plt.plot(x, y, label='same') x = [2**3, 2**10] y = np.array([1, 1]) * chi2( bin_dat(q_tof[0::2], isBinAligned=True, bin_width=0.1, user_roi=tof_roi)[1]) plt.plot(x, y, label='ref1') x = [2**3, 2**10] y = np.array([1, 1]) * chi2( bin_dat(q_tof[1::2], isBinAligned=True, bin_width=0.1, user_roi=tof_roi)[1]) plt.plot(x, y, label='ref2') plt.figure(32132313) pointwise_scales, piecewise_scales = scaling_correction.get_all_scale_coeffs( varying_tof, m2q_roi=tof_roi, cts_per_slice=2**6, max_scale=1.075,