In [1]:
# Configure Jupyter so figures appear in the notebook
%matplotlib inline
# Configure Jupyter to display the assigned value after an assignment
%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'
# import functions from the modsim.py module
from modsim import *
In [2]:
radian = UNITS.radian
m = UNITS.meter
s = UNITS.second
Out[2]:
And creating a Params object with the system parameters
In [3]:
params = Params(Rmin = 0.02 * m,
Rmax = 0.055 * m,
L = 47 * m,
omega = 10 * radian / s,
t_end = 130 * s,
dt = 1*s)
Out[3]:
The following function estimates the parameter k, which is the increase in the radius of the roll for each radian of rotation.
In [4]:
def estimate_k(params):
"""Estimates the parameter `k`.
params: Params with Rmin, Rmax, and L
returns: k in meters per radian
"""
Rmin, Rmax, L = params.Rmin, params.Rmax, params.L
Ravg = (Rmax + Rmin) / 2
Cavg = 2 * pi * Ravg
revs = L / Cavg
rads = 2 * pi * revs
k = (Rmax - Rmin) / rads
return k
As usual, make_system takes a Params object and returns a System object.
In [5]:
def make_system(params):
"""Make a system object.
params: Params with Rmin, Rmax, and L
returns: System with init, k, and ts
"""
init = State(theta = 0 * radian,
y = 0 * m,
r = params.Rmin)
k = estimate_k(params)
return System(params, init=init, k=k)
Testing make_system
In [6]:
system = make_system(params)
Out[6]:
In [7]:
system.init
Out[7]:
Now we can write a slope function based on the differential equations
$\omega = \frac{d\theta}{dt} = 10$
$\frac{dy}{dt} = r \frac{d\theta}{dt}$
$\frac{dr}{dt} = k \frac{d\theta}{dt}$
In [8]:
def slope_func(state, t, system):
"""Computes the derivatives of the state variables.
state: State object with theta, y, r
t: time
system: System object with r, k
returns: sequence of derivatives
"""
theta, y, r = state
k, omega = system.k, system.omega
dydt = r * omega
drdt = k * omega
return omega, dydt, drdt
Testing slope_func
In [9]:
slope_func(system.init, 0, system)
Out[9]:
We'll use an event function to stop when y=L.
In [10]:
def event_func(state, t, system):
"""Detects when we've rolled length `L`.
state: State object with theta, y, r
t: time
system: System object with L
returns: difference between `y` and `L`
"""
theta, y, r = state
return y - system.L
In [11]:
event_func(system.init, 0, system)
Out[11]:
Now we can run the simulation.
In [12]:
results, details = run_ode_solver(system, slope_func, events=event_func)
details
Out[12]:
And look at the results.
In [13]:
results.tail()
Out[13]:
The final value of y is 47 meters, as expected.
In [14]:
unrolled = get_last_value(results.y)
Out[14]:
The final value of radius is R_max.
In [15]:
radius = get_last_value(results.r)
Out[15]:
The total number of rotations is close to 200, which seems plausible.
In [16]:
radians = get_last_value(results.theta)
rotations = magnitude(radians) / 2 / np.pi
Out[16]:
The elapsed time is about 2 minutes, which is also plausible.
In [17]:
t_final = get_last_label(results) * s
Out[17]:
Plotting theta
In [18]:
def plot_theta(results):
plot(results.theta, color='C0', label='theta')
decorate(xlabel='Time (s)',
ylabel='Angle (rad)')
plot_theta(results)
Plotting y
In [19]:
def plot_y(results):
plot(results.y, color='C1', label='y')
decorate(xlabel='Time (s)',
ylabel='Length (m)')
plot_y(results)
Plotting r
In [20]:
def plot_r(results):
plot(results.r, color='C2', label='r')
decorate(xlabel='Time (s)',
ylabel='Radius (m)')
plot_r(results)
We can also see the relationship between y and r, which I derive analytically in the book.
In [21]:
plot(results.r, results.y, color='C3')
decorate(xlabel='Radius (m)',
ylabel='Length (m)',
legend=False)
And here's the figure from the book.
In [22]:
def plot_three(results):
subplot(3, 1, 1)
plot_theta(results)
subplot(3, 1, 2)
plot_y(results)
subplot(3, 1, 3)
plot_r(results)
plot_three(results)
savefig('figs/chap24-fig01.pdf')
In [23]:
from matplotlib.patches import Circle
from matplotlib.patches import Arrow
def draw_func(state, t):
# get radius in mm
theta, y, r = state
radius = r.magnitude * 1000
# draw a circle with
circle = Circle([0, 0], radius, fill=True)
plt.gca().add_patch(circle)
# draw an arrow to show rotation
dx, dy = pol2cart(theta, radius)
arrow = Arrow(0, 0, dx, dy)
plt.gca().add_patch(arrow)
# make the aspect ratio 1
plt.axis('equal')
In [24]:
animate(results, draw_func)
Exercise: Run the simulation again with a smaller step size to smooth out the animation.
In [25]:
# Solution
dydt = gradient(results.y);
In [26]:
plot(dydt, label='dydt')
decorate(xlabel='Time (s)',
ylabel='Linear velocity (m/s)')
In [27]:
# Solution
linear_velocity = get_last_value(dydt) * m/s
Out[27]:
Now suppose the peak velocity is the limit; that is, we can't move the paper any faster than that.
Nevertheless, we might be able to speed up the process by keeping the linear velocity at the maximum all the time.
Write a slope function that keeps the linear velocity, dydt, constant, and computes the angular velocity, omega, accordingly.
Run the simulation and see how much faster we could finish rolling the paper.
In [28]:
# Solution
def slope_func(state, t, system):
"""Computes the derivatives of the state variables.
state: State object with theta, y, r
t: time
system: System object with r, k
returns: sequence of derivatives
"""
theta, y, r = state
k, omega = system.k, system.omega
dydt = linear_velocity
omega = dydt / r
drdt = k * omega
return omega, dydt, drdt
In [29]:
# Solution
slope_func(system.init, 0, system)
Out[29]:
In [30]:
# Solution
results, details = run_ode_solver(system, slope_func, events=event_func)
details
Out[30]:
In [31]:
# Solution
t_final = get_last_label(results) * s
Out[31]:
In [32]:
# Solution
plot_three(results)
In [ ]: