integrator_lyapunov.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_LYAPUNOV_HPP
#define ACADO_TOOLKIT_INTEGRATOR_LYAPUNOV_HPP


#include <acado/integrator/integrator_fwd.hpp>


BEGIN_NAMESPACE_ACADO


class IntegratorLYAPUNOV : public Integrator{

//
// PUBLIC MEMBER FUNCTIONS:
//

public:

    IntegratorLYAPUNOV();

    IntegratorLYAPUNOV( int dim_, double power_ );

    IntegratorLYAPUNOV( const DifferentialEquation &rhs_, int dim_, double power_ );

    IntegratorLYAPUNOV( const IntegratorLYAPUNOV& arg );

    virtual ~IntegratorLYAPUNOV( );

    virtual IntegratorLYAPUNOV& operator=( const IntegratorLYAPUNOV& arg );

    virtual Integrator* clone() const = 0;



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


    virtual returnValue init( const DifferentialEquation &rhs_ );

    inline returnValue init( const DifferentialEquation &rhs_,
                             const Transition           &trs_ );


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

    virtual returnValue freezeMesh();


    virtual returnValue freezeAll();


    virtual returnValue unfreeze();



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

    virtual returnValue step(   int number  
                                                                );


    virtual returnValue stop();


    virtual returnValue setDxInitialization( double *dx0   );

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


    virtual int getNumberOfSteps() const;


    virtual int getNumberOfRejectedSteps() const;


    virtual double getStepSize() const;


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


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



    virtual returnValue evaluateSensitivities();



    virtual int getDim() const;



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


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


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


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

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


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


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


    virtual returnValue getProtectedX(           DVector *xEnd  ) const;


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



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



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


    void deleteAll();


    void constructAll( const IntegratorLYAPUNOV& arg );



    void allocateMemory( );


    void initializeVariables();


    virtual void initializeButcherTableau() = 0;


    double determineEta45();


    double determineEta45( int number );


    void determineEtaGForward( int number );


    void determineEtaGForward2( int number );


    void determineEtaHBackward( int number );


    void determineEtaHBackward2( int number );


    void printIntermediateResults();



    returnValue setForwardSeed2( const DVector &xSeed          ,
                                 const DVector &pSeed          ,
                                 const DVector &uSeed          ,
                                 const DVector &wSeed          );


    virtual returnValue setBackwardSeed2( const DVector &seed      );



    void interpolate( int jj, double *e1, double *d1, double *e2, VariablesGrid &poly );


        void logCurrentIntegratorStep(  const DVector& currentX  = emptyConstVector
                                                                        );


// DATA MEMBERS:
//
protected:


    // BUTCHER-
    // TABLEAU:
    // ----------
    int      dim               ;  
    double **A                 ;  
    double  *b4                ;  
    double  *b5                ;  
    double  *c                 ;  
    // RK-ALGORITHM:
    // -------------
    double  *eta4              ;  
    double  *eta5              ;  
    double  *eta4_             ;  
    double  *eta5_             ;  
    double **k                 ;  
    double **k2                ;  
    double **l                 ;  
    double **l2                ;  
    double   t                 ;  
    double  *x                 ;  
    double   err_power         ;  
    // SENSITIVITIES:
    // --------------
    DVector     fseed           ;  
    DVector     bseed           ;  
    DVector     fseed2          ;  
    DVector     bseed2          ;  
    double    *G               ;  
    double    *etaG            ;  
    double    *G2              ;  
    double    *G3              ;  
    double    *etaG2           ;  
    double    *etaG3           ;  
    double    *H               ;  
    double    *etaH            ;  
    double    *H2              ;  
    double    *H3              ;  
    double    *etaH2           ;  
    double    *etaH3           ;  
    // STORAGE:
    // --------
    int maxAlloc                ;  
  // Original ODE
  int dimxmy                    ; /* dimension  of  the  original ODE*/
  int dimu                    ; /* dimension  of  the  control*/
  int dimp                    ; /* dimension  of  the  parameters*/
  int dimw                    ; /* dimension  of  the  disturbances*/
 
  // Sensitivities
  double **Y                  ;  /* sensitivity matrix  */    

  double *seedmy              ; /* Seed vector */
  Lyapunov lyap;
};


CLOSE_NAMESPACE_ACADO


#include <acado/integrator/integrator_lyapunov.ipp>


#endif  // ACADO_TOOLKIT_INTEGRATOR_RUNGE_KUTTA_HPP

// end of file.