integration_algorithm.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_INTEGRATION_ALGORITHM_HPP
#define ACADO_TOOLKIT_INTEGRATION_ALGORITHM_HPP


#include <acado/utils/acado_utils.hpp>
#include <acado/user_interaction/user_interaction.hpp>
#include <acado/dynamic_discretization/shooting_method.hpp>


BEGIN_NAMESPACE_ACADO


class IntegrationAlgorithm : public UserInteraction
{
        //
        // PUBLIC MEMBER FUNCTIONS:
        //
        public:

                IntegrationAlgorithm( );

                IntegrationAlgorithm( const IntegrationAlgorithm& rhs );

                virtual ~IntegrationAlgorithm( );

                IntegrationAlgorithm& operator=( const IntegrationAlgorithm& rhs );


        virtual returnValue addStage( const DynamicSystem  &dynamicSystem_,
                                      const Grid           &stageIntervals,
                                      const IntegratorType &integratorType_ = INT_UNKNOWN );

                virtual returnValue addTransition( const Transition& transition_ );


        virtual returnValue clear();


                returnValue evaluate(   VariablesGrid  *x ,      
                                                                VariablesGrid  *xa,      
                                                                VariablesGrid  *p ,      
                                                                VariablesGrid  *u ,      
                                                                VariablesGrid  *w        
                                                                );

                returnValue evaluate(   OCPiterate& _iter );

                returnValue integrate(  VariablesGrid  *x ,      
                                                                VariablesGrid  *xa,      
                                                                VariablesGrid  *p ,      
                                                                VariablesGrid  *u ,      
                                                                VariablesGrid  *w        
                                                                );


                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 BlockMatrix &xSeed_,   
                                                                        const BlockMatrix &pSeed_ = emptyBlockMatrix,   
                                                                        const BlockMatrix &uSeed_ = emptyBlockMatrix,   
                                                                        const BlockMatrix &wSeed_ = emptyBlockMatrix     );

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


                returnValue setUnitForwardSeed();



                returnValue setBackwardSeed( const BlockMatrix &seed     );

                returnValue setBackwardSeed(    const DVector &seed    );

                returnValue setUnitBackwardSeed();



                returnValue deleteAllSeeds();


                returnValue evaluateSensitivities( );

                returnValue integrateSensitivities( );

                returnValue evaluateSensitivities(      const BlockMatrix &seed,
                                                                                        BlockMatrix &hessian
                                                                                        );

                returnValue integrateSensitivities(     const BlockMatrix &seed,
                                                                                        BlockMatrix &hessian
                                                                                        );


                returnValue unfreeze( );


                BooleanType isAffine( ) const;


                returnValue getX(       DVector& xEnd
                                                        ) const;

                returnValue getXA(      DVector& xaEnd
                                                        ) const;

                returnValue getX(       VariablesGrid& X
                                                        ) const;


                returnValue getXA(      VariablesGrid& XA
                                                        ) const;


                returnValue getForwardSensitivities(    BlockMatrix &D  
                                                                                                ) const;

                 returnValue getForwardSensitivities(   DVector &Dx
                                                                                                ) const;


                returnValue getBackwardSensitivities(   BlockMatrix &D  
                                                                                                ) const;

                returnValue getBackwardSensitivities(   DVector &Dx_x0,
                                                                                                DVector &Dx_p = emptyVector,
                                                                                                DVector &Dx_u = emptyVector,
                                                                                                DVector &Dx_w = emptyVector
                                                                                                ) const;



    //
    // PROTECTED MEMBER FUNCTIONS:
    //

    protected:

                virtual returnValue setupOptions( );
                virtual returnValue setupLogging( );


    //
    // PROTECTED MEMBERS:
    //

    protected:

        ShootingMethod* integrationMethod;
                OCPiterate              iter;
};


CLOSE_NAMESPACE_ACADO


//#include <acado/dynamic_discretization/integration_algorithm.ipp>


#endif  // ACADO_TOOLKIT_INTEGRATION_ALGORITHM_HPP

// end of file