Limitations of RIOTS versions 1.0
=================================
This is the first version of RIOTS_95. As it stands, there are a few
significant limitations on the type of problems which can be
effectively solved by RIOTS_95. Below are listed the most significant
such limitations. Some of these can be circumvented by clever problem
modifications.
(1) Problems with inequality state constraints that require a very
high level of discretization (e.g. N = 1000) cannot be solved by
RIOTS_95. Also, the computation of gradients for trajectory
constraints is not handled as efficiently as it could be.
(2) Problems that have highly unstable, nonlinear dynamics may require
a very good initial guess for the solution in order to be solved by
RIOTS_95. Alternatively, you may wish to attempt to find a stabiizing
feedback controller and incorporate that into the problem statement.
(3) General constraints on the controls that do not involve state
variables are not handled efficiently: adjoints are computed but not
used. Simple control bounds are handled _much_ more efficiently.
(4) RIOTS_95 does not allow delays in the systems dynamics (although
Pade approximations can be used).
(5) Numerical methods for solving optimal control problems have not
reached the stage that, say, methods for solving differential
equations have reached. Solving an optimal control problem can,
depending on the difficulty of the problem, require significant user
involvement in the solution process. This sometimes requires the user
to understand the theory of optimal control, optimization and/or
numerical approximation methods.
Some Hints on Solving Difficult Problems
========================================
(1) Always check your problem derivatives using the 'check_deriv()'
command.
(2) Difficult problems can often be transcribed into simpler ones.
For instance, some problems with trajectory constraints are solved
much more efficiently if the trajectory constraints are converted into
equivalent endpoint constraints. This procedure is described in
Section 1 of the RIOTS_95 User's Manual.
(3) For problem with nonlinear, unstable and/or stiff dynamics, it may be
better to use LSODA rather than one of the fixed step-size integration
routines. Also, it may be helpful to solve the problem on a smaller
time horizon and use that solution as a starting point for the same
problem with the time horizon increased. In this way, you can build
up to a solution across the total time horizon.
(4) If the control appears in the state equations in the form f(x)*u,
it can be helpful to make the substition v=f(x)*u. Don't do this,
however, if the original problem has control bounds because control
bounds on u(t) will become general constraints on v(t).
(5) If your problem has many state contraints, try solving the problem
with a reduced set of constraints first. Then see which constraints
are violated and add those constraints back into the problem. This is
easily done just by changing the intialization values of neq[] in your
problem description.
(6) If you know that the optimal control for you problem is pretty
smooth and your problem has difficult dynamics, use LSODA with a low
number of control breakpoints rather than using on of the fixed
step-size integration routines. Note, though, that the fixed
step-size routines are usually much faster and can produce solutions
that are as accurate or more accurate than LSODA.
(7) The convergence theory for RIOTS requires that the functions
describing the optimal control problem have at least one continuous
derivative. In practice, however, it is not always convenient to
formulate problems this way. Often, RIOTS will produce solutions even
if system functions are only piecewise differentiable. In any case,
it doesn't hurt to try and see what happens.
(8) For some problems it can be expedient to formulate system dynamics
with functions that are 'flat' with respect to the controls in certain
regions of the state-space (i.e. the derivative w.r.t. u is zero). If
this is the case, the initial guess for the control, u0(t), must be
chosen to avoid such flat spots or else the optimization procedure
will have no idea which direction to head. Thus, the optimization
program will terminate without making any progress.