COMPGROUPS.NET | Search | Post Question | Groups | Stream | About | Register

### ode-solver - iteration scheme?

• Email
• Follow

```I have a linear equation of motion, for a flapped airfoil with damper and springs.

M*ddx + D*dx + C*x = F(t,x,dx)

The calculation of the aerodynamic forces is performed through a panel-method based on Hess and Smith. The solution is obtained using the ode45-solver, which seems to give accurate results.
My question is, does the ode-solver take in account the dependency of displacement x and the velocity dx of the flaps properly? MATLAB calculates the forces at the beginning of every time-step, but they change during the time-step. Isn't there an iteration scheme like any kind of predictor-corrector-method necessary?

Thank you in anticipation!
```
 0

See related articles to this posting

```> I have a linear equation of motion, for a flapped
> airfoil with damper and springs.
>
> M*ddx + D*dx + C*x = F(t,x,dx)
>
> The calculation of the aerodynamic forces is
> performed through a panel-method based on Hess and
> Smith. The solution is obtained using the
> ode45-solver, which seems to give accurate results.
> My question is, does the ode-solver take in account
> the dependency of displacement x and the velocity dx
> of the flaps properly? MATLAB calculates the forces
> at the beginning of every time-step, but they change
> during the time-step. Isn't there an iteration scheme
> like any kind of predictor-corrector-method
> necessary?
>
> Thank you in anticipation!

The fact that ODE45 is an explicit integrator does
not cause that the results are less accurate than those
obtained by an implicit solver.
The only advantage of implicit solvers is that they
can better cope with stiff problems. If you notice
that ODE45 makes very small time steps, you should
switch to such an implicit integrator.

Best wishes
Torsten.
```
 0

```"Manuel " <manuel.jain@gmx.net> wrote in message <ho7okm\$cbt\$1@fred.mathworks.com>...
> I have a linear equation of motion, for a flapped airfoil with damper and springs.
>
> M*ddx + D*dx + C*x = F(t,x,dx)
>
> The calculation of the aerodynamic forces is performed through a panel-method based on Hess and Smith. The solution is obtained using the ode45-solver, which seems to give accurate results.
> My question is, does the ode-solver take in account the dependency of displacement x and the velocity dx of the flaps properly? MATLAB calculates the forces at the beginning of every time-step, but they change during the time-step. Isn't there an iteration scheme like any kind of predictor-corrector-method necessary?

Huh? It is *your* responsibility to program the dependency. The runge-kutta scheme (ode45) *is* a predictor-corrector method.

Bruno
```
 0

```Dear Bruno,
The calculation of the forces is correct. But if you look at the first time-step, the ode-solver accesses the force calculation and then integrates the equation of motion. The magnitude of the force changes during the time-step. For instance, ode starts at t_0 and calculates F, integrates the equation and reaches time-step t_1 = t_0 + h, with h being the step-size. The magnitude of F at time, let's say, t = t_0 + h/2, is different, due to the displacement x, but the integration is based on F(t_0,x_0,dx_0). So does ode take care of this inexactness?
Regards.
```
 0

```"Manuel " <manuel.jain@gmx.net> wrote in message <ho7svf\$1nk\$1@fred.mathworks.com>...
> Dear Bruno,
> The calculation of the forces is correct. But if you look at the first time-step, the ode-solver accesses the force calculation and then integrates the equation of motion. The magnitude of the force changes during the time-step. For instance, ode starts at t_0 and calculates F, integrates the equation and reaches time-step t_1 = t_0 + h, with h being the step-size. The magnitude of F at time, let's say, t = t_0 + h/2, is different, due to the displacement x, but the integration is based on F(t_0,x_0,dx_0). So does ode take care of this inexactness?
> Regards.

To make good use of matlab you need to learn to use help. At the matlab prompt type: help
then: help ode45
If you don't find the information you're wondering about you have to look in the documentation, type: doc ode45

HTH,
Bjeorn
```
 0

```Dear Bruno!

> The runge-kutta scheme (ode45) *is* a predictor-corrector method.

No, Runge-Kutta 45 uses the two different methods "4" and "5" to estimate the local error and control the step size. But it is not a predictor-corrector method, e.g. as an Adams-Bashforth-Moulten method.

Kind regards, Jan
```
 0

```Dear Manuel!

> The calculation of the forces is correct. But if you look at the first time-step, the ode-solver accesses the force calculation and then integrates the equation of motion. The magnitude of the force changes during the time-step. For instance, ode starts at t_0 and calculates F, integrates the equation and reaches time-step t_1 = t_0 + h, with h being the step-size. The magnitude of F at time, let's say, t = t_0 + h/2, is different, due to the displacement x, but the integration is based on F(t_0,x_0,dx_0). So does ode take care of this inexactness?

The ODE45 method takes care of this inexactness. For the calculation of a single time step, several intermediate values of the forces, velocities and accelerations are evaluated. The ODE uses two schemes to calculate a step with a 4th and 5th order method and if the results are greater than a certain absolute or relative limit, the step size is reduced.
But of course every single step integration method has a discretization error by dividing the time in a finite number of steps. Nevertheless, if you try to increase the accuracy by using a tiny step size for small discretization errors, the computer calculates a ridiculous number of steps and the global error will be dominated by the increasing accumulated rounding errors! So a so-called valid integration is a balance between the local discretization error and the loss of accuracy due to rounding.
To control the global error, you can vary the initial conditions by a small value and examine the difference of the results.

Kind regards, Jan
```
 0

```"Jan Simon" <matlab.THIS_YEAR@nMINUSsimon.de> wrote in message <ho8kh8\$nia\$1@fred.mathworks.com>...

>
> No, Runge-Kutta 45 uses the two different methods "4" and "5" to estimate the local error and control the step size. But it is not a predictor-corrector method, e.g. as an Adams-Bashforth-Moulten method.
>
> Kind regards, Jan

It seems you are right Jan. I stand corrected.

Bruno
```
 0

```I think ode does solve the problem properly.
Thanks a lot for your help.
Regards.
```
 0