Chirag Sharma

Tier 2 E&M Lab: Faraday’s Law

Objective
We aim to test Faraday’s law of electromagnetic induction using multiple setups that will utilize
the magnetometer and high gain sensors of an IOLab device. We will then extend this to observe
and record the effect of eddy current damping on an oscillating metal can in a magnetic field.
Finally, we will consider the practical application of Faraday’s law in the construction of a DC
motor by building one ourselves.

Equipment and Setup

Equipment:
• IOLab device and software with:
• 3D magnetometer (16 bit signed, 1000 uT range, 0.63-80 Hz sample rate)
• DC coupled high gain differential amplifier (gain = 1,400, f3dB = 100Hz), up to 4.8 kHz
sampling
• Hookean spring (unknown spring constant)
• Neodymium magnets (unknown strengths)
• Spool of 26 AWG copper wire
• Ruler — precision error = ± 0.5 mm = ± 0.0005 m
• Aluminum can

Setup:
• Part 1: Details given on p3 of lab manual
• Part 2: Details given on p5 of lab manual
• Part 3:
 Fig 1. Part 3 Experimental Setup
Our setup involves the IOLab device placed
flat on the table with the coil along the y-
axis as in Part 2. We hold the magnet 10.00
± 0.05 cm away from the coil and then
manually oscillate it in the perpendicular
direction. The displacement amplitude
along the perpendicular direction (the x-
axis) is also 10.00 ± 0.05 cm
• Part 4 (Eddy current damping):

Our setup involves the IOLab with the
aluminum can taped to its bottom hanging
from a spring that is attached to the pole
(similar to Part 2). The magnet is placed on
the pole such that its face aligns with the
center of the aluminum can. We create

!1
 Chirag Sharma

small damped oscillations by Fig 2. Part 4 Experimental Setup

slightly displacing the IOLab
device and can vertically (we try
to keep the initial vertical
displacement consistent at 3.6 cm)
and then take multiple
accelerometer measurements for
varying eddy current strength
(which we will vary by varying
the distance between the rod and
the IOLab/can).

Theory
• We are testing Faraday’s law of electromagnetic induction, given by:

dΦB dB
ε! induced = − N = − NA for a coil of wire with N loops
dt dt
• The theory concerning eddy currents and eddy current damping is given on p2 of the lab
manual
• For the non-linear damped harmonic oscillation fit, we will use the model given in p3 of the
Tier 1 Harmonic Oscillations Lab manual:

! ydamped = Ae −tβ[(β 2 − ω 2 )cos(ωt + ϕ) + 2βωsin(ωt + ϕ)]

a
This model takes into account damping due to velocity-dependent friction and will hopefully
be a good fit for the eddy current damping that we are looking for
• Quantities that we will measure include distance (ruler) and continuous measurement of
magnetic field strength (magnetometer), induced EMF (high gain amplifier), and acceleration
(accelerometer) over time
• The only derived quantity is the rate of change of magnetic field strength, using the
dB B(t1 + Δt) − B(t1)
approximation ! (t1) ≈ , given on p4 of the lab manual
dt Δt

Procedure and Data Collection Notes

• The general procedures are given on p3-6 of the lab manual but the specifics of our experiment
are given below
• Part 1:
• We wound our copper wire 20 times around the pole and then slid the coil off and taped it
over the z-directed magnetometer of the IOLab Device.
• Coil diameter = 1.320 ± 0.005 cm (using calipers)

!2
 Chirag Sharma

• We moved a small neodymium magnets along the z-axis above the coil and recorded the Bz
data with high gain voltage
• Our IOLab was giving us a lot of noise in the high gain data so we had to switch it out for
another device that we recalibrated; this gave us the data we were looking for
• Part 2:
• We used the same coil of wire as in Part 1 but placed it over the magnetometer on the IOLab
Device that was along the y-direction
• We attached it to the spring and held it 47.50 ± 0.05 cm above the magnet so that we could
produce oscillations with a very small amplitude of a few cm (to minimize unwanted
oscillation along other directions)
• Part 3:
• We set up the IOLab device and magnet as detailed earlier
• We slowly displaced the magnet along a straight line perpendicular to the face of the coil in
an oscillating manner with an amplitude of 10.00 ± 0.05 cm
• We tried to make the turns as smooth as possible to prevent sharp changes in magnetic field
strength
• Part 4 (Eddy current damping):
• We set up the experiment as detailed earlier
• We started with a control trial in which we removed the magnet from the pole and made the
IOLab device and can undergo regular harmonic motion without eddy current damping
• We then attached the magnet to the pole as illustrated in Fig. 2 and conducted 3 trials in
which the IOLab/can setup was displaced different distances !d from the magnet
• d
! : Trial 1: 1.80 ± 0.05 cm, Trial 2: 2.40 ± 0.05 cm, Trial 3: 5.10 ± 0.05 cm
• For all trials, including the control, we used a ruler to ensure that the initial amplitude of
oscillation was always around 3.6 cm

Data Plots



Fig 3. Part 1 Raw Data Plot

!3
 Chirag Sharma

Fig 4. Part 2 Raw Data Plot

Fig 5. Part 3 Raw Data Plot

!4
 Chirag Sharma

Fig 6. Part 4 Raw Data Plot

a) Control b) Trial 1 

c) Trial 2 d) Trial 3

!5
 Chirag Sharma

Data Analysis
• The data analysis plots, with regression and curve-fitting done on them, are attached at the end
and will be referenced below
• Part 1:
ϵ
Analytical estimated slope ! dB is given by −NA
! (from the theory section)
•
dt
• !−NA = − 20 × π (0.660 ± 0.005 cm)2 = − 27.4 ± 0.4 cm 2
• Since the trend looks fairly linear, we do a linear fit and get the slope as:

mV s
! (−6.78 ± 0.06) ⋅ 10−6 = − 67.8 ± 0.6 cm 2
μT
• Discrepancy test:
• ϵ! = 40.4, !δϵ = 0.72
• ϵ! ≫ 2δϵ so the values fail the discrepancy test
• This is likely due to the fact that the coil probably wasn’t moved exactly normal to the
magnet on the table; moreover, the turns of the coil likely do not perform as an ideal inductor
due to impedances and imperfections
• Part 2:
• The data points don’t look very linear — there seems to be a looping pattern in the data
• Nevertheless, we perform a linear fit and get the slope as:

mV s
! (−8.07 ± 0.12) ⋅ 10−6 = − 80.7 ± 1.2 cm 2
μT
• Part 3:
• The data points don’t look very linear — it seems to be cubic or some higher order
polynomial
• Nevertheless, we perform a linear fit and get the slope as:

mV s
! (−4.42 ± 0.05) ⋅ 10−6 = − 44.2 ± 0.5 cm 2
μT
• This result agrees with the theoretical expectation better than those from the first 2 parts
• Discrepancy test:
• ϵ! = 16.8, δϵ ! = 0.6
• ϵ! ≫ 2δϵ so the values fail the discrepancy test
• Part 4:
• We do a non-linear fit for all the trials (including control) using the model given in the theory
section
• Damping factors obtained:
• Control — !0.0034 ± 0.0002
• Trial 1 — 0.0112 ! ± 0.0003
• Trial 2 — 0.0045 ! ± 0.0003
• Trial 3 — 0.0038 ! ± 0.0002
• From Fig. 15, we can clearly see that the damping factor decreases (maybe exponentially or
quadratically — too few data points to determine) with increasing distance

!6
 Chirag Sharma

Bonus Section

Fig 7. Homemade DC Motor

39 rotations in 2.24 s
RPM ~ 1045
The motor seemed to switch direction
every 2 rotations

Discussion
• Since the first 3 parts fail the discrepancy test, it appears that our model does not work very
well in the regime and case that we are considering
• It is possible that this error is due to an error with the magnetometer/high gain amplifier of the
IOLab device but is likely mostly due to the imperfect self-inductance of the copper coil
• This suggests that for improper inductors, higher-order terms cannot be ignored, which would
explain the polynomial pattern we observe in some of our plots
• This experiment could therefore be further refined either by using a better inductor (such as
commercially available ones) or by redefining our model to take into account these higher
order terms
• Part 4: When the distance is small, the magnetic field strength at the can is the highest so we
get high damping and for large distances, the magnetic field strength decreases so the damping
factor goes down (probably asymptotically) to the control value

Summary and Conclusions

Therefore, we have successfully tested Faraday’s Law in various scenarios and have built a
functional DC motor using this idea. Unfortunately, it appears that our coil was not a satisfactory
inductor since we did not get a very good linear fit for our data and our experimentally obtained
results did not agree with what we expected. Nevertheless, we could see that the negative
proportionality dictated by Faraday’s Law is followed by our data to good approximation. We
also measured and observed the phenomenon of eddy current damping by generating eddy
currents in an oscillating aluminum can and successfully concluded that the damping effect
decreases with decreasing magnetic field strength for the same initial acceleration (we used
gravitational acceleration).

!7
In [1]: import matplotlib.pyplot as plt
from scipy.interpolate import interp1d
import numpy as np
import scipy.optimize as fitter

Part 1
In [2]: t_Bz = [0.0122359,0.0244719,0.0367078,0.0489438,0.0611797,0.0734157,0.085651

In [3]: Bz = [-2734.98,-2664.33,-2619.7,-2596.38,-2589.95,-2566.06,-2531.58,-2500.36

In [4]: dBzdt = []
for i in range(len(Bz)-1):
dBzdt += [(Bz[i+1]-Bz[i])/(t_Bz[i+1]-t_Bz[i])]

In [5]: t_EMF = [0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1,0.11,0.12,0.13,

In [6]: EMF = [-0.0795395,-0.0722135,-0.0643642,-0.0648875,-0.0779696,-0.0894819,

In [7]: interp_dBzdt = interp1d(t_Bz[:-1], dBzdt)

interp_EMF = interp1d(t_EMF, EMF)
interp_Bz = interp1d(t_Bz, Bz)

In [8]: def linear(x, m, b):

return np.add(np.multiply(m, x), b)

t = np.linspace(4.2, 19.7, 1000)

par, cov = fitter.curve_fit(linear, interp_dBzdt(t), interp_EMF(t))
In [9]: plt.figure(figsize=[8, 6])
plt.plot(interp_dBzdt(t), interp_EMF(t), 'x', label='Interpolated data')
plt.plot(interp_dBzdt(t), linear(interp_dBzdt(t), par[0], par[1]), label=
plt.xlabel('$dBz/dt \ (\mu T/s)$ \n Fig 8. Part 1 Linear Regression for EMF
plt.ylabel('$EMF \ (mV)$', fontsize=12)
plt.legend()
plt.show()

print('Slope: {} +/- {}'.format(par[0], np.sqrt(cov[0][0])))

print('Intercept: {} +/- {}'.format(par[1], np.sqrt(cov[1][1])))

Slope: -6.7856137295266555e-06 +/- 6.445625104182566e-08

Intercept: -0.010556193758201214 +/- 9.365638378142492e-05

Part 2
In [10]: t_By = [0.0122532,0.0245063,0.0367595,0.0490127,0.0612658,0.073519,0.0857722

In [11]: By = [1156.68,1156.68,1151.88,1150.99,1151.78,1151.78,1155.6,1175.79,1202.94

In [12]: dBydt = []
for i in range(len(By)-1):
dBydt += [(By[i+1]-By[i])/(t_By[i+1]-t_By[i])]
In [13]: t_EMF = [0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1,0.11,0.12,0.13,

In [14]: EMF = [-0.0115123,-0.0115123,-0.0141287,-0.0162219,-0.0162219,-0.0167452,

In [15]: interp_dBydt = interp1d(t_By[:-1], dBydt)

interp_EMF = interp1d(t_EMF, EMF)
interp_By = interp1d(t_By, By)

In [16]: def linear(x, m, b):

return np.add(np.multiply(m, x), b)

t = np.linspace(1, 9.6, 1000)

par, cov = fitter.curve_fit(linear, interp_dBydt(t), interp_EMF(t))
In [17]: plt.figure(figsize=[8, 6])
plt.plot(interp_dBydt(t), interp_EMF(t), 'x', label='Interpolated data')
plt.plot(interp_dBydt(t), linear(interp_dBydt(t), par[0], par[1]), label=
plt.xlabel('$dB_y/dt \ (\mu T/s)$ \n Fig 9. Part 2 Linear Regression for EMF
plt.ylabel('$EMF \ (mV)$', fontsize=12)
plt.legend()
plt.show()

print('Slope: {} +/- {}'.format(par[0], np.sqrt(cov[0][0])))

print('Intercept: {} +/- {}'.format(par[1], np.sqrt(cov[1][1])))

Slope: -8.067231337640461e-06 +/- 1.2470591094922178e-07

Intercept: -0.01091292291451558 +/- 0.0004261118990162456

Part 3
In [18]: t_By = [0.0122197,0.0244394,0.0366591,0.0488789,0.0610986,0.0733183,0.085538

In [19]: By = [521.67,521.572,521.67,521.572,521.964,522.258,521.082,521.376,521.376

In [20]: dBydt = []
for i in range(len(By)-1):
dBydt += [(By[i+1]-By[i])/(t_By[i+1]-t_By[i])]
In [21]: t_EMF = [0.00999385,0.0199877,0.0299815,0.0399754,0.0499692,0.0599631,0.0699

In [22]: EMF = [-0.00994244,-0.00941915,-0.00994244,-0.00941915,-0.00941915,-0.009942

In [23]: interp_dBydt = interp1d(t_By[:-1], dBydt)

interp_EMF = interp1d(t_EMF, EMF)
interp_By = interp1d(t_By, By)

In [24]: def linear(x, m, b):

return np.add(np.multiply(m, x), b)

t = np.linspace(5, 15, 1000)

par, cov = fitter.curve_fit(linear, interp_dBydt(t), interp_EMF(t))
In [25]: plt.figure(figsize=[8, 6])
plt.plot(interp_dBydt(t), interp_EMF(t), 'x', label='Interpolated data')
plt.plot(interp_dBydt(t), linear(interp_dBydt(t), par[0], par[1]), label=
plt.xlabel('$dB_y/dt \ (\mu T/s)$ \n Fig 10. Part 3 Linear Regression for EM
plt.ylabel('$EMF \ (mV)$', fontsize=12)
plt.legend()
plt.show()

print('Slope: {} +/- {}'.format(par[0], np.sqrt(cov[0][0])))

print('Intercept: {} +/- {}'.format(par[1], np.sqrt(cov[1][1])))

Slope: -4.420495003891437e-06 +/- 5.19869389879648e-08

Intercept: -0.009591346241733537 +/- 5.330055043448324e-05

Part 4 (Eddy current damping)

In [26]: #model equation given in theory section
def damped_acc(t, A, B, omega, phi, C):
return [C + A*np.exp(-t*B)*((B**2-omega**2)*np.cos(omega*t + phi) + 2

In [27]: t, a = [], []
for line in np.loadtxt('part 4 new control.csv', delimiter=',', skiprows=
t.append(line[3])
a.append(line[7])
In [28]: par0 = [2, 0.01, 8, 1.5, -9.8]
par, cov = fitter.curve_fit(damped_acc, t[20000:25000], a[20000:25000], par0

plt.figure()
plt.title('Control trial')
plt.xlabel('$t \ (s)$ \n Fig 11. Part 4 Non-linear Damped Acceleration Fitti
plt.ylabel('$a \ (m/s^2)$', fontsize=12)
plt.plot(t[20000:25000], a[20000:25000], label='Data') #taking a cleaner sam
plt.plot(t[20000:25000], damped_acc(t[20000:25000], par[0], par[1], par[2
plt.legend()
plt.show()

print('Damping factor = {} +/- {}'.format(par[1], np.sqrt(cov[1][1])))

Damping factor = 0.0034277688903821745 +/- 0.00020951912809778986

In [29]: t, a = [], []
for line in np.loadtxt('part 4 1.8 cm.csv', delimiter=',', skiprows=1):
t.append(line[3])
a.append(line[7])
In [30]: par0 = [2, 0.01, 8, 1.5, -9.8]
par, cov = fitter.curve_fit(damped_acc, t[20000:25000], a[20000:25000], par0

plt.figure()
plt.title('Trial 1 (1.80 cm)')
plt.xlabel('$t \ (s)$ \n Fig 12. Part 4 Non-linear Damped Acceleration Fitti
plt.ylabel('$a \ (m/s^2)$', fontsize=12)
plt.plot(t[20000:25000], a[20000:25000], label='Data') #taking a cleaner sam
plt.plot(t[20000:25000], damped_acc(t[20000:25000], par[0], par[1], par[2
plt.legend()
plt.show()

print('Damping factor = {} +/- {}'.format(par[1], np.sqrt(cov[1][1])))

Damping factor = 0.011174490255147997 +/- 0.000324457412127007

In [31]: t, a = [], []
for line in np.loadtxt('part 4 2.4 cm.csv', delimiter=',', skiprows=1):
t.append(line[3])
a.append(line[7])
In [32]: par0 = [2, 0.01, 8, 1.5, -9.8]
par, cov = fitter.curve_fit(damped_acc, t[20000:25000], a[20000:25000], par0

plt.figure()
plt.title('Trial 2 (2.40 cm)')
plt.xlabel('$t \ (s)$ \n Fig 13. Part 4 Non-linear Damped Acceleration Fitti
plt.ylabel('$a \ (m/s^2)$', fontsize=12)
plt.plot(t[20000:25000], a[20000:25000], label='Data') #taking a cleaner sam
plt.plot(t[20000:25000], damped_acc(t[20000:25000], par[0], par[1], par[2
plt.legend()
plt.show()

print('Damping factor = {} +/- {}'.format(par[1], np.sqrt(cov[1][1])))

Damping factor = 0.004533881494999536 +/- 0.00033566194910672855

In [33]: t, a = [], []
for line in np.loadtxt('part 4 5.1 cm.csv', delimiter=',', skiprows=1):
t.append(line[3])
a.append(line[7])
In [34]: par0 = [2, 0.01, 8, 1.5, -9.8]
par, cov = fitter.curve_fit(damped_acc, t[20000:25000], a[20000:25000], par0

plt.figure()
plt.title('Trial 3 (5.10 cm)')
plt.xlabel('$t \ (s)$ \n Fig 14. Part 4 Non-linear Damped Acceleration Fitti
plt.ylabel('$a \ (m/s^2)$', fontsize=12)
plt.plot(t[20000:25000], a[20000:25000], label='Data') #taking a cleaner sam
plt.plot(t[20000:25000], damped_acc(t[20000:25000], par[0], par[1], par[2
plt.legend()
plt.show()

print('Damping factor = {} +/- {}'.format(par[1], np.sqrt(cov[1][1])))

Damping factor = 0.003810399208349606 +/- 0.00021578897410233893

In [35]: distances = [1.80, 2.40, 5.10]
betas = [0.0112, 0.0045, 0.0038]
beta_errs = [0.0003, 0.0003, 0.0002]

plt.figure()
plt.title('Damping factor vs distance', fontsize=12)
plt.xlabel('Distance $(cm)$ \n Fig 15. Part 4 Variation in acceleration damp
plt.ylabel('Damping factor', fontsize=12)
plt.errorbar(distances, betas, xerr=[0.05]*3, yerr=beta_errs, fmt='x')
plt.plot(np.linspace(1.5, 5.5, 100), [0.0034]*100, label='Control')
plt.plot(np.linspace(1.5, 5.5, 100), [0.0036]*100, '--', label='Control uppe
plt.plot(np.linspace(1.5, 5.5, 100), [0.0032]*100, '--', label='Control lowe
plt.legend()
plt.show()