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
