Example #1
0
def plot_data(channels):
    
    for i,ch in enumerate(channels):#file_array):
      #cdata = B.get_file(ctrl_dir + cf)
      # get time slices for analysis         
      #f_name = "./Analysis_Results/"+str(29975)+"/Raw_Fitting/fit_results_4_"+ str(29975) + "_{0:5.3f}_{1:5.3f}_{2:d}.npz".format(0.000, 0.500, ch)#self.par['dtmin']/us, self.par['dtmax']/us, self.par['channel'])
      (dtmin,dtmax) = db.retrieve('dtmin, dtmax', 'Raw_Fitting', 'Shot = '+ str(shot) + ' AND Channel = '+ str(ch))      
      #cdata.par.get_value('input_result_file', str)
      pf_name =  "../Analysis_Results/"+str(shot)+"/Rate_Plotting/rate_results_4_"+ str(shot) + "_{0:5.3f}_{1:5.3f}_{2:d}.npz".format(dtmin, dtmax, ch)#cdata.par.get_value('output_file', str)
      
      #f_name = res_dir + f_name
      #pf_name = res_dir + pf_name
      
      # shot = cdata.par.get_value('shot_number',str)
      
      try:
          d = np.load(pf_name)
          #pd = B.get_file(pf_name)
      except:
          print("cannot open : ", pf_name, " skipping")
          continue
      t = d['t']#B.get_data(pd, 't')
      Ap  = d['Ap']#B.get_data(pd, 'Ap')
      dAp = d['dAp']#B.get_data(pd, 'dAp')
      
      

      # 
      # At  = B.get_data(pd, 'At')
      # dAt = B.get_data(pd, 'dAt')
      # 
      # A  = B.get_data(pd, 'A')
      # dA = B.get_data(pd, 'dA')
      # 
      # Total signal
      B.plot_exp(t, Ap, dAp, color = colors[ channels[i] ], ecolor='grey', label = 'Ch {}'.format(channels[i]), capsize = 0.)
      # B.plot_line(t, A, color = colors[i])
      #
      B.pl.xlabel('t [s]')
      B.pl.ylabel('Rate (p)')
      B.pl.title('Shot : '+ str(shot) )
      #B.pl.ylim((A_min, A_max))
      #B.pl.xlim((t_min, t_max))
    B.pl.legend(loc = 'upper right')
    B.pl.show()
Example #2
0
    def plot_results(self):

        draw_p = self.par['draw_p']
        draw_t = self.par['draw_t']
        draw_sum = self.par['draw_sum']

        #if pulser were added
        draw_pulser=self.par['draw_pul']
        
        dt = self.par['time_slice_width']*us

        # proton sum signal
        if draw_p :
            B.plot_exp(self.slice_t/us, self.A_sp/dt*us, self.dA_sp/dt*us, linestyle = '-', marker = 'o', color = 'b', ecolor='grey', capsize = 0.) #,markeredgecolor='g',

        # triton sum signal
        if draw_t:
            B.plot_exp(self.slice_t/us, self.A_st/dt*us, self.dA_st/dt*us, color = 'g', ecolor='grey', capsize = 0.)

        # pulser sum signal
        if draw_pulser:
            B.plot_exp(self.slice_t/us, self.A_pul/dt*us, self.dA_pul/dt*us, color = 'm', ecolor='grey', capsize = 0.)

        # Total signal
        if draw_sum :
            B.plot_exp(self.slice_t/us, self.A_t/dt*us, self.dA_t/dt*us, linestyle = '-',ecolor='grey', marker = '.',   capsize = 0., label='Ch %d'%self.par['channel'])
        o_file = self.var['of_name']

        if  not os.path.exists(os.path.dirname(o_file)):
                os.makedirs(os.path.dirname(o_file))

        B.pl.xlabel('t [s]')
        B.pl.ylabel('Rate [Hz]')
        B.pl.title('Shot : '+ str(self.par['shot']) +'/ channel: '+str(self.par['channel']))
        B.pl.xlim((self.par['dtmin']/us, self.par['dtmax']/us))
        B.pl.show()
        """
Example #3
0
C = h.bin_content
dC = h.bin_error
dM = M[1] - M[0]

# get the bin width
#dM = d.par.get_value('dx')

# get the histogram data
#M = d['xb']
#C = d['cont']
#dC = d['dcont']
#dC = np.sqrt(C)

# plot the data

B.plot_exp(M, C, dC)

# setup
# simple gaussian
A = B.Parameter(C.max(), 'A')
#x0 = B.Parameter(0.135, 'x0')
#x0 = B.Parameter(0.135, 'x0')
x0 = B.Parameter(0.956, 'x0')
#x01 = B.Parameter(0.545, 'x01')
sig = B.Parameter(.005, 'sigma')


def gaus(x):
    return A() * np.exp(-(x - x0())**2 / (2. * sig()**2))

Example #4
0
r4 = R0a[:, 3]
r5 = R0a[:, 4]
r6 = R0a[:, 5]

dr1 = sig_R0a[:, 0]
dr2 = sig_R0a[:, 1]
dr3 = sig_R0a[:, 2]
dr4 = sig_R0a[:, 3]
dr5 = sig_R0a[:, 4]
dr6 = sig_R0a[:, 5]

# range in R covered (2 sigma)

B.plot_exp(times,
           r1,
           dr1,
           color='r',
           label='view 1, ch {}'.format(channels[0][0]))
B.plot_exp(times,
           r2,
           dr2,
           color='g',
           label='view 2, ch {}'.format(channels[0][1]))
B.plot_exp(times,
           r3,
           dr3,
           color='b',
           label='view 3, ch {}'.format(channels[0][2]))
B.plot_exp(times,
           r4,
           dr4,
# read the data
mf = B.get_file('my_exp_1.data')

# get the data into arrays
t = B.get_data(mf, 'time')
dexp = B.get_data(mf,'dist')
derr = B.get_data(mf, 'd_err')

# print the values in a for loop
for i, D in enumerate(dexp):
    # indentation is important
    print 'time = ', t[i], 'distance = ', D, 'error = ', derr[i]
# end of the loop = end of indentation
# plot the data
B.plot_exp(t, dexp, derr)

# fit a line
fit = B.linefit(t, dexp, derr)

# draw the fit result
B.plot_line(fit.xpl, fit.ypl)

# add the labels
B.pl.xlabel('t (sec)')
B.pl.ylabel('Distance (m)')
B.pl.title('Distance vs time exp.')

# save the plot
B.pl.savefig('my_plot.pdf')
Example #6
0
sigma_strobe = 0.05

sigma_B = np.sqrt((((mu_naught / (2 * np.pi * R)) * df1['Sigmai(A)'])**2) +
                  (((-mu_naught * 3.00) / (2 * np.pi *
                                           ((R)**2)) * sigma_R)**2))

sigma_ang_vel = np.sqrt(sigma_strobe)

sigma_Imoment = (2 / 5) * np.sqrt(((((rBall)**2) * sigma_mBall)**2) +
                                  ((2 * (rBall * mBall * sigma_rBall))**2))

sigma_L = np.sqrt(((ang_vel * sigma_Imoment)**2) +
                  ((moment_I * sigma_ang_vel)**2))

sigma_mu = np.sqrt((((1 / BoverL) * sigma_omega)**2) +
                   (((-omega * L / ((0.002541)**2)) * sigma_B)**2) +
                   (((omega / 0.002541) * sigma_L)**2))

errorbar = sigma_omega

B.plot_exp(BoverL, omega, 0.008)

B.pl.title("Precesional Frequency over B/L")
B.pl.ylabel("Frequency (HZ)")
B.pl.xlabel("B/L")

fit2 = B.linefit(BoverL, omega)
B.plot_line(fit2.xpl, fit2.ypl)
B.pl.show()

#%%

A_a, X_a, S_a, A0_a, A1_a, Q = fit_draw_histo(h2_etap_phi, Fit=True)

#%%
A_a, X_a, S_a, A0_a, A1_a, Q = fit_draw_histo(h2_etap_mant, Fit=True)

#%%
A_a, X_a, S_a, A0_a, A1_a, Q = fit_draw_histo(h2_etap_be, Fit=True)

#%%
phi_bin_center = h2_etap_phi.y_bin_center

B.plot_exp(phi_bin_center, Q, marker='o')
B.pl.hlines(Q.mean(), phi_bin_center.min(), phi_bin_center.max())
plt.xlabel('azimuthal angle $\phi_{GJ}$', fontsize=8)
plt.ylabel('Q values', fontsize=8)

#%%
mant_bin_center = h2_etap_mant.y_bin_center
B.plot_exp(mant_bin_center, Q, marker='o')
B.pl.hlines(Q.mean(), mant_bin_center.min(), mant_bin_center.max())
plt.xlabel('momentum transfer t', fontsize=8)
plt.ylabel('Q values', fontsize=8)

#%%

e_beam_bin_center = h2_etap_be.y_bin_center
B.plot_exp(e_beam_bin_center, Q, marker='o')
Example #8
0
R = (23.5 + 17.9) / 2
sigma_R = (0.05**2) / 2
R = R / 100
sigma_R = sigma_R / 100
# units of R in mn

N = 195

Bfield = ((mu_naught * N * df['I']) / (R)) * ((4 / 5)**(3 / 2))
# Bfield = Bfield*10**6
#units in kg/As^2
Torque = df['r'] * m * g
Torque = Torque / 100

#error propagation
sigma_Torque = np.sqrt(((m * g * df['sigmar'])**2) +
                       ((df['r'] * g * sigma_m)**2))

# print(sigma_Torque)

B.plot_exp(Bfield, Torque, 0.00004)

B.pl.title("Torque Vs Magentic Field")
B.pl.ylabel("Torque   [(kgm^2)/(s^2)]")
B.pl.xlabel("Magnetic field *10^-6  [kg/(s^2)(A)]")

fit2 = B.linefit(Bfield, Torque)
B.plot_line(fit2.xpl, fit2.ypl)
B.pl.show()
Example #9
0
mBall = mBall / 1000
sigma_mBall = 0.05
sigma_mBall = sigma_mBall / 1000
# units in kg

moment_I = (2 * mBall * (rBall**2)) / 5

Bfield = ((mu_naught * N * df['Current(A)']) / (R)) * ((4 / 5)**(3 / 2))

IoverB = moment_I / Bfield

axis_X = 4 * (np.pi**2) * IoverB

print(Bfield)

B.plot_exp(Tsquared, axis_X, 0.15)

B.pl.title("Harmonic Motion")
B.pl.ylabel("4pi*I/B  (T^-1)")
B.pl.xlabel("period squared (s^2)")
fit2 = B.linefit(
    Tsquared,
    axis_X,
)

B.plot_line(fit2.xpl, fit2.ypl)
B.pl.show()

# plt.plot([list(axis_X)],[list(Tsquared)],'ro')
# plt.ylabel('period squared (s^2)')
# plt.xlabel('4pi*I/B  (T^-1)')
Example #10
0
A_fit.sigma_min.set(0.003)
A_fit.sigma_max.set(0.03)

A_fit.b0_min.set(0.5)
A_fit.b0_max.set(0.9)
A_fit.c0_min.set(45.)
A_fit.c0_max.set(70.)

A_fit.fit_gaussbt(pi0m, A_value, A_err)  # fit gauss peak with linear bkg
plt.figure()
A_fit.plot_fit()
B.plot_line(pi0m, A_fit.gauss(pi0m))
B.plot_line(pi0m, A_fit.bt_bkg(pi0m))
B.plot_exp(pi0m,
           A_value,
           A_err,
           plot_title='Fit the fit parameter A',
           x_label=' $M(\gamma\gamma)$')

plt.figure()
px0 = B.polyfit(pi0m, x0_value, x0_err, order=1)
B.plot_exp(pi0m,
           x0_value,
           x0_err,
           plot_title='Fit the fit parameter $x0$',
           x_label='bin centers of y-axis in 2D plot $M(\pi^{0})$')
B.plot_line(px0.xpl, px0.ypl)

plt.figure()
pS = B.polyfit(pi0m, S_value, S_err, order=2)
B.plot_exp(pi0m,
Example #11
0
        # calculate averages
        # use only proton data
        t_mean_b, w_mean_b, sig_w_mean_b = get_mean(t, Ap, dAp, t_wb)
        t_mean_a, w_mean_a, sig_w_mean_a = get_mean(t, Ap, dAp, t_wa)
        # append information to an array
        R_b.append([[t_mean_b, w_mean_b, sig_w_mean_b], cf, j,
                    nr_b])  #int(channel), j, nr_b] )
        R_a.append([[t_mean_a, w_mean_a, sig_w_mean_a], cf, j, nr_a])
        print('Channel : ', cf)  #hannel
        print('Mean before : ', get_mean(t, Ap, dAp, t_wb))
        print('Mean after : ', get_mean(t, Ap, dAp, t_wa))

    # Total signal
    B.plot_exp(t,
               Ap,
               dAp,
               color=colors[cf],
               label='Ch {}'.format(channels[i]),
               capsize=0.)
    # B.plot_line(t, A, color = colors[i])

B.pl.xlabel('t [s]')
B.pl.ylabel('Rate')
B.pl.legend(loc='upper right')
B.pl.title('Shot : ' + str(shot))
B.pl.ylim((A_min, A_max))
B.pl.xlim((t_min_pl, t_max_pl))

ymin, ymax = B.pl.ylim()
# before
B.pl.vlines(t_min_b, ymin, ymax, color='r')
B.pl.vlines(t_max_b, ymin, ymax, color='r')
Example #12
0
    def plot_results(self):

        draw_p = self.par['draw_p']
        draw_t = self.par['draw_t']
        draw_sum = self.par['draw_sum']

        # histogram setup
        h_min = self.par['h_min']
        h_max = self.par['h_max']
        h_bins = self.par['h_bins']
        h_range = (h_min, h_max)

        #if pulser were added
        add_pulser = self.par['add_pulser']
        # no histo fitting at this time
        fit_histos = False
        t_offset = self.par['t_offset']  #cdata.par.get_value('t_offset')*us
        # get directories
        f_name = self.var['f_name']

        # load data (faster loading then from txt)
        d = np.load(f_name)
        tr = d['t'] + t_offset
        Vpr = d['V']  # raw PH
        Ar = d['A']  # fitted PH
        dAr = d['sig_A']
        #        chir = np.zeros_like(tr)

        # positive signals
        pa = Ar > 0.
        r = np.abs(dAr[pa] / Ar[pa])
        # cut on error ratio
        r_cut_off = self.par['sig_ratio']
        # this is for good events
        gr = r < r_cut_off

        # this is to study background
        #gr = r > r_cut_off

        tg = tr[pa][gr]
        A = Ar[pa][gr]
        #        dA = dAr[pa][gr]
        #        chi = chir[pa][gr]

        # simple pulse heights for testing
        ta = tr[pa]
        Ap = Vpr[pa]  # raw data

        # time slice the data
        dt = self.par['time_slice_width'] * us  # step width

        # bin numbers
        i_t = (tg / dt).astype('int')
        i_t_a = (ta / dt).astype('int')
        # time slicing for fitted peaks
        slice_t = []
        slices = []
        i_start = 0
        i_bin = i_t[0]
        for i, ip in enumerate(i_t):
            if ip != i_bin or i == len(i_t) - 1:
                i_end = i
                # print "found slice from : ", i_start, i_end
                slice_t.append(i_bin * dt + 0.5 * dt)
                slices.append(slice(i_start, i_end))
                i_bin = ip
                i_start = i

        # time slicing for all peaks
        slice_t_a = []
        slices_a = []
        i_start_a = 0
        i_bin_a = 0
        for i, ip in enumerate(i_t_a):
            if ip == i_bin_a:
                continue
            else:
                i_end = i
                # print "found slice from : ", i_start, i_end
                slice_t_a.append(i_bin_a * dt + 0.5 * dt)
                slices_a.append(slice(i_start_a, i_end))
                i_bin_a = ip
                i_start_a = i

        # histogram
        h = []
        hp = []

        for i, s in enumerate(slices):
            hi = B.histo(A[s], range=h_range, bins=h_bins)
            h_time = "{0:6.4f} s".format(slice_t[i] / us)
            hi.title = h_time
            h.append(hi)

        for i, s in enumerate(slices_a):
            hip = B.histo(Ap[s], range=h_range, bins=h_bins)
            h_time = "{0:6.4f} s".format(slice_t_a[i] / us)
            hip.title = h_time
            hp.append(hip)

        self.h = h
        self.hp = hp

        print("created ", len(h), " histograms h")

        A_sp = []
        dA_sp = []

        A_st = []
        dA_st = []

        A_pul = []
        dA_pul = []

        # for protons
        p_min = self.par['p_min']  #cdata.par.get_value('p_min')
        p_max = self.par['p_max']  #cdata.par.get_value('p_max')
        # for tritons
        t_min = self.par['t_min']
        t_max = self.par['t_max']
        # fit histograms

        if add_pulser:
            pul_min = self.par['pulser_min']
            pul_max = self.par['pulser_max']

        # inital parameters
        A_init = self.par['A_init']
        sigma_init = self.par['sig_init']

        for i, hi in enumerate(h):
            # proton fit
            # hi.mean.set(p_mean) #check if necessary
            hi.A.set(A_init)
            hi.sigma.set(sigma_init)
            # fitting with limits
            if fit_histos:
                hi.fit(xmin=p_min, xmax=p_max)
            # sum histograms
            sp, dsp = hi.sum(xmin=p_min, xmax=p_max)
            st, dst = hi.sum(xmin=t_min, xmax=t_max)
            spul, dspul = hi.sum(xmin=pul_min, xmax=pul_max)
            A_sp.append(sp)
            dA_sp.append(dsp)
            A_st.append(st)
            dA_st.append(dst)
            A_pul.append(spul)
            dA_pul.append(dspul)
        # proton amplitudes
        A_sp = np.array(A_sp)
        dA_sp = np.array(dA_sp)
        # tritomn amplitudes
        A_st = np.array(A_st)
        dA_st = np.array(dA_st)
        # pulser amplitudes
        A_pul = np.array(A_pul)
        dA_pul = np.array(dA_pul)

        # total
        A_t = A_sp + A_st
        dA_t = np.sqrt(dA_sp**2 + dA_st**2)

        # fitting results
        if fit_histos:
            A_f = []
            dA_f = []
            chi_red = []
            m_f = []
            dm_f = []
            fact = np.sqrt(2. * np.pi)
            for i, hi in enumerate(h):
                bw = hi.bin_width
                sig = np.abs(hi.sigma())
                name, Am, dAm = hi.fit_par['A'].get()
                name, p, dp = hi.fit_par['mean'].get()
                A_f.append(Am * sig * fact / bw)
                dA_f.append(dAm * sig * fact / bw)
                m_f.append(p)
                dm_f.append(dp)
                chi_red.append(hi.F.chi2_red)
            A_f = np.array(A_f)
            dA_f = np.array(dA_f)
            m_f = np.array(m_f)
            dm_f = np.array(dm_f)
            chi_red = np.array(chi_red)

        # proton sum signal
        if draw_p == 'True':
            B.plot_exp(np.array(slice_t) / us,
                       A_sp / dt * us,
                       dA_sp / dt * us,
                       linestyle='-',
                       marker='o',
                       color='b',
                       ecolor='grey',
                       capsize=0.)  #,markeredgecolor='g',

        # triton sum signal
        if draw_t == 'True':
            B.plot_exp(np.array(slice_t) / us,
                       A_st / dt * us,
                       dA_st / dt * us,
                       color='g',
                       ecolor='grey',
                       capsize=0.)

        # pulser sum signal
        if add_pulser == 'True':
            B.plot_exp(np.array(slice_t) / us,
                       A_pul / dt * us,
                       dA_pul / dt * us,
                       color='m',
                       ecolor='grey',
                       capsize=0.)

        # Total signal
        if draw_sum == 'True':
            B.plot_exp(np.array(slice_t) / us,
                       A_t / dt * us,
                       dA_t / dt * us,
                       linestyle='-',
                       ecolor='grey',
                       marker='.',
                       capsize=0.,
                       label='Ch %d' %
                       self.par['channel'])  #color = 'r',ecolor='grey', #

        o_file = self.var['of_name']

        if not os.path.exists(os.path.dirname(o_file)):
            os.makedirs(os.path.dirname(o_file))

        B.pl.xlabel('t [s]')
        B.pl.ylabel('Rate [Hz]')
        B.pl.title('Shot : ' + str(self.par['shot']) + '/ channel: ' +
                   str(self.par['channel']))
        B.pl.xlim((self.par['dtmin'] / us, self.par['dtmax'] / us))
        B.pl.show()
        B.pl.savefig('../Analysis_Results/%d/Rate_Plotting/Rate_%s.png' %
                     (self.par['shot'], self.var['f_name'][-16:-6]))
        # write results

        #        if os.path.isfile(o_file):
        #            inp = raw_input("Do you want to overwrite the results file? (y)es or (n)o: ")
        #            if inp == "yes" or inp == "y":
        #               os.remove(o_file)
        #               print 'Old file removed.'
        #            elif inp == "no" or inp == "n":
        #               return

        np.savez_compressed(o_file,
                            t=np.asarray(slice_t) / us,
                            Ap=np.asarray(A_sp) / dt * us,
                            dAp=np.asarray(dA_sp) / dt * us,
                            At=np.asarray(A_st) / dt * us,
                            dAt=np.asarray(dA_st) / dt * us,
                            A=np.asarray(A_t) / dt * us,
                            dA=np.asarray(dA_t) / dt * us)
#alpha2r, err_alpha2  = round(alpha2[1], 5), alpha2[2]
#beta2r, err_beta2 = round(beta2[1], 5), beta2[2]

lambda1 = lambda1.get()
lambda1r, err_lambda1 = round(lambda1[1], 5), lambda1[2] 

#Plot 1 - Single Exponential Fit
fig = plt.figure()
ax = fig.add_subplot(111)

plt.xlim(0, max(timescale))
plt.ylim(0, max(normcounts)+0.0002)

lt.plot_exp(timescale, normcounts,
	marker = '|', 
	color = 'grey',
	x_label = 'Decay Time  ($\mu s$)', 
	y_label = 'Probability Density ($\%$ of total detected)',
	plot_title = 'Muon Decay - Single Exponential Fit'), 

lt.plot_line(L.xpl, L.ypl,
	linewidth = 1.5,
#	linestyle = '',
	color = 'b',
	label = r'Single Exponential: $\tau$ = {0}$\mu s$'.format(round(1/lambda1r, 5)))

handles, labels = ax.get_legend_handles_labels()
ax.legend(handles, labels)

plt.savefig('graph_{0}_SnglExp.png'.format(filename))

Example #14
0
import LT.box as B
import numpy as np
import pandas as pd
import LT_Fit.parameters as P
import LT_Fit.gen_fit as G

df = pd.read_csv(
    'C:\\Users\\iw2ba\\Desktop\\Senior Physics\\NMR\\T1A7.18B3.54.csv')

DIF = df['Voltage(V)']
tao = df['tao(s)']

y = np.log(0.5 * (1 - (DIF / 4.055432285469148)))

B.plot_exp(tao, y, 0.02)
B.pl.title('Spin Echo VS Tau Linear')
B.pl.ylabel('Spin Echo (v)')
B.pl.xlabel('Tau(s)')
fit1 = B.linefit(tao, y)
B.plot_line(fit1.xpl, fit1.ypl)

slope = fit1.par[1]

T1 = -1 / slope
print(T1)
print(1 / 0.26248527624448215)

# M0 = P.Parameter(4.055432285469148, 'M0')
# T1 = P.Parameter(0.04900121822053086, 'T1')
# c1=  P.Parameter (0,'c1')
x_bpm = B.get_data(f, 'x_bpm')
y_bpm = B.get_data(f, 'y_bpm')

ptrig6_acc = B.get_data(f, 'ptrig6_accepted')
ptrig6_acc_err = np.sqrt(ptrig6_acc) 

norm_cnts = ptrig6_acc / charge
norm_cnts_err = ptrig6_acc_err / charge



#with error
#B.plot_exp(run[(run>=3291) & (run<=3305)], ptrk_eff[(run>=3291) & (run<=3305)], ptrk_eff_err[(run>=3291) & (run<=3305)], color='r', marker='o', label = 'Pm = 580 MeV: Set 1' )
#B.plot_exp(run[(run>=3341) & (run<=3356)], ptrk_eff[(run>=3341) & (run<=3356)], ptrk_eff_err[(run>=3341) & (run<=3356)], color='b', marker='s', label = 'Pm = 580 MeV: Set 2' )

'''
#no error
B.plot_exp(run[(run>=3291) & (run<=3305)], charge[(run>=3291) & (run<=3305)], color='r', marker='o', label = 'Pm = 580 MeV: Set 1' )
B.plot_exp(run[(run>=3341) & (run<=3356)], charge[(run>=3341) & (run<=3356)], color='b', marker='s', label = 'Pm = 580 MeV: Set 2' )

B.plot_exp(run, h3of4_rate, color='r', marker='o', label = 'HMS 3/4 Rate: Pm = 580 MeV/c')
B.plot_exp(run, p3of4_rate, color='r', marker='s', label = 'SHMS 3/4 Rate: Pm = 580 MeV/c') 
B.plot_exp(run, coin_rate, color='r', marker='^', label = 'Coin 3/4 Rate: Pm = 580 MeV/c')    
                                                                                           
B.plot_exp(run, cpuLT, color='r', marker='o', label = 'Computer Live Time: Pm = 580 MeV/c')   
B.plot_exp(run, tLT, color='b', marker='s', label = 'Total Live Time: Pm = 580 MeV/c')  
'''

B.plot_exp(run, x_bpm, color='r', marker='o', label = 'X BPM: Pm = 580 MeV/c')       
B.plot_exp(run, y_bpm, color='b', marker='s', label = 'Y BPM: Pm = 580 MeV/c')                                   
Example #16
0
import LT.box as B
import numpy as np
import pandas as pd

df = pd.read_csv('C:\\Users\\iw2ba\\Desktop\\Senior Physics\\NMR\\T22.csv')

spinEcho = df['Voltage(V)']
tao = df['tao(s)']

y = np.log(spinEcho)

# dy = np.sqrt(((1/spinEcho)*0.02)**2)
dy = df['dy']

B.plot_exp(tao, y, 0.03)

B.pl.title('FID VS Tao: Linear ')
B.pl.xlabel('Tao(s)')
B.pl.ylabel('FID (v)')
fit1 = B.linefit(tao, y)
B.plot_line(fit1.xpl, fit1.ypl)
# fit1 = B.polyfit(tao,spinEcho)
# B.plot_line(fit1.xpl, fit1.ypl)

B.pl.show()

slope = fit1.par[1]

T2 = -1 / slope

m0 = np.exp(1.4000572874265063)
Example #17
0
    Be = np.array(Be)
    Be_err = np.array(Be_err)
    Ga = np.array(Ga)
    Ga_err = np.array(Ga_err)
    De = np.array(De)
    De_err = np.array(De_err)

    return Aa, X0, S, Al, Be, Ga, De, Aa_err, X0_err, S_err, Al_err, Be_err, Ga_err, De_err


#%%
Aa, X0, S, Al, Be, Ga, De, Aa_err, X0_err, S_err, Al_err, Be_err, Ga_err, De_err = fit_histo(
)

#%%
'''pAl = B.polyfit(pi0m, Al, Al_err,  order=4)
pBe = B.polyfit(pi0m, Be, Be_err, order=4)
pGa = B.polyfit(pi0m, Ga, Ga_err, order=4)
pDe = B.polyfit(pi0m, De, De_err,  order=3)


pA = B.polyfit(pi0m, Aa, Aa_err,  order=4)
pS = B.polyfit(pi0m, S, S_err, order=1)
pM = B.polyfit(pi0m, X0, X0_err, order=1)

pAl = B.polyfit(pi0m, Al, Al_err,  order=4)
B.plot_exp(pi0m, Al, Al_err, plot_title = "Fit the fit parameter $\\alpha$", x_label = 'bin centers of y-axis in 2D plot $M(\pi^{0})$')
B.plot_line(pAl.xpl, pAl.ypl)

plt.figure()
pBe = B.polyfit(pi0m, Be, Be_err,  order=4)
Example #18
0
Q5 = 8.69
Q6 = 3.374
Q7 = 7.10
Q8 = 1.80

print('q = 1.764e-19 C')
print('Percent error  =10.11%')
data = {'Qs': [1.764, 12.278, 6.97, 8.26, 8.69, 3.374, 7.10, 1.80]}
df1 = pd.DataFrame(data)

q_int = df1['Qs'] / Q1

df1['Q_int'] = round(q_int)

df1.dropna(inplace=True)
df1.reset_index(inplace=True, drop=True)

B.plot_exp(df1['Q_int'], df1['Qs'], .3)
B.pl.title('Method of Smallest Value')
B.pl.ylabel('Drop Charge (e^-19 Coulombs)')
B.pl.xlabel('# of Electrons lost')

fit2 = B.linefit(
    df1['Q_int'],
    df1['Qs'],
)

B.plot_line(fit2.xpl, fit2.ypl)

B.pl.show()
import LT.box as B
#import numpy as np
#import matplotlib as mpl
#import mathplotlib.pyplot as plt


# get file
data_file = B.get_file('estimatepi.data')

# get data
no_dimension = B.get_data(data_file, 'dimension')
pi_estimate = B.get_data(data_file, 'piestimate')
error = B.get_data(data_file, 'error')

# make a plot
B.plot_exp(no_dimension, pi_estimate, error)

# add the labels
B.pl.xlabel('Number of dimensions')
B.pl.ylabel('Estimator for pi')
B.pl.title('Pi estimated')

# save the plot
B.pl.savefig('pi_plot.png')
Example #20
0
delta = B.Parameter(1., 'delta')

def tanh_bkg(x):
    return alpha() + beta()*np.tanh(gamma()*(x - delta()))

def signal(x):
    return tanh_bkg(x) + gaus_peak(x)


M = hep.bin_center
C = hep.bin_content
dC = hep.bin_error
fit = B.genfit(signal, [ A, x0, s, alpha, beta, gamma, delta], x = M, y = C, y_err = dC )

plt.figure()
B.plot_exp(M, C, dC, x_label = '$M(\pi^{+}\pi^{-}\eta)$', plot_title = 'Gaussian peak on Tanh bkg   ')

B.plot_line(fit.xpl, fit.ypl)
             


fit.save_parameters()
al = fit.parameters_sav[3].value
be = fit.parameters_sav[4].value
ga = fit.parameters_sav[5].value
de = fit.parameters_sav[6].value


def etap_bkg(x):
    return al + be*np.tanh(ga*(x - de))