def part8a(plotA=True, printA=False, saveA=False, fs=20, size=(15, 7.5)): tau = np.arange(12, 25) # ms tau = np.log(tau) amp = np.array([ 2.98, 2.56, 2.14, 1.78, 1.42, 1.09, .62, .59, .82, 1.07, 1.29, 1.59, 1.90 ]) # V T = np.linspace(10, 25, 1000) T = np.log(T) par_m = [10, np.log(19), 0, .8] A_m = quadfit(par_m, T) par_f = df.least_square(quadfit, par_m, tau, amp) # testfit(1,0,par_f) # alpha # testfit(.7,2,par_f) # beta # testfit(.05,3,par_f) # A_0 # testfit(.05,1,par_f) # t_0 A_f = quadfit(par_f, T) alpha = dg.var(par_f[0], 1, 'V/s^2') beta = dg.var(par_f[2], .7, 'V/s') t_1 = dg.var(par_f[1], .05, 'ms') A_0 = dg.var(par_f[3], .05, 'V') tau_1 = err.err8a(t_1) # tau1 = err.quad_err('part8a',alpha,beta,A_0,T,A_f) if plotA == True: fig = plt.figure(figsize=size) plt.title('$\\tau_1$ Two Pulse, Zero Crossing : Glycerin', fontsize=fs + 2) plt.xlabel('ln(delay time/ms)', fontsize=fs) plt.ylabel('amplitude [V]', fontsize=fs) plt.plot(tau, amp, 's', color='b', label='data') # plt.plot(T,A_m,'-', color='m', lw=2, label='manual fit') plt.plot(T, A_f, '-', color='r', lw=2, label='least square fit') note = '$A = \\alpha (t_q-t_1)^2 + \\beta (t_q-t_1) + \gamma$\n$\\alpha = %s \pm %s\ [V/s^2]$\n$\\beta = %s \pm %s\ [V/s]$\n$\\gamma = %s \pm %s\ [V]$\n$ln(t_1/ms) = %s \pm %s$\n$\\tau_1 = %s \pm %s\ [ms]$' % ( alpha.pval, alpha.perr, beta.pval, beta.perr, A_0.pval, A_0.perr, t_1.pval, t_1.perr, tau_1.pval, tau_1.perr) plt.annotate(note, xy=(2.8, 1.5), color='r', fontsize=fs) plt.xlim([min(T), max(T)]) plt.legend(loc='best', numpoints=1) plt.tight_layout() if saveA == True: fig.savefig('../graphs/fig05.png') plt.close(fig) else: plt.show() if printA == True: print("tau_1_g = %s +- %s" % (tau_1.pval, tau_1.perr)) # print("tau1_g = %s +- %s" % (tau1.pval,tau1.perr)) return tau_1
def part7(plotA=True, printA=False, saveA=False, fs=20, size=(15, 7.5)): # tau = np.arange(20,124,20) # ms # amp = np.array([4.20, 2.39, 1.37, 1.00, .65, .35]) # V tau = np.arange(2, 32, 2) amp = np.array([ 9.84, 8.86, 7.92, 7.06, 6.58, 6.06, 5.50, 5.12, 4.74, 4.50, 4.14, 3.96, 3.70, 3.50, 3.30 ]) T = np.linspace(0, 60, 1000) par_m = [12, 20, 1] A_m = expfit(par_m, T) par_f = df.least_square(expfit, par_m, tau, amp) # testfit(.3,0,par_f) # A_0 # testfit(.3,1,par_f) # t_2 # testfit(.1,2,par_f) # C A_f = expfit(par_f, T) A_0 = dg.var(par_f[0], .3, 'V') t_2 = dg.var(par_f[1], .3, 'ms') C = dg.var(par_f[2], .1, 'V') tau_2 = t_2 # tau_2 = err.err7(t_2) # tau2 = err.exp_err(tau_2,A_0,T[1:],A_f[1:],double='yes') if plotA == True: fig = plt.figure(figsize=size) plt.title('$\\tau_2$ Meiboom-Gill : Mineral Oil', fontsize=fs + 2) plt.xlabel('delay time [ms]', fontsize=fs) plt.ylabel('amplitude [V]', fontsize=fs) plt.plot(tau, amp, 's', color='b', label='data') # plt.plot(T,A_m,'-', color='m', lw=2, label='manual fit') plt.plot(T, A_f, '-', color='r', lw=2, label='least square fit') note = '$A = A_0 e^{-t/\\tau_2} + C$\n$A_0 = %s \pm %s\ [V]$\n$\\tau_2 = %s \pm %s\ [ms]$\n$C = %s \pm %s\ [V]$' % ( A_0.pval, A_0.perr, tau_2.pval, tau_2.perr, C.pval, C.perr) plt.annotate(note, xy=(30, 4), color='r', fontsize=fs) plt.xlim([min(T), max(T)]) plt.legend(loc='best', numpoints=1) plt.tight_layout() if saveA == True: fig.savefig('../graphs/fig04.png') plt.close(fig) else: plt.show() if printA == True: print("tau2 = %s +- %s" % (tau_2.pval, tau_2.perr)) # print("tau2 = %s +- %s" % (tau2.pval,tau2.perr)) return tau_2
def lin_fit(X_data, Y_data, X_lin): """ complete linear fit of data Parameters ---------- X_data: domain of data Y_data: range of data X_lin: higher resolution domain to plot smooth linear fit Returns ------- Y_lin: high resolution range of fitted line m: dg.var class object - slope b: dg.var class object - y-intercept """ X_data = np.array(X_data) Y_data = np.array(Y_data) assert len( X_data ) >= 2, "there have to be at least 2 data points to find a fit. df.lin_fit( X_data, Y_data, X_fit )" if len(X_data) > 2: m = m_exp(X_data, Y_data) b = b_exp(X_data, Y_data) Y_lin = m * X_lin + b m_err = sig_m(X_data, Y_data) b_err = sig_b(X_data, Y_data) m_var = dg.var(m, m_err) b_var = dg.var(b, b_err) else: m = (Y_data[1] - Y_data[0]) / (X_data[1] - X_data[0]) def fit_func(b, x): return m * x + b def errfunc(b, x, y): return y - fit_func(b, x) qout, success = optimize.leastsq(errfunc, [1], args=(X_data, Y_data), maxfev=5000) b = qout Y_lin = m * X_lin + b m_var = dg.var(m, 0) b_var = dg.var(b, 0) R_2 = R2(X_data, Y_data) return {'Y_fit': Y_lin, 'm': m_var, 'b': b_var, 'R2': R_2}
def part5(plotA=True, printA=False, saveA=False, fs=20, size=(15, 7.5)): tau = np.arange(1, 17) # ms tau *= 2 amp = np.array([ 7.5, 6.8, 6.0, 5.3, 4.9, 4.2, 4.0, 3.6, 3.4, 3.0, 2.8, 2.6, 2.4, 2.2, 2.0, 1.8 ]) # V T = np.linspace(0, 30, 1000) par_m = [8, 10, .01] A_m = expfit(par_m, T) par_f = df.least_square(expfit, par_m, tau, amp) # testfit(.2,0,par_f) # A_0 # testfit(.3,1,par_f) # tau_2 # testfit(.2,2,par_f) # C A_f = expfit(par_f, T) A_0 = dg.var(par_f[0], .2, 'V') tau_2 = dg.var(par_f[1], .3, 'ms') # tau2 = err.exp_err(A_0,T[1:],A_f[1:],double='yes') C = dg.var(par_f[2], .2, 'V') if plotA == True: fig = plt.figure(figsize=size) plt.title('$\\tau_2$ Two-Pulse Spin Echo : Mineral Oil', fontsize=fs + 2) plt.xlabel('delay time [ms]', fontsize=fs) plt.ylabel('amplitude [V]', fontsize=fs) plt.plot(tau, amp, 's', color='b', label='data') # plt.plot(T,A_m,'-', color='m', lw=2, label='manual fit') plt.plot(T, A_f, '-', color='r', lw=2, label='least square fit') note = '$A = A_0 e^{-t/\\tau_2} + C$\n$A_0 = %s \pm %s\ [V]$\n$\\tau_2 = %s \pm %s\ [ms]$\n$C = %s \pm %s\ [V]$' % ( A_0.pval, A_0.perr, tau_2.pval, tau_2.perr, C.pval, C.perr) plt.annotate(note, xy=(15, 4), color='r', fontsize=fs) plt.xlim([min(T), max(T)]) plt.legend(loc='best', numpoints=1) plt.tight_layout() if saveA == True: fig.savefig('../graphs/fig02.png') plt.close(fig) else: plt.show() if printA == True: print("tau_2 = %s +- %s" % (tau_2.pval, tau_2.perr)) # print("tau2 = %s +- %s" % (tau2.pval,tau2.perr)) return tau_2
def part6(plotA=True, printA=False, saveA=False, fs=20, size=(15, 7.5)): # tau = np.arange(20,120,20) # ms # amp = np.array([4.2, 2.10, 1.09, .62, .34]) # V tau = np.arange(2, 18, 2) # ms amp = np.array([9.52, 8.02, 6.5, 5.3, 3.96, 3.06, 2.36, 1.70]) T = np.linspace(0, 40, 1000) par_m = [12, 10, -1] A_m = expfit(par_m, T) par_f = df.least_square(expfit, par_m, tau, amp) # testfit(.5,0,par_f) # A_0 # testfit(.3,1,par_f) # t_2 # testfit(.2,2,par_f) # C A_f = expfit(par_f, T) A_0 = dg.var(par_f[0], .5, 'V') t_2 = dg.var(par_f[1], .3, 'ms') C = dg.var(par_f[2], .2, 'V') tau_2 = t_2 # tau_2 = err.err6(t_2) # tau2 = err.exp_err(A_0,T[1:],A_f[1:],double='yes') if plotA == True: fig = plt.figure(figsize=size) plt.title('$\\tau_2$ Carr-Purcell : Mineral Oil', fontsize=fs + 2) plt.xlabel('delay time [ms]', fontsize=fs) plt.ylabel('amplitude [V]', fontsize=fs) plt.plot(tau, amp, 's', color='b', label='data') # plt.plot(T,A_m,'-', color='m', lw=2, label='manual fit') plt.plot(T, A_f, '-', color='r', lw=2, label='least square fit') note = '$A = A_0 e^{-t/\\tau_2} + C$\n$A_0 = %s \pm %s\ [V]$\n$\\tau_2 = %s \pm %s\ [ms]$\n$C = %s \pm %s\ [V]$' % ( A_0.pval, A_0.err, tau_2.pval, tau_2.perr, C.pval, C.perr) plt.annotate(note, xy=(20, 3), color='r', fontsize=fs) plt.xlim([min(T), max(T)]) plt.legend(loc='best', numpoints=1) plt.tight_layout() if saveA == True: fig.savefig('../graphs/fig03.png') plt.close(fig) else: plt.show() if printA == True: print("tau2 = %s +- %s" % (tau_2.pval, tau_2.perr)) # print("tau2 = %s +- %s" % (tau2.pval,tau2.perr)) return tau_2
def part8b(plotA=True, printA=False, saveA=False, fs=20, size=(15, 7.5)): tau = np.arange(20, 100, 20) # ms amp = np.array([4, 1.71, .76, .43]) # V T = np.linspace(0, 120, 1000) par_m = [7, 30, 0] A_m = expfit(par_m, T) par_f = df.least_square(expfit, par_m, tau, amp) # testfit(.3,0,par_f) # A_0 # testfit(.9,1,par_f) # t_2 # testfit(.1,2,par_f) # C A_f = expfit(par_f, T) A_0 = dg.var(par_f[0], .3, 'V') t_2 = dg.var(par_f[1], .9, 'ms') C = dg.var(par_f[2], .1, 'V') tau_2 = t_2 # tau_2 = err.err8b(t_2) # tau2 = err.exp_err(A_0,T[1:],A_f[1:],double='yes') if plotA == True: fig = plt.figure(figsize=size) plt.title('$\\tau_2$ Meiboom-Gill : Glycerin', fontsize=fs + 2) plt.xlabel('delay time [ms]', fontsize=fs) plt.ylabel('amplitude [V]', fontsize=fs) plt.plot(tau, amp, 's', color='b', label='data') # plt.plot(T,A_m,'-', color='m', lw=2, label='manual fit') plt.plot(T, A_f, '-', color='r', lw=2, label='least square fit') note = '$A = A_0 e^{-t/\\tau_2} + C$\n$A_0 = %s \pm %s\ [V]$\n$\\tau_2 = %s \pm %s\ [ms]$\n$C = %s \pm %s\ [V]$' % ( A_0.pval, A_0.perr, tau_2.pval, tau_2.perr, C.pval, C.perr) plt.annotate(note, xy=(60, 1.5), color='r', fontsize=fs) plt.xlim([min(T), max(T)]) plt.legend(loc='best', numpoints=1) plt.tight_layout() if saveA == True: fig.savefig('../graphs/fig06.png') plt.close(fig) else: plt.show() if printA == True: print("tau_2_g = %s +- %s" % (tau_2.pval, tau_2.perr)) # print("tau2_g = %s +- %s" % (tau2.pval,tau2.perr)) return tau_2
def quad_err(alpha,beta,gamma,T_data,A_data): T = np.array(T_data) A = np.array(A_data) short = np.sqrt(beta.val**2 - (4*alpha.val*(gamma.val-np.average(A)))) dt_q = dt/T one = dt_q two_1 = alpha.err/(2*alpha.val) two_2 = (1/alpha.val) * (beta.val + short) two_3 = (2*(gamma.val-A)) / short two = two_1 * (two_2 + two_3) three_1 = beta.err/(2*alpha.val) three_2 = 1 + (beta.val*beta.err)/short three = three_1 * three_2 four = (gamma.val*gamma.err)/short five = (A*dA)/short dT1 = np.sqrt(one**2 + two**2 + three**2 + four**2 + five**2) tau1_err = np.exp(np.average(dT1)) * dt T1 = T + (1/(2*alpha.val)) * (beta.val - short) tau1_val = np.exp(np.average(T1)) tau1 = dg.var(tau1_val,tau1_err,'ms') return tau1
def laser(theta_comp, C, theta_comp_err=.05): # theta_laser - mRad if type(theta_comp) != float: theta_comp = np.array(theta_comp) theta_comp = np.average(theta_comp) val = theta_comp * C.val err = np.sqrt((theta_comp_err / theta_comp)**2 + (C.err / C.val)**2) return dg.var('laser', val, err, 'mRad')
def thetaD2(N, printA=False): # equation 14 displ = [] for t in theta[:-2]: i = dg.nearest(theta, t) d1 = (-1)**(i + 1) / ((1 + x.val)) d2 = (x.val * theta[i]) + (1 - x.val) * theta[i + 1] - theta[i + 2] displ.append(d1 * d2) displ = np.array(displ) av = np.average(displ) #err = np.std(displ) err1_1 = theta_laser_err(np.average(theta), .05, C) err1_2 = np.sqrt((N - 1) * (1 - x.val)**2 + 2 * x.val) err1 = err1_1 * err1_2 / ((N - 1) * (1 + x.val)) err2_1 = x.err / ((N - 1) * (1 + x.val)**2) err2_2 = 2 * thetasum(1, N - 1) + theta[N - 1] - theta[1 - 1] err2 = err2_1 * err2_2 err = np.sqrt(err1**2 + err2**2) if printA == True: print("") print("thetad 2 = %s" % displ) print("av = %s" % av) return dg.var('thetaD 2', av, err, 'mRad')
def thetaD(N, printA=False): # equaiton 15 val1 = (1 - x.val) val2 = thetasum(1, N) val3 = -theta[1 - 1] + (x.val * theta[N - 1]) val4 = (N - 1) * (1 + x.val) val = (val1 * val2 + val3) / val4 err1_1 = theta_laser_err(np.average(theta), .05, C) err1_2 = np.sqrt((N - 1) * (1 - x.val)**2 + 2 * x.val) err1 = err1_1 * err1_2 / ((N - 1) * (1 + x.val)) err2_1 = x.err / ((N - 1) * (1 + x.val)**2) err2_2 = 2 * thetasum(1, N - 1) + theta[N - 1] - theta[1 - 1] err2 = err2_1 * err2_2 err = np.sqrt(err1**2 + err2**2) if printA == True: print("") print("thetad val1 = %s" % val1) print("thetad val2 = %s" % val2) print("thetad val3 = %s" % val3) print("thetad val4 = %s" % val4) print("thetad val = %s" % val) return dg.var('theta_d', val, err, 'mRad')
def G(theta, k, R, M_m, m_m, d, static=True): # gravitational constant - N m^2 kg^-2 if static == True: th_err = theta.err / 1000 # mRad -> rad th_val = theta.av / 1000 # mRad -> rad else: th_err = theta.err / 1000 th_val = theta.val / 1000 m_h = .34 / 1000 # mass missing from boom where small spheres are - kg f_d = 3.5 / 100 f_b = 0.19 m_factor = (m_m.val - m_h) * (1 - f_d) + (m_b.val * f_b) #val = (k.val * th_val * R.val**2)/(2 * M_m.val * m_m.val * d.val) val = (k.val * th_val * R.val**2) / (2 * M_m.val * m_factor * d.val ) # corrected var1 = (k.err / k.val)**2 var2 = (th_err / th_val)**2 var3 = (2 * R.err / R.val)**2 var4 = (m_m.val * m_m.err)**2 var5 = (M_m.val * M_m.err)**2 var6 = (d.val * d.err)**2 err = val * np.sqrt(var1 + var2 + var3 + var4 + var5 + var6) return dg.var('G', val, err, 'N m^2 kg^-2')
def K2(T, gamma, I): eta = (2 * np.pi / T.av)**2 + gamma.val**2 d_eta = np.sqrt(2 / T.err**2 + 2 * gamma.err**2) val = I.val * eta err = np.sqrt((d_eta / eta)**2 + (I.err / I.val)**2) return dg.var('k2', val, err, 'N m')
def err5(t): """calculates error for part6 args ---- name: name that goes into returned djak.gen.var object t: djak.gen.var class object """ return dg.var((1/2)*t.val,(1/2)*t.err,'ms')
def K(omega, gamma, I): # torsion constant - N m val = I.val * (omega.val**2 + gamma.val**2) var1 = ((omega.val**2 + gamma.val**2) * I.err)**2 var2 = (2 * I.val * omega.val * omega.err)**2 var3 = (2 * I.val * gamma.val * gamma.err)**2 err = np.sqrt(var1 + var2 + var3) return dg.var('k', val, err, 'N m')
def err4(t): """calculates error for part4 args ---- name: name that goes into returned djak.gen.var object t: djak.gen.var class object """ return dg.var(np.exp(t.val),np.exp(t.val)*t.err,'ms')
def K(omega, gamma, I): # torsion constant - N m eta = omega.val**2 + gamma.val**2 d_eta = np.sqrt(2 * omega.err**2 + 2 * gamma.err**2) val = eta * I.val err = np.sqrt((d_eta / eta)**2 + (I.err / I.val)**2) return dg.var('k', val, err, 'N m')
def X4(gamma, T, printA=False): val = np.exp(-gamma.val * T.val / 2) val = np.average(val) err = (val / 2) * np.sqrt((T.val * gamma.err)**2 + (gamma.val * T.err)**2) err = np.average(err) if printA == True: print("x4 = %s +- %s" % (val, err)) return dg.var('x', val, err, None)
def ThetaD3(): Q = omega.val / (2 * gamma.val) def the(t): return theta_e.val + (4 * Q / np.pi) * theta_s.val * ( 1 - np.exp(-gamma.val * t)) * np.cos(omega.val * t) thetas = the(extrema[:, 0]) return dg.var('thetaD 3', thetas, 'std', 'mRad')
def X2(N, printA=False): # equation 8a val1 = theta[2 - 1] - theta[N - 1 - 1] val2 = thetasum(2, N - 2) val = 1 - val1 / val2 err1 = 1 / abs(theta[1 - 1] - theta[N - 1]) err2 = np.sqrt((N - 1) * (1 - val)**2 + (2 * val)) err = laser_err * (1 - val) * err1 * err2 if printA == True: print("") print("x2 = %s +- %s" % (val, err)) return dg.var('x2', val, abs(err), None)
def X1(N, printA=False): # equation 8 val1 = theta[1 - 1] - theta[N - 1] val2 = thetasum(1, N - 1) val = 1 - val1 / val2 err1 = laser_err * (1 - val) err2 = np.sqrt((N - 1) * (1 - val)**2 + (2 * val)) err3 = abs(theta[1 - 1] - theta[N - 1]) err = err1 * err2 / err3 if printA == True: print("x1 = %s +/- %s" % (val, err)) return dg.var('x1', val, err, None)
def X3(N, printA=False): #equation 7 Xs = [] for t in theta[:-2]: i = dg.nearest(theta, t) x = -(theta[i + 2] - theta[i + 1]) / (theta[i + 1] - theta[i]) Xs.append(x) Xs = np.array(Xs) x = np.average(Xs) if printA == True: print("") print("x3 = %s" % Xs) print("x3 = %s +- %s" % (x, np.std(Xs))) return dg.var('x3', x, np.std(Xs), None)
def I(m_m, d, m_r, m_b, l_b, w_b): # moment of inertia - kg m^2 val1 = (2 * m_m.val) * (d.val**2 + (2 / 5) * m_r.val**2) val2 = (m_b.val / 12) * (l_b.val**2 + w_b.val**2) val = val1 + val2 var1 = (2 * d.val**2 * m_b.err)**2 + (4 * m_m.val * d.val * d.err)**2 + ( (4 / 5) * m_r.val**2 * m_m.err)**2 + ( (8 / 5) * m_m.val * m_r.val * m_r.err)**2 var2 = ((1 / 12) * l_b.val**2 * m_b.err)**2 + ( (1 / 6) * m_b.val * l_b.val * l_b.err)**2 + ( (1 / 12) * w_b.val**2 * m_b.err)**2 + ( (1 / 6) * w_b.val * m_b.val * w_b.err)**2 err = np.sqrt(var1 + var2) return dg.var('I', val, err, 'kg m^2')
def I(m_m, d, m_r, m_b, l_b, w_b): # moment of inertia - kg m^2 eta = d.val**2 + (2 / 5) * m_r.val**2 d_eta = np.sqrt(2 * d.err**2 + 2 * m_r.err**2) mu = l_b.val**2 + w_b.val**2 d_mu = np.sqrt(2 * l_b.err**2 + 2 * w_b.err**2) Is = (2 * m_m.val) * eta d_Is = np.sqrt((m_m.err / m_m.val)**2 + (d_eta / eta)**2) Ib = (m_b.val / 12) * mu d_Ib = np.sqrt((m_b.err / m_b.val)**2 + (d_mu / mu)**2) val = Is + Ib err = np.sqrt(d_Is**2 + d_Ib**2) return dg.var('I', val, err, 'kg m^2')
def fig07(saveA=True): data = pd.read_table(three_d['txt']) B = data['MagField'].values * C['T'] # T I = data['MagCurr'].values # A X = B # T Y = I * C['L'] / C['A'] # T X_fit = np.linspace(min(X), max(X), 1000) FIT = df.lin_fit(X, Y, X_fit) Y_fit = FIT['Y_fit'] m = FIT['m'] b = FIT['b'] R2 = FIT['R2'] mu_rval = m.val mu_rerr = m.err mu_r = dg.var(mu_rval, mu_rerr) fig = plt.figure(figsize=pp['figsize']) plt.title('Finding $\mu_r$', fontsize=pp['fs'] + 2) plt.xlabel('B [ T ]', fontsize=pp['fs']) plt.ylabel('I L / A [ T ]', fontsize=pp['fs']) plt.xlim([min(X), max(X)]) plt.plot(X, Y, color='c', lw=pp['lw'], label='p-Ge') plt.plot(X_fit, Y_fit, pp['fit_style'], lw=pp['lw'], label='fit') plt.legend(loc='best', fontsize=pp['fs']) note = 'y = m x + b\n\ m = $\mu_r$ = %s $\pm$ %s [ H/m ]\n\ b = %s $\pm$ %s [ T ]\n\ R$^2$ = %s'\ % (m.pval,m.perr,b.pval,b.perr,"{0:.4f}".format(R2) ) plt.annotate(note, xy=(.097, 24500), color='r', fontsize=pp['fs']) if saveA: fig.savefig('png/fig07.png') plt.close() else: plt.show() dic = {'mu_val': mu_r.val, 'mu_err': mu_r.err, 'mu_r': mu_r} return pd.Series(dic)
def DrivenG(plot=False, printA=False): plt.close('all') D = np.load(nppath + 'driven.npy') X, Y = D[:, 0] / 1000, (D[:, 1] - eq2) * C.val # data data = dp.data(X, Y, '-', 'b', 'data') # data i_1 = dg.maxima(X, Y, 2.87, 25) x1, y1 = X[i_1], Y[i_1] d1 = dp.data([x1], [y1], '*', 'r', '$X[t_0],\ Y[t_0]$') X2 = X[i_1:] Y2 = Y[i_1:] Y2_env, Y2_man, Y2_fit, par_f = dampedWave(X2, Y2, par_m) d2_man = dp.data(X2, Y2_man, '--', 'm', 'manual fit') d2_env = dp.data(X2, Y2_env, '--', 'c', 'upper envelope') d2_fit = dp.data(X2, Y2_fit, '-', 'r', 'least-square fit') n1 = '$\\theta_e + A e^{-\\gamma t} \cos{\\omega t}$' n2 = '$\\theta_e$ = %s $\pm$ %s mRad' % (round(par_f[0], 1), .1) n3 = 'A = %s $\pm$ %s mRad' % (round(par_f[1], 1), .2) n4 = '$\\gamma$ = %s $\pm$ %s (10$^3$ s)$^{-1}$' % (round(par_f[2], 1), .1) n5 = '$\\omega$ = %s $\pm$ %s (10$^3$ s)$^{-1}$' % (round(par_f[3], 1), .2) note = dp.note(n1 + '\n' + n2 + '\n' + n3 + '\n' + n4 + '\n' + n5, 4, -10, 'r') theta_d = theta_driven(X2, Y2, y1, printA=True) G_d = dg.var('G_d', G(theta_d.val), G_d_err(k, theta_d, R, M_m, m_m, d), 'N m^2 kg^-2') dg.printvar(G_d) print(G_d.val, G_d.err) if plot == True: ax = dp.ax([data, d1, d2_env, d2_man, d2_fit], 111, 'time [$10^3$ sec]', '$\\theta_{laser}$ [mRad]', 'Driven Measurement') ax.notes = [note] dp.plot([ax]) #, name=gp+'0_4_DrivenG') if printA == True: print("Driven G Results:") return theta_d
def exp_err(A_0,T_data,A_data,double='no'): T = np.array(T_data) A = np.array(A_data) one = dt/np.log(A_0.val/A) two = A_0.err/(A*np.log(A_0.val/A)**2) three = (A_0.val*dA)/(A**2 * np.log(A_0.val/A)**2) dt2 = np.average( np.sqrt(one**2 + two**2 + three**2) ) t2 = np.average( T/np.log(A_0.val/A) ) tau2_val = t2 tau2_err = dt2 if double != 'no': tau2_val *= 1/2 tau2_err *= 1/2 tau2 = dg.var(tau2_val,tau2_err,'ms') return tau2
def G(theta, k, R, M_m, m_m, d, static=True): # gravitational constant - N m^2 kg^-2 th_err = theta.err / 1000 # mRad -> rad z = 2 if static == True: th_val = np.average(theta.val) / 1000 print(type(th_val)) else: th_val = theta.val val = (k.val * th_val * R.val**2) / (2 * M_m.val * m_m.val * d.val) err = np.sqrt((k.err / k.val)**2 + (th_err / th_val)**2 + 2 * (R.err / R.val)**2 + (M_m.val / M_m.err)**z + (m_m.val / m_m.err)**z + (d.val / d.err)**z) return dg.var('G', val, err, 'N m^2 kg^-2')
def torun(): #w_b = dg.var('w_b',.1/100,.05/100,'m') #I = dg.var('I', I_s+I_b, I_err(m_m,d,m_r,m_b,l_b,w_b), 'kg m^2') k = dg.var('k', K_s(I.val, T.av), k_err(T, I), 'N m') #beta = dg.var('beta', 2*I.val*gamma.val, beta_err(gamma,T), 'J s') #theta_s = StaticG() #G_s = dg.var('G_s', G(theta_s.av), G_s_err(k,theta_s,R,M_m,m_m,d), 'N m^2 kg^-2') #theta_d = DrivenG() #G_d = dg.var('G_d', G(theta_d.val), G_d_err(k,theta_d,R,M_m,m_m,d), 'N m^2 kg^-2') #dg.printvar(w_b) #dg.printvar(I) dg.printvar(k) #dg.printvar(beta) #dg.printvar(theta_s) #dg.printvar(G_s) #dg.printvar(theta_d) #dg.printvar(G_d) print(G(theta_s.av), G(theta_d.val)) print(G2(theta_s.av), G2(theta_d.val)) return
def part3(printA=True,saveA=True,figsize=(15,15), fs=20, lw=2): print("") print("Part III") # compare G2 = 1*10*100 R = 10e3 # Ohm delta_f = 110961 # Hz vout = .94 # V vrms_conv = out2rms(G2,vout) # V vrms_calc = v_rms(delta_f,k_default,R_default) vrms, perr = err(vrms_conv,vrms_calc) if printA == True: print("compare") print("v_out = ", vout) print("v_rms_conv = ", vrms_conv) print("v_rms_calc = ", vrms_calc) print("v_rms = %s +/- %s V (%s percent)" % (vrms.pval,vrms.perr,perr) ) print("") # amplifier noise R = np.array([ 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6 ]) G2 = np.array([ 10*10*20, 10*10*20, 10*10*20, 10*10*20, 10*10*10, 1*10*40, 1*10*30 ]) VOUT = np.array([ .9727, .9722, .9715, .9718, .9743, .9773, .9747, .9755, 1.0005, 1.0025, .9998, 1.0010, 1.2441, 1.2492, 1.2468, 1.2435, .9323, .9319, .9355, .9337, .8912, .8882, .8863, .8877, .9585, .9550, .9595, .9650 ]).reshape([7,4]) VOUT = np.array([ np.average(VOUT[i]) for i in range(7) ]) Y_data = ( VOUT * (1e6)**2 ) / ( gain(G2)**2) # micro V^2 X_fit = np.linspace(0, 2e4, 1000) # Ohm cutoff = 2 # num Y_fit, m, b = df.lin_fit( R[:-cutoff] , Y_data[:-cutoff] , X_fit ) # micro V^2 R2 = df.R2(R[:-cutoff],Y_data[:-cutoff]) # num amp = np.sqrt(b.val) amp_err = b.err/(2*np.sqrt(b.val)) ampN = dg.var( amp,amp_err ) # micro V fig = plt.figure(figsize=figsize) plt.title('Part III: Amplifier Noise', fontsize=fs+2) plt.xlabel('R [$\\Omega$]', fontsize=fs) plt.ylabel('<Vj$^2$> [$\\mu$ V$^2$]', fontsize=fs) plt.xlim(min(X_fit),max(X_fit)) plt.plot(R[:-cutoff],Y_data[:-cutoff], 'bo', markersize=15, label='data') plt.plot(X_fit,Y_fit, color='r', lw=lw, label='fit') note = '$Vj^2 = mR + b$\n$m = %s \pm %s\ \\mu\ V^2/\\Omega$\n$b = %s \pm %s\ \\mu\ V^2$\n$R^2 = %s$' % (m.pval,m.perr,b.pval,b.perr,round(R2,6) ) plt.annotate(note, xy=(1e3,35), color='r', fontsize=fs) note2 = 'Pre-Amp Noise = $\sqrt{b} \pm \\Delta b/(2 \sqrt{b})$\n $= %s \pm %s\ \\mu V$' % (ampN.pval,ampN.perr) plt.annotate(note2, xy=(1e3,30), color='m', fontsize=fs+2) plt.legend(loc='best', fontsize=fs) if saveA == True: fig.savefig('../graphs/fig02.png') plt.close(fig) else: plt.show(fig) if printA == True: print('amplifier noise') print('R = %s Ohm' % R) print('Vj^2 = %s micro V^2' % Y_data ) print("The best fit was found by not considering the last %s data points" % cutoff ) print("n = %s +/- %s micro V^2/Ohm" % (m.pval,m.perr) ) print("b = %s +/- %s micro V^2/Ohm") print('amplifer noise = %s +/- %s micro V^2' % (ampN.pval,ampN.perr) ) print('') # experimental k DELTA_f = np.array([ 355, 1077, 3554, 10774, 35543, 107740 ]) # Hz G2 = np.array([ 10*10*60, 10*10*40, 10*10*20, 10*10*10, 1*10*60, 1*10*40 ]) VOUT = np.array([ .8, 1.0, .9, .7, .8, .9 ]) # V R = 100e3 # Ohm Y_data = ( VOUT * (1e9)**2 ) / ( gain(G2)**2 * 4 * R * T_room ) # nV^2/Ohm/K X_fit = np.linspace(0,120000,1000) # Hz Y_fit, m, b = df.lin_fit( DELTA_f , Y_data , X_fit ) R2 = df.R2(DELTA_f,Y_data) kval = m.val/(1e9)**2 # J/K kval_err = m.err/(1e9)**2 k = dg.var( kval,kval_err ) fig = plt.figure(figsize=figsize) plt.title('Part III: Bolzmann Constant', fontsize=fs+2) plt.xlabel('$\\Delta$ f [Hz]', fontsize=fs) plt.ylabel('<Vj$^2$>/R/T [nV$^2$/$\\Omega$/K]', fontsize=fs) plt.xlim(min(X_fit),max(X_fit)) plt.plot(DELTA_f,Y_data, 'bo', markersize=15, label='data') plt.plot(X_fit,Y_fit, color='r', lw=lw, label='fit') note = '$V^2 = m f + b$\n$m = %s \pm %s\ nV^2/ \\Omega/ K / Hz$\n$b = %s \pm %s\ nV^2/ \\Omega/ K$\n$R^2 = %s$' % (m.pval,m.perr,b.pval,b.perr,round(R2,3) ) plt.annotate(note, xy=(1.5e3,1.2), color='r', fontsize=fs) note2 = '$k = (m \pm \\Delta m)/(1_{+9})^2$\n $= %s \pm %s\ J/K$' % (k.pval,k.perr) plt.annotate(note2, xy=(1.5e3,1), color='m', fontsize=fs+2) plt.legend(loc='best', fontsize=fs) if saveA == True: fig.savefig('../graphs/fig03.png') plt.close(fig) else: plt.show(fig) if printA == True: print("Bolzmann constant") print("m = %s +/- %s 1e18 J/K" % (m.pval,m.perr) ) print("k = %s +/- %s J/K" % (k.pval,k.perr) ) return
def err(v_conv,v_calc): abs_err = abs(v_calc - v_conv) per_err = 100 * (1 - v_calc/v_conv) v_av = (v_conv + v_calc)/2 v = dg.var(v_av,abs_err) return v, per_err