Why does changing my time step result in zeros when solving a system of ODEs?

I have correctly solved a system of ODEs to calculate a car’s trajectory from a given steering input:

A is a matrix describing the vehicle parameters; b is a vector based on vehicle parameters; u is the steering input; and V is the velocity. The parameters A, b and V are not time dependent. The steering input (radians) is a time-dependent step input as shown in the code.

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
# model parameters
m = 1500 #mass
I = 2500 #moment inertia
lf = 1.1
lr = 1.6
Cf = 55000 #tire stiffness
Cr = 60000
V = 27.77    
A = np.array([[-2*(Cf+Cr)/(m*V), (2*(Cr*lr-Cf*lf)/(m*V**2))-1,0,0,0],[2*(Cr*lr-Cf*lf)/I, -2*((Cf*lf**2)+(Cr*lr**2))/(I*V),0,0,0]])
b = np.array([(2*Cf)/(m*V),(2*Cf*lf)/I])
def func(x,t):
x1 = x[0]
x2 = x[1]
x3 = x[2]
x4 = x[3]
x5 = x[4]
if t>1 and t<1.5:  # steering inputs
u = .2
elif t>3.5 and t<4:
u=-.2
elif t>8 and t<8.5:
u = -.2
elif t>10.5 and t<11:
u = .2
else:
u=0
dx1dt = np.dot(A[0,:],x) +b[0]*u 
dx2dt = np.dot(A[1,:],x) + b[1]*u
dx3dt = V*np.cos(x5+x1)
dx4dt = V*np.sin(x5+x1)
dx5dt = x2
return [dx1dt, dx2dt,dx3dt,dx4dt,dx5dt]
x0 =[0,0,0,0,0] # initial conditions
t = np.arange(0,20,.005) #timestep 0 to 20 seconds at .005sec interval
x = odeint(func,x0,t)
x1 = x[:,0]
x2 = x[:,1]
x3 = x[:,2]
x4 = x[:,3]
x5 = x[:,4]
plt.plot(x3,x4) # x3 is x position, x4 is y position
plt.xlim([0,600])
plt.ylim([0,40])

Now, depending on the timestep, I get totally different results:

• For 0.005 and 0.08, I get a correct solution.
• For 0.03, I get a solution that is only zero.
• For 0.08, I get an incorrect non-zero solution.

Why would changing the timestep result in a zeros for the other variables?
How can one know which timestep values provide a correct solution without knowing the correct solution beforehand?

What you observe is probably due to the following:

• u suddenly changes on very small time scales compared to your integration time.
• The t argument of odeint is not prescribing mandatory integration steps, but rather points at which the solution is evaluated. odeint may decide to take coarser steps than given in t and then interpolate the result at the points given in t. However, t does affect the guess of step sizes and thus the steps actually taken. (I am not completely sure about this since I cannot find it documented, but it’s a common behaviour for integrators and perfectly matches your observations.)

As a result, odeint may completely step over the intervals where u is different (steering inputs) and thus your car is computed to drive straight instead of taking a turn. For example in such a case, your function func simply never gets evaluated for any time between 1 and 1.5 and thus odeint cannot possibly know that it changes its behaviour in that interval.

To avoid this, set the parameter hmax which governs the maximum step size such that at least one step has to be within a steering interval:

x = odeint(func,x0,t,hmax=0.49)

The adaptive integrator will then take care to further scale down the steps accordingly.