integrator.hpp

Go to the documentation of this file.

/*
 *    This file is part of ACADO Toolkit.
 *
 *    ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
 *    Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
 *    Milan Vukov, Rien Quirynen, KU Leuven.
 *    Developed within the Optimization in Engineering Center (OPTEC)
 *    under supervision of Moritz Diehl. All rights reserved.
 *
 *    ACADO Toolkit is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    ACADO Toolkit is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with ACADO Toolkit; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */



#ifndef ACADO_TOOLKIT_INTEGRATOR_HPP
#define ACADO_TOOLKIT_INTEGRATOR_HPP


#include <acado/utils/acado_utils.hpp>
#include <acado/user_interaction/algorithmic_base.hpp>
#include <acado/matrix_vector/matrix_vector.hpp>
#include <acado/variables_grid/variables_grid.hpp>
#include <acado/symbolic_expression/symbolic_expression.hpp>
#include <acado/function/function.hpp>

#include <acado/integrator/integrator_fwd.hpp>


BEGIN_NAMESPACE_ACADO


class Integrator : public AlgorithmicBase
{

        friend class SimulationByIntegration;
        friend class ShootingMethod;

        //
        // PUBLIC MEMBER FUNCTIONS:
        //
        public:


                Integrator( );

                Integrator( const Integrator &arg );

                virtual ~Integrator( );

                virtual Integrator* clone() const = 0;


        // ================================================================================


                virtual returnValue init( const DifferentialEquation &rhs ) = 0;



                returnValue init(       const DifferentialEquation &rhs,
                                                        const Transition           &trs
                                                        );


                returnValue setTransition(      const Transition &trs
                                                                        );



                // ================================================================================

                virtual returnValue freezeMesh() = 0;


                virtual returnValue freezeAll() = 0;


                virtual returnValue unfreeze() = 0;



                // ================================================================================

                returnValue integrate(  double t0        ,
                                                                double tend      ,
                                                                double *x0       ,
                                                                double *xa  = 0  ,
                                                                double *p   = 0  ,
                                                                double *u   = 0  ,
                                                                double *w   = 0    );



                returnValue integrate(  const Grid   &t          ,
                                                                double      *x0          ,
                                                                double      *xa  = 0     ,
                                                                double      *p   = 0     ,
                                                                double      *u   = 0     ,
                                                                double      *w   = 0       );



                returnValue integrate(  double       t0                  ,
                                                                double       tend                ,
                                                                const DVector &x0                 ,
                                                                const DVector &xa  = emptyVector  ,
                                                                const DVector &p   = emptyVector  ,
                                                                const DVector &u   = emptyVector  ,
                                                                const DVector &w   = emptyVector    );



                returnValue integrate(  const Grid   &t                  ,
                                                                const DVector &x0                 ,
                                                                const DVector &xa  = emptyVector  ,
                                                                const DVector &p   = emptyVector  ,
                                                                const DVector &u   = emptyVector  ,
                                                                const DVector &w   = emptyVector    );



                // ================================================================================


                returnValue setForwardSeed(     const int    &order                ,
                                                                        const DVector &xSeed                ,
                                                                        const DVector &pSeed = emptyVector  ,
                                                                        const DVector &uSeed = emptyVector  ,
                                                                        const DVector &wSeed = emptyVector    );



                // ================================================================================


                returnValue setBackwardSeed(    const int    &order ,
                                                                                const DVector &seed    );



                // ================================================================================

                virtual returnValue deleteAllSeeds();


                // ================================================================================


                returnValue integrateSensitivities( );



                virtual returnValue setDxInitialization( double *dx0   ) = 0;


                // ================================================================================


                inline  returnValue getX( DVector &xEnd ) const;


                inline  returnValue getXA( DVector &xaEnd ) const;



                inline  returnValue getX( VariablesGrid &X ) const;


                inline  returnValue getXA( VariablesGrid &XA ) const;


                inline  returnValue getI( VariablesGrid &I ) const;



                 returnValue getForwardSensitivities(   DVector &Dx,
                                                                                                int order ) const;


                returnValue getForwardSensitivities(    VariablesGrid &Dx,
                                                                                                int order ) const;


                returnValue getBackwardSensitivities(   DVector &Dx_x0,
                                                                                                DVector &Dx_p ,
                                                                                                DVector &Dx_u ,
                                                                                                DVector &Dx_w ,
                                                                                                int order      ) const;

                // ================================================================================




                virtual int getNumberOfSteps() const = 0;


                virtual int getNumberOfRejectedSteps() const = 0;



                virtual BooleanType canHandleImplicitSwitches( ) const;


                virtual BooleanType isDifferentialEquationDefined( ) const;     


                virtual BooleanType isDifferentialEquationAffine( ) const;

                virtual double getDifferentialEquationSampleTime() const;


                virtual double getStepSize() const = 0;


                virtual returnValue printRunTimeProfile() const;


                virtual returnValue evaluateSensitivities() = 0;


        //
        // PROTECTED MEMBER FUNCTIONS:
        //
        protected:

                virtual returnValue setupOptions( );


                // ================================================================================


                virtual returnValue evaluate( const DVector &x0    ,
                                                                        const DVector &xa    ,
                                                                        const DVector &p     ,
                                                                        const DVector &u     ,
                                                                        const DVector &w     ,
                                                                        const Grid   &t_      ) = 0;

                virtual returnValue evaluateTransition( const double time   ,
                                                                                                        DVector &xd    ,
                                                                                                const DVector &xa    ,
                                                                                                const DVector &p     ,
                                                                                                const DVector &u     ,
                                                                                                const DVector &w       );


                virtual returnValue diffTransitionForward(       DVector &DX,
                                                                                                const DVector &DP,
                                                                                                const DVector &DU,
                                                                                                const DVector &DW,
                                                                                                const int    &order );


                virtual returnValue diffTransitionBackward( DVector &DX,
                                                                                                        DVector &DP,
                                                                                                        DVector &DU,
                                                                                                        DVector &DW,
                                                                                                        int    &order );


                // ================================================================================


                virtual returnValue setProtectedForwardSeed( const DVector &xSeed     ,
                                                                                                        const DVector &pSeed     ,
                                                                                                        const DVector &uSeed     ,
                                                                                                        const DVector &wSeed     ,
                                                                                                        const int    &order      ) = 0;

                // ================================================================================


                virtual returnValue setProtectedBackwardSeed(  const DVector &seed    ,
                                                                                                        const int    &order     ) = 0;


                // ================================================================================



                virtual returnValue getProtectedX( DVector *xEnd  ) const = 0;


                virtual returnValue getProtectedForwardSensitivities( DMatrix *Dx  ,
                                                                                                                        int order    ) const = 0;


                virtual returnValue getProtectedBackwardSensitivities( DVector &Dx_x0,
                                                                                                                        DVector &Dx_p ,
                                                                                                                        DVector &Dx_u ,
                                                                                                                        DVector &Dx_w ,
                                                                                                                        int order      ) const = 0;


                // ================================================================================



                virtual int getDim() const = 0;


                virtual int getDimX() const;



                void initializeOptions();


                virtual returnValue setupLogging( );


        //
        // DATA MEMBERS:
        //
        protected:


                // DIFFERENTIAL ALGEBRAIC RHS:
                // ---------------------------
                DifferentialEquation *rhs    ;  
                short int             m      ;  
                short int             ma     ;  
                short int             mdx    ;  
                short int             mn     ;  
                short int             mu     ;  
                short int             mui    ;  
                short int             mp     ;  
                short int             mpi    ;  
                short int             mw     ;  
                short int             md     ;  
                // TRANSITION:
                // ---------------------------
                Transition        *transition;  
                // SETTINGS:
                // ---------
                double  *h                   ;  
                double   hini                ;  
                double   hmin                ;  
                double   hmax                ;  
                double   tune                ;  
                double   TOL                 ;  
                int      las                 ;  
                Grid     timeInterval        ;  
                // INTERNAL INDEX LISTS:
                // ---------------------
                int    *diff_index         ;  
                int    *ddiff_index        ;  
                int    *alg_index          ;  
                int    *control_index      ;  
                int    *parameter_index    ;  
                int    *int_control_index  ;  
                int    *int_parameter_index;  
                int    *disturbance_index  ;  
                int     time_index         ;  
                // OTHERS:
                // -------------------------
                int     maxNumberOfSteps   ;  
                int     count              ;  
                int     count2             ;  
                int     count3             ;  
                DVector  diff_scale         ;  
                // PRINT-LEVEL:
                // -------------------------
                int PrintLevel             ;  
                // SEED DIMENSIONS:
                // -------------------------
                int        nFDirs          ;  
                int        nBDirs          ;  
                int        nFDirs2         ;  
                int        nBDirs2         ;  
                // THE STATE OF AGGREGATION:
                // -------------------------
                StateOfAggregation soa     ;  
                // STATISTICS:
                // --------------------------
                RealClock totalTime         ;
                RealClock functionEvaluation;
                int       nFcnEvaluations   ;


                DVector                    xE;

                DVector                    dX;
                DVector                    dP;
                DVector                    dU;
                DVector                    dW;

                DVector                   dXb;
                DVector                   dPb;
                DVector                   dUb;
                DVector                   dWb;

                VariablesGrid         xStore;
                VariablesGrid        dxStore;
                VariablesGrid       ddxStore;
                VariablesGrid         iStore;


};


CLOSE_NAMESPACE_ACADO


#include <acado/integrator/integrator.ipp>


// collect all remaining headers of integrator directory
#include <acado/integrator/integrator_runge_kutta.hpp>
#include <acado/integrator/integrator_runge_kutta12.hpp>
#include <acado/integrator/integrator_runge_kutta23.hpp>
#include <acado/integrator/integrator_runge_kutta45.hpp>
#include <acado/integrator/integrator_runge_kutta78.hpp>
#include <acado/integrator/integrator_discretized_ode.hpp>
#include <acado/integrator/integrator_bdf.hpp>
#include <acado/integrator/integrator_lyapunov.hpp>
#include <acado/integrator/integrator_lyapunov45.hpp>


#endif  // ACADO_TOOLKIT_INTEGRATOR_HPP

// end of file.