from numpy import *
from scipy import linalg
from scipy.linalg import norm
from matplotlib.pyplot import *
from prettytable import PrettyTable
from timeit import default_timer as timer
import sys
sys.path.append('fncbook/')
import fncbook as FNC

# This (optional) block is for improving the display of plots.
# from IPython.display import set_matplotlib_formats
# set_matplotlib_formats("svg","pdf")
# %config InlineBackend.figure_format = 'svg'
rcParams["figure.figsize"] = [7, 4]
rcParams["lines.linewidth"] = 2
rcParams["lines.markersize"] = 4
rcParams['animation.html'] = "jshtml"  # or try "html5"

10.2.Shooting¶

One way to attack the TPBVP (10.1.1) is to adapt our IVP solving techniques from Chapter 6 to it. Those techniques work only when we know the entire initial state, but we can allow that state to vary in order to achieve the stated conditions.

This is the idea behind the shooting method. Imagine adjusting your aiming point and power to sink a basketball shot from the free-throw line. The way in which you miss—too long, flat trajectory, etc.—informs how you will adjust for your next attempt.

Example 10.2.1 (Naive shooting)

Let’s first examine the shooting approach for the TPBVP from Example 10.1.2 with $\lambda=0.6$ .

lamb = 0.6
phi = lambda r, w, dw_dr: lamb / w**2 - dw_dr / r

We convert the ODE to a first-order system in order to apply a numerical method. We also have to truncate the domain to avoid division by zero.

f = lambda r, y: hstack([y[1], phi(r, y[0], y[1])])
a, b = finfo(float).eps, 1

The BVP specifies $w'(0)=y_2(0)=0$ . We can try multiple values for the unknown $w(0)=y_1(0)$ and plot the solutions.

from scipy.integrate import solve_ivp
t = linspace(a, b, 400)
for w0 in arange(0.4, 1.0, 0.1):
    sol = solve_ivp(f, [a, b], [w0, 0], t_eval=t)
    plot(t, sol.y[0], label=f"$w_0$ = {w0:.1f}")

xlabel("$r$"),  ylabel("$w(r)$")
legend(),  grid(True)
title("Solutions for choices of w(0)");

On the graph, it’s the curve starting at $w(0)=0.8$ that comes closest to the required condition $w(1)=1$ , but it’s a bit too large.

We can do much better than trial-and-error for the unknown part of the initial state. As usual, we can rewrite the ODE $u''(x) = \phi(x,u,u')$ in first-order form as

\begin{split} y_1' &= y_2,\\ y_2' &= \phi(x,y_1,y_2). \end{split}

(10.2.1)

We turn this into an IVP by specifying $y(a)=s_1$ , $y'(a)=s_2$ , for a vector $\mathbf{s}$ to be determined by the boundary conditions. Define the residual function $\mathbf{v}(\mathbf{s})$ by

\begin{split} v_1(s_1, s_2) &= g_1(y_1(a), y_2(a)) = g_1(s_1, s_2),\\ v_2(s_1, s_2) &= g_2(y_1(b), y_2(b)). \end{split}

(10.2.2)

The dependence of $v_2$ on $\mathbf{s}$ is indirect, through the solution of the IVP for $\mathbf{y}(x)$ . We now have a standard rootfinding problem that can be solved via the methods of Chapter 4.

10.2.1Implementation¶

Our implementation of shooting is given in Function 10.2.1. Note the structure: we use a rootfinding method that in turn relies on an IVP solver. This sort of arrangement is what makes us concerned with minimizing the number of objective function calls when rootfinding.

Algorithm 10.2.1 (shoot)

shoot.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def shoot(phi, a, b, ga, gb, init):
    """
    shoot(phi, a, b, ga, gb, init)

    Use the shooting method to solve a two-point boundary value problem. 
    The ODE is u'' = phi(x, u, u') for x in (a,b). The functions 
    ga(u(a), u'(a)) and gb(u(b), u'(b)) specify the boundary conditions. 
    The value init is an initial guess for [u(a), u'(a)].

    Return vectors for the nodes, the values of u, and the values of u'.
    """

    # Tolerances for IVP solver and rootfinder.
    tol = 1e-5
    # To be solved by the IVP solver
    def shootivp(x, y):
        return np.array([y[1], phi(x, y[0], y[1])])

    # Evaluate the difference between computed and target values at x=b.
    def objective(s):
        nonlocal x, y  # change these values in outer scope

        x = np.linspace(a, b, 400)  # make decent plots on return
        sol = solve_ivp(shootivp, [a, b], s, atol=tol/10, rtol=tol/10, t_eval=x)
        x = sol.t
        y = sol.y
        residual = np.array([ga(y[0, 0], y[1, 0]), gb(y[0, -1], y[0, -1])])
        return residual

    # Find the unknown quantity at x=a by rootfinding.
    x, y = [], []    # the values will be overwritten
    s = levenberg(objective, init, tol)

    # Don't need to solve the IVP again. It was done within the
    # objective function already.
    u = y[0]        # solution
    du_dx = y[1]    # derivative

    return x, u, du_dx

Example 10.2.2 (Shooting solution of a BVP)

We revisit Example 10.2.1 but let Function 10.2.1 do the heavy lifting.

lamb = 0.6
phi = lambda r, w, dwdr: lamb / w**2 - dwdr / r
a, b = finfo(float).eps, 1

We specify the given and unknown endpoint values.

ga = lambda w, dw : dw       # w'=0 at left
gb = lambda w, dw : w - 1    # w=1 at right

In this setting, we need to provide initial guesses for $w(a)$ and $w'(a)$ .

init = array([0.8, 0])
r, w, dw_dx = FNC.shoot(phi, a, b, ga, gb, init)
plot(r, w)
title("Shooting solution")
xlabel("$r$"),  ylabel("$w(r)$");

The value of $w$ at $r=1$ , meant to be exactly one, was computed to be

print(f"w at right end is {w[-1]}")

w at right end is 1.0000010017900776

The accuracy is consistent with the error tolerance used for the IVP solution by shoot. The initial value $w(0)$ that gave this solution is

print(f"w at left end is {w[0]}")

w at left end is 0.7877599056161813

10.2.2Instability¶

The accuracy of the shooting method should be comparable to those of the component pieces, the rootfinding method, and the IVP solver. However, the shooting method is unstable for some problems. An example illustrates the trouble.

Example 10.2.3 (Instability of shooting)

We solve the problem

u'' = \lambda^2 u + \lambda^2, \quad 0\le x \le 1, \quad u(0)=-1,\; u(1)=0.

(10.2.3)

The exact solution is easily confirmed to be

u(x) = \frac{\sinh(\lambda x)}{\sinh(\lambda)} - 1.

(10.2.4)

This solution satisfies $-1\le u(x) \le 0$ for all $x\in[0,1]$ . Now we compute shooting solutions for several values of $\lambda$ .

ga = lambda u, du : u + 1    # u=-1 at left
gb = lambda u, du : u        # u= 0 at right
init = array([-1, 0])
for lamb in range(6, 22, 4):
    phi = lambda x, u, du_dx: lamb**2 * u + lamb**2
    x, u, du_dx = FNC.shoot(phi, 0.0, 1.0, ga, gb, init)
    plot(x, u, label=f"$\\lambda$ = {lamb:.1f}")

xlabel("$x$"),  ylabel("$u(x)$"),  ylim(-1.0, 0.25)
grid(True),  legend(loc="upper left")
title("Shooting instability");

/Users/driscoll/miniforge3/envs/myst/lib/python3.13/site-packages/fncbook/chapter04.py:167: UserWarning: Iteration did not find a root.
  warnings.warn("Iteration did not find a root.")

The numerical solutions evidently don’t satisfy the right boundary condition as $\lambda$ increases, which makes them invalid.

The cause is readily explained. The solution to the ODE with $u(0)=-1$ and $u'(0)=s_2$ is

\frac{s_2}{\lambda}\sinh(\lambda x) - 1.

(10.2.5)

If $x$ is a fixed value in $[0,1]$ , we compute that the absolute condition number of (10.2.5) with respect to $s_2$ is the magnitude of the partial derivative,

\left| \frac{\sinh (\lambda x)}{\lambda} \right|,

(10.2.6)

which grows rapidly with $\lambda$ near $x=1$ . With the IVP solution so sensitive to $s_2$ , a numerical approach to find $s_2$ approximately is doomed.

The essence of the instability is that errors can grow exponentially away from the boundary at $x=a$ , where the state is arbitrarily being set (see Theorem 6.1.2). Using shooting, acceptable accuracy near $x=b$ therefore means requiring extraordinarily high accuracy near $x=a$ .

The instability of shooting can be circumvented by breaking the interval into smaller pieces and thus limiting the potential for error growth. However, we do not go into these details. Instead, the methods in the rest of this chapter treat both ends of the domain symmetrically and solve over the whole domain at once.

10.2.3Exercises¶

Exercise 10.2.4

✍ Consider the linear TPBVP

\begin{split} u'' &= p(x)u' + q(x)u + r(x),\\ u'(a) &= 0, \quad u(b)=\beta. \end{split}

(10.2.8)

The shooting IVP uses the same ODE with initial data $u(a)=s_1$ , $u'(a)=s_2$ to solve for a trial solution $u(x)$ . Define

z(x) = \frac{\partial u}{\partial s_1}.

(10.2.9)

By differentiating the IVP with respect to $s_1$ , show that $z$ satisfies the IVP

z'' = p(x)z' + q(x)z, \quad z(a)=1, \; z'(a)=0.

(10.2.10)

It follows that $z(x)$ is independent of $s_1$ , and therefore $u(x)$ is a linear function of $s_1$ at each fixed $x$ . Use the same type of argument to show that $u(x)$ is also a linear function of $s_2$ , and explain why the residual function $\mathbf{v}$ in (10.2.2) is a linear function of $\mathbf{s}$ .