Modeling and Simulation in Python

Chapter 24

Copyright 2017 Allen Downey

License: Creative Commons Attribution 4.0 International

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 module
from modsim import *

Rolling paper

We'll start by loading the units we need.

In [2]:
radian = UNITS.radian
m = UNITS.meter
s = UNITS.second

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)

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)

In [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,
    dydt = r * omega
    drdt = k * omega
    return omega, dydt, drdt

Testing slope_func

In [9]:
slope_func(system.init, 0, system)

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)

Now we can run the simulation.

In [12]:
results, details = run_ode_solver(system, slope_func, events=event_func)

And look at the results.

In [13]:

The final value of y is 47 meters, as expected.

In [14]:
unrolled = get_last_value(results.y)

The final value of radius is R_max.

In [15]:
radius = get_last_value(results.r)

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

The elapsed time is about 2 minutes, which is also plausible.

In [17]:
t_final = get_last_label(results) * s


Plotting theta

In [18]:
def plot_theta(results):
    plot(results.theta, color='C0', label='theta')
    decorate(xlabel='Time (s)',
             ylabel='Angle (rad)')

Plotting y

In [19]:
def plot_y(results):
    plot(results.y, color='C1', label='y')

    decorate(xlabel='Time (s)',
             ylabel='Length (m)')

Plotting r

In [20]:
def plot_r(results):
    plot(results.r, color='C2', label='r')

    decorate(xlabel='Time (s)',
             ylabel='Radius (m)')

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)',

And here's the figure from the book.

In [22]:
def plot_three(results):
    subplot(3, 1, 1)

    subplot(3, 1, 2)

    subplot(3, 1, 3)



Here's a draw function that animates the results using matplotlib patches.

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)
    # draw an arrow to show rotation
    dx, dy = pol2cart(theta, radius)
    arrow = Arrow(0, 0, dx, dy)

    # make the aspect ratio 1

In [24]:
animate(results, draw_func)

Exercise: Run the simulation again with a smaller step size to smooth out the animation.


Exercise: Since we keep omega constant, the linear velocity of the paper increases with radius. Use gradient to estimate the derivative of results.y. What is the peak linear velocity?

In [25]:
# Solution goes here

In [26]:
plot(dydt, label='dydt')
decorate(xlabel='Time (s)',
         ylabel='Linear velocity (m/s)')

In [27]:
# Solution goes here

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 goes here

In [29]:
# Solution goes here

In [30]:
# Solution goes here

In [31]:
# Solution goes here

In [32]:
# Solution goes here

In [ ]: