Algorithmic Options and Numerical Accuracy

In the previous tutorials we have only used the optimization algorithms with its default settings. For optimal control problems these default settings are usually a multiple-shooting SQP type method combined with a standard Runge-Kutta integrator for the state integration. This tutorial describes how to overwrite the default settings and how to specialize the algorithm for our problems regarding both the method and its numerical accuracy settings.

A tutorial code with algorithmic options

Let us directly start with an example on how to set some options for the simple rocket optimization problem from the first tutorial:

#include <acado_optimal_control.hpp>
#include <include/acado_gnuplot/gnuplot_window.hpp>

int main( )
{
        USING_NAMESPACE_ACADO

        DifferentialState        s,v,m      ;   // the differential states
        Control                  u          ;   // the control input u
        Parameter                T          ;   // the time horizon T
        DifferentialEquation     f( 0.0, T );   // the differential equation

        //  -------------------------------------
        OCP ocp( 0.0, T, 50 )               ;   // time horizon of the OCP: [0,T]
                                                                                        // use 50 control intervals
        ocp.minimizeMayerTerm( T )          ;   // the time T should be optimized

        f << dot(s) == v                    ;   // an implementation
        f << dot(v) == (u-0.2*v*v)/m        ;   // of the model equations
        f << dot(m) == -0.01*u*u            ;   // for the rocket.

        ocp.subjectTo( f                   );   // minimize T s.t. the model,
        ocp.subjectTo( AT_START, s ==  0.0 );   // the initial values for s,
        ocp.subjectTo( AT_START, v ==  0.0 );   // v,
        ocp.subjectTo( AT_START, m ==  1.0 );   // and m,

        ocp.subjectTo( AT_END  , s == 10.0 );   // the terminal constraints for s
        ocp.subjectTo( AT_END  , v ==  0.0 );   // and v,

        ocp.subjectTo( -0.1 <= v <=  1.7   );   // as well as the bounds on v
        ocp.subjectTo( -1.1 <= u <=  1.1   );   // the control input u,
        ocp.subjectTo(  5.0 <= T <= 15.0   );   // and the time horizon T.
        //  -------------------------------------

        OptimizationAlgorithm algorithm(ocp);   // construct optimization algorithm,

        algorithm.set( INTEGRATOR_TYPE      , INT_RK78        );
        algorithm.set( INTEGRATOR_TOLERANCE , 1e-8            );
        algorithm.set( DISCRETIZATION_TYPE  , SINGLE_SHOOTING );
        algorithm.set( KKT_TOLERANCE        , 1e-4            );

        algorithm.solve()                   ;   // and solve the problem.

        return 0                            ;
}

The options which have been set in this example are first the integrator type: now, the Runge-Kutta integrator with order (7/8) will be used (instead of a Runge Kutta integrator with order 4/5, which is the default choice). In addition, the integrator tolerance has been set, while single shooting is used instead of the multiple shooting method, which would be the default choice. Finally, the KKT tolerance, which is used for the convergence criterion of the SQP algorithm, has been set to 1e-4 . Here, 1e-6 would have been the default choice.

Note that all options can be set on the optimization algorithm by using the syntax

set( <Option Name>, <Option Value> ).

An important exception are the number of control intervals which are specified in the constructor of the OCP following the definition of the time interval.

A brief overview of the most common options for optimal control with ACADO Toolkit

Option Name: Option Value: Short Description:
MAX_NUM_ITERATIONS int maximum number of SQP iterations
(maxNumIterations = 0: only simulation)
KKT_TOLERANCE double termination tolerance for the optimal control algorithm
HESSIAN_APPROXIMATION CONSTANT_HESSIAN
FULL_BFGS_UPDATE
BLOCK_BFGS_UPDATE
GAUSS_NEWTON
EXACT_HESSIAN
constant hessian (generalized gradient method)
BFGS update of the whole hessian
structure exploiting BFGS update (default)
Gauss-Newton Hessian approximation (only for LSQ)
Exact Hessians
DISCRETIZATION_TYPE SINGLE_SHOOTING
MULTIPLE_SHOOTING
COLLOCATION
single shooting discretization
multiple shooting discretization (default)
collocation (will be implemented soon)
INTEGRATOR_TYPE INT_RK12
INT_RK23
INT_RK45
INT_RK78
INT_BDF
Runge Kutta integrator (adaptive Euler method)
Runge Kutta integrator (order 2/3, RKF )
Runge Kutta integrator (order 4/5, Dormand Prince)
Runge Kutta integrator (order 7/8, Dormand Prince)
BDF (backward differentiation formula) integrator
INTEGRATOR_TOLERANCE double the relative tolerance of the integrator
ABSOLUTE_TOLERANCE double the absolute tolerance of the integrator ("ATOL")
MAX_NUM_INTEGRATOR_STEPS int maximum number of integrator steps
LEVENBERG_MARQUARDT double value for Levenberg-Marquardt regularization
MIN_LINESEARCH_PARAMETER double minimum stepsize of the line-search globalization

Next example: Storing the Results of Optimization Algorithms



acado
Author(s): Milan Vukov, Rien Quirynen
autogenerated on Sat Jun 8 2019 19:40:23