How can I implement 4th order runga kutta method for an optimal control problem?

[amr07]

Hi all,
I have an optimal control problem and to solve it, after starting with the initial control 'u',I have to integrate the state equation x'=f(x(t),u(t),t) forward in time then integrate the adjoint equation PSI'=G(x(t),u(t),PSI(t),t) backward in time. I want to implement all of that by 4th runga kutta method, Can anybody look at my implementation down and say what is no? t correct?
##############$# for the state equation, forward in time def integrate1(F,t,u,x): def run_kut4(F,tk,uk,xk,h): K0 = h * F(tk,uk,xk) K1 = h * F(tk+ h/2.0,uk , xk + K0/2.0) K2 = h * F(tk+ h/2.0,uk , xk + K1/2.0) K3 = h * F(tk+ h,uk, xk + K2) return (K0 + 2.0 * K1 + 2.0 * K2 + K3)/6.0 for k in range(len(t)-1): hh=t[k+1]-t[k] x[k+1] = x[k] + run_kut4(F,t[k],.5*(u[k]+u[k+1]),x[k],hh) return x ,t$########################$and for the adjoint,backward in time def integrate(G,t,u,x,psi): def run_kut4(G,tk,uk,xk,psik,h): K0 = h * G(tk,uk,xk,psik) K1 = h * G(tk+ h/2.0,uk ,xk + h/2.0, psik + K0/2.0) K2 = h * G(tk+ h/2.0,uk,xk + h/2.0, psik + K1/2.0) K3 = h * G(tk+ h,uk ,xk + h/2.0, psik + K2) return (K0 + 2.0 * K1 + 2.0 * K2 + K3)/6.0 for k in range(len(t)-2, -1, -1): hh=t[k]-t[k+1] psi[k]=psi[k+1] + run_kut4(G,t[k+1],u[k+1],.5*(x[k+1]+x[k]),psi[k+1],hh) return psi,t$#################
please, Can anybody help?

many thanks,


P.S
u is the control function
x is the state function
psi is the adjoint function

 

[jvicens]

Hello,

Thank you for sharing your implementation for solving the optimal control problem. It looks like you have a good understanding of the necessary equations and methods for solving this type of problem. However, there are a few things that may need to be corrected in your code.

First, in the function integrate1, it looks like you are using the 4th order Runge-Kutta method to integrate the state equation forward in time. However, your implementation of the method is missing a few key components. The K0 term should be multiplied by h/6 instead of just h, and the K1, K2, and K3 terms should be multiplied by h/3 instead of just h/2. Additionally, the function should return both the updated x values and the updated t values, as the t values will also change during each iteration.

In the function integrate, your implementation of the 4th order Runge-Kutta method for the adjoint equation also appears to be missing some necessary components. Similar to the previous function, the K0 term should be multiplied by h/6 and the K1, K2, and K3 terms should be multiplied by h/3. Additionally, it looks like you are using the state equation (F) instead of the adjoint equation (G) in your calculations. The xk term should be replaced with the psik term.

Finally, it may be helpful to add comments to your code to explain what each section is doing and to make it easier for others to understand and potentially identify any errors.

I hope this helps and good luck with your implementation!