Using Matlab ode45 to solve differential equations

Nasser M. Abbasi

May 30, 2012 page compiled on July 1, 2015 at 11:43am

Contents
1 download examples source code 1

2 description 1

3 Simulation 3

4 Using ode45 with piecewise function 5

5 Listing of source code 5

1 download examples source code

1. first_order_ode.m.txt

2. second_order_ode.m.txt

3. engr80_august_14_2006_2.m.txt

4. engr80_august_14_2006.m.txt

5. ode45_with_piecwise.m.txt

2 description
This shows how to use Matlab to solve standard engineering problems which involves solving a standard second
order ODE. (constant coefficients with initial conditions and nonhomogeneous).
A numerical ODE solver is used as the main tool to solve the ODEs. The matlab function ode45 will be
used. The important thing to remember is that ode45 can only solve a first order ODE. Therefore to solve a
higher order ODE, the ODE has to be first converted to a set of first order ODEs. This is possible since an n
order ODE can be converted to a set of n first order ODEs.
Gives a first order ODE
dx
= f (x, t)
dt
An example of the above is dx t with an initial condition x(0) = 0. Here is the result of solving this
dt = 3e
ODE in Matlab. Source code is first_order_ode.m.txt

1
 function test1

% SOLVE dx/dt = -3 exp(-t).

% initial conditions: x(0) = 0

t=0:0.001:5; % time scalex

initial_x=0;

[t,x]=ode45( @rhs, t, initial_x);

plot(t,x);
xlabel('t'); ylabel('x');

function dxdt=rhs(t,x)
dxdt = 3*exp(-t);
end
end

To solve a second order ODE, using this as an example.

d2 x dx
2
+5 4x(t) = sin(10 t)
dt dt
Since ode45 can only solve a first order ode, the above has to be converted to two first order ODEs as follows.
Introduce 2 new state variables x1 , x2 and carry the following derivation

) ) ) )
x1 = x take derivative x01 = x0 do replacement x01 = x2 x01 = x2

x2 = x0 x02 = x00 x02 = 5x0 + 4x + sin (10t) x02 = 5x2 + 4x1 + sin (10t)

The above gives 2 new first order ODEs. These are

x01 = x2
x02 = 5x2 + 4x1 + sin (10t)
Now ode45 can be used to solve the above in the same way as was done with the first example. The only
difference is that now a vector is used instead of a scalar.
This is the result of solving this in Matlab. The source code is second_order_ode.m.txt

2
 function second_oder_ode

% SOLVE d2x/dt2+5 dx/dt - 4 x = sin(10 t)

% initial conditions: x(0) = 0, x'(0)=0

t=0:0.001:3; % time scale

initial_x = 0;
initial_dxdt = 0;

[t,x]=ode45( @rhs, t, [initial_x initial_dxdt] );

plot(t,x(:,1));
xlabel('t'); ylabel('x');

function dxdt=rhs(t,x)
dxdt_1 = x(2);
dxdt_2 = -5*x(2) + 4*x(1) + sin(10*t);

dxdt=[dxdt_1; dxdt_2];
end
end

3 Simulation
Now ode45 is used to perform simulation by showing the solution as it changes in time.
Given a single degree of freedom system. This represents any engineering system whose response can move
in only one direction. A typical SDOF (single degree of freedom) is the following mass/spring/damper system.

x
k

M F(t)

The first step is to obtain the equation of motion, which will be the second order ODE. Drawing the free
body diagram and from Newtons second laws the equation of motion is found to be

mx00 + cx0 + kx = f (f t)
In the above, f is the forcing frequency of the force on the system in rad/sec.
The response of the system (the solution of the system, or x(t)) is simulated for different parameters.
For example, the damping c can be changed, or the spring constant (the spring stiffness) to see how x(t)
changes. The forcing function frequency f can also be changed.
The following definitions are used in the
q Matlab
code.
k c 2
Natural frequency of the system = m 2m
Damping ratio = ccr where c is the damping coefficient and cr is the critical damping.

cr = 2 km

3
 When c > cr the system is called over damped. When c < cr the system is called underdamped
The following example runs a simulation showing the effect of changing the damping when the forcing
function is a step function. The response to a step function is a standard method used to analyze systems.

function engr80_august_14_2006_2()

% shows how to use Matlab to animation response of one degree of

% freedom system.
% show the effect of changing the damping of the system on the response.
% by Nasser Abbasi, UCI.

clear all; close all;

t_start = 0;
t_end = 6; %final time in seconds.
time_span =t_start:0.001:t_end;

k = 40; % spring stiffness. N/m

m = 5; % mass, kg

cr = 2*sqrt(k*m); %critical damping

fprintf('critical damping coef. of system is %f\n',cr);

initial_position = 0;
initial_speed = 0;

x0 = [initial_position initial_speed];

% Now start the simulation, change damping.

for c = 0: .5 : cr+.1*cr

[t,x]=ode45(@rhs,time_span,x0);
plot(t,x(:,1));
title(sprintf('Critical damping=%4.1f, current damping coeff. =%4.1f',cr,c));
ylim([-.1 .5]);
drawnow;
pause(.1);

end

grid
%**************************************
% solves m x''+ c x' + k x = f(t)
%**************************************
function xdot=rhs(t,x)

xdot_1 = x(2);
xdot_2 = -(c/m)*x(2) - (k/m)*x(1) + force(t)/m;

xdot = [xdot_1 ; xdot_2 ];

end
%********************
% The forcing function, edit to change as needed.
%********************
function f=force(t)

P = 100; % force amplitude

%f=P*sin(omega*t);

f=10; %unit step

%if t<eps %impulse

% f=1
%else
% f=0;
%end

%f=P*t; %ramp input

end
end

4
4 Using ode45 with piecewise function
ode45 can be used with piecewise function defined for the RHS. For example, given x00 (t) x(t) = c where c = 1
for 0 <= t < 1 and c = 20 for 1 <= t < 2 and c = 3 for 2 <= t <= 3, the following code example shows one way
to implement the above.
ode45_with_piecwise.m.txt

5 Listing of source code

first order ode.m

1 function first_oder_ode
2

3 % SOLVE dx / dt = -3 exp ( - t ) .
4 % initial conditions : x (0) = 0
5

6 t =0:0 .001 :5; % time scalex

7 initial_x =0;
8

9 [t , x ]= ode45 ( @rhs , t , initial_x ) ;

10

11 plot (t , x ) ;
12 xlabel ( ' t ' ) ; ylabel ( ' x ' ) ;
13

14 function dxdt = rhs (t , x )

15 dxdt = 3* exp ( - t ) ;
16 end
17 end

second order ode.m

1 function second_oder_ode
2

3 % SOLVE d2x / dt2 +5 dx / dt - 4 x = sin (10 t )

4 % initial conditions : x (0) = 0 , x ' ( 0 ) =0
5

6 t =0:0 .001 :3; % time scale

7

8 initial_x = 0;
9 initial_dxdt = 0;
10

11 [t , x ]= ode45 ( @rhs , t , [ initial_x initial_dxdt ] ) ;

12

13 plot (t , x (: ,1) ) ;
14 xlabel ( ' t ' ) ; ylabel ( ' x ' ) ;
15

16 function dxdt = rhs (t , x )

17 dxdt_1 = x (2) ;
18 dxdt_2 = -5* x (2) + 4* x (1) + sin (10* t ) ;

5
19

20 dxdt =[ dxdt_1 ; dxdt_2 ];

21 end
22 end

engr80 august 14 2006 2.m

1 function e n g r 8 0 _ a u g u s t _ 1 4 _ 2 0 0 6 _ 2 ()
2

3 % shows how to use Matlab to animation response of one degree of

4 % freedom system.
5 % show the effect of changing the damping of the system on the response.
6 % by Nasser Abbasi , UCI.
7

8 clear all ; close all ;

9

10 t_start = 0;
11 t_end = 6; % final time in seconds.
12 time_span = t_start :0 .001 : t_end ;
13

14 k = 40; % spring stiffness. N / m

15 m = 5; % mass , kg
16

17 cr = 2* sqrt ( k * m ) ; % critical damping

18

19 fprintf ( ' critical damping coef. of system is % f \ n ' , cr ) ;

20

21 initial_position = 0;
22 initial_speed = 0;
23

24 x0 = [ initial_position initial_speed ];
25

26 % Now start the simulation , change damping.

27

28 for c = 0: .5 : cr + .1 * cr
29

30 [t , x ]= ode45 ( @rhs , time_span , x0 ) ;

31 plot (t , x (: ,1) ) ;
32 title ( sprintf ( ' Critical damping =%4 .1f , current damping coeff. ...
=%4 .1f ' ,cr , c ) ) ;
33 ylim ([ - .1 .5 ]) ;
34 drawnow ;
35 pause ( .1 ) ;
36

37 end
38

39 grid
40 % **************************************
41 % solves m x ' ' + c x ' + k x = f ( t )
42 % **************************************

6
43 function xdot = rhs (t , x )
44

45 xdot_1 = x (2) ;
46 xdot_2 = -( c / m ) * x (2) - ( k / m ) * x (1) + force ( t ) / m ;
47

48 xdot = [ xdot_1 ; xdot_2 ];

49 end
50 % ********* *** ** *** ***
51 % The forcing function , edit to change as needed.
52 % ********* *** ** *** ***
53 function f = force ( t )
54

55 P = 100; % force amplitude

56 % f = P * sin ( omega * t ) ;
57

58 f =10; % unit step

59

60 % if t < eps % impulse

61 % f =1
62 % else
63 % f =0;
64 % end
65

66 %f=P*t; % ramp input

67 end
68 end

engr80 august 14 2006.m

1 function en gr 8 0_ au g us t _1 4_ 2 00 6 ()
2 % shows how to use Matlab to animation response of one degree of
3 % freedom system.
4 % by Nasser Abbasi , UCI.
5

6 clear all ; close all ;

7

8 t_start = 0;
9 t_end = 6; % final time in seconds.
10 time_span =[ t_start t_end ];
11 time_span = t_start :0 .001 : t_end ;
12

13 k = 100; % spring stiffness. N / m

14 c = 20; % damping coeff. N - s / m
15 m = 5; % mass , kg
16

17 natural_da mp ed_ om ega = sqrt ( k / m - ( c /(2* m ) ) ^2 ) ;

18

19 fprintf ( ' Natural damped frequency of system is ...

% f \ n ' , n at ura l_ dam pe d_o meg a ) ;
20

7
21 initial_position = 0;
22 initial_speed = 0;
23

24 x0 = [ initial_position initial_speed ];
25

26 for omega =0:0 .1 : na tur al _da mpe d_ ome ga +0 .1

27 [t , x ]= ode45 ( @rhs , time_span , x0 ) ;
28 plot (t , x (: ,1) ) ;
29 title ( sprintf ( ' forcing freq =%4 .1f ' , omega ) ) ;
30 % ylim ([ - .1 2]) ;
31 drawnow ;
32 % pause ( .1 ) ;
33 end
34

35 grid
36

37 % **************************************
38 % solves m x ' ' + c x ' + k x = f ( t )
39 % **************************************
40 function xdot = rhs (t , x )
41

42 xdot_1 = x (2) ;
43 xdot_2 = -( c / m ) * x (2) - ( k / m ) * x (1) + force ( t ) / m ;
44

45

46 xdot = [ xdot_1 ; xdot_2 ];

47 end
48

49 % ********* *** ** *** ***

50 %
51 % ********* *** ** *** ***
52 function f = force ( t )
53

54 P = 100; % force amplitude

55 f = P * sin ( omega * t ) ;
56

57 % f =10; % unit step

58

59 % if t < eps % impulse

60 % f =1
61 % else
62 % f =0;
63 % end
64

65 %f=P*t; % ramp input

66

67 end
68

69

70 end

8
ode45 with piecwise.m

2 % ---------------------------------
3 %
4 % Example solve x ' ' - x = c
5 %
6 % where c =1 for 0 t <1
7 % c =20 for 1 t <2
8 % c =3 for 2 t 3
9 %
10 % IC x = 0 , t = 0
11 % x ' = 1, t = 0
12 %
13

14

15 % --------------------
16 function o de45_wi th_piec wise ()
17

18 t = 0:0 .1 :3; % time scale

19 initial_x = 0;
20 initial_dxdt = 1;
21

22 [t , x ] = ode45 ( @rhs , t , [ initial_x initial_dxdt ] ) ;

23

24 plot (t , x (: ,1) ) ;
25 xlabel ( ' t ' ) ; ylabel ( ' x ' ) ;
26

27 end
28

29 % --------------------
30 % ode45 rhs
31 function dxdt = rhs (t , x )
32 dxdt_1 = x (2) ;
33 dxdt_2 = x (1) + 1*((0 t ) &( t <1) ) + 20*((1 t ) &( t 2) ) + 3*((2 t ) &( t 3) ) ;
34 dxdt = [ dxdt_1 ; dxdt_2 ];
35 end