objective.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_OBJECTIVE_HPP
#define ACADO_TOOLKIT_OBJECTIVE_HPP

#include <acado/objective/lagrange_term.hpp>
#include <acado/objective/lsq_term.hpp>
#include <acado/objective/lsq_end_term.hpp>
#include <acado/objective/mayer_term.hpp>
#include <acado/constraint/constraint.hpp>

BEGIN_NAMESPACE_ACADO

struct LsqData
{
        LsqData(const DMatrix& _WW, const Function& _hh, bool _givenW = true)
                : W( _WW ), h( _hh ), givenW( _givenW )
        {}

        DMatrix W;
        Function h;
        bool givenW;
};

typedef std::vector< LsqData > LsqElements;

struct LsqExternData
{
        LsqExternData(const DMatrix& _WW, const std::string& _hh, bool _givenW = true)
                : W( _WW ), h( _hh ), givenW( _givenW )
        {}

        DMatrix W;
        std::string h;
        bool givenW;
};

typedef std::vector< LsqExternData > LsqExternElements;

struct LsqLinearData
{
        LsqLinearData(const DVector& _Wlx, const DVector& _Wlu, bool _givenW = true)
                : Wlx( _Wlx ), Wlu( _Wlu ), givenW( _givenW )
        {}

        DMatrix Wlx, Wlu;
        bool givenW;
};

typedef std::vector< LsqLinearData > LsqLinearElements;

class Objective : public LagrangeTerm
{
    //
    // PUBLIC MEMBER FUNCTIONS:
    //
    public:

        Objective( );

        Objective( const Grid &grid_ );

        Objective( const Objective& rhs );

        virtual ~Objective( );

        Objective& operator=( const Objective& rhs );



        returnValue init( const Grid &grid_ );


// =======================================================================================
//
//                                    LOADING ROUTINES
//
// =======================================================================================


        inline returnValue addMayerTerm( const Expression& arg );
        inline returnValue addMayerTerm( const Function& arg );



        returnValue addLSQ( const MatrixVariablesGrid *S_,   
                            const Function&            h ,   
                            const VariablesGrid       *r_     );



        returnValue addLSQEndTerm( const DMatrix   & S,  
                                   const Function & m,  
                                   const DVector   & r    );

        //
        // Code generation related functions
        //

        returnValue addLSQ(const DMatrix& S, const Function& h);

        returnValue addLSQEndTerm(const DMatrix& S, const Function& h);

        returnValue addLSQ(const DMatrix& S, const std::string& h);

        returnValue addLSQEndTerm(const DMatrix& S, const std::string& h);

        returnValue addLSQ(const BMatrix& S, const Function& h);

        returnValue addLSQEndTerm(const BMatrix& S, const Function& h);

        returnValue addLSQ(const BMatrix& S, const std::string& h);

        returnValue addLSQEndTerm(const BMatrix& S, const std::string& h);

        returnValue addLSQLinearTerms(const DVector& Slx, const DVector& Slu);

        returnValue addLSQLinearTerms(const BVector& Slx, const BVector& Slu);

// =======================================================================================
//
//                                 INITIALIZATION ROUTINES
//
// =======================================================================================

        returnValue init( const int              nStages     ,
                          const int              nTransitions,
                          DifferentialEquation **fcn         ,
                          Transition            *transitions ,
                          Constraint            *constraint_   );


// =======================================================================================
//
//                                  DEFINITION OF SEEDS:
//
// =======================================================================================


    virtual returnValue setForwardSeed( BlockMatrix *xSeed_ ,   
                                        BlockMatrix *xaSeed_,   
                                        BlockMatrix *pSeed_ ,   
                                        BlockMatrix *uSeed_ ,   
                                        BlockMatrix *wSeed_ ,   
                                        int          order       );



    virtual returnValue setBackwardSeed( BlockMatrix *seed,    
                                         int          order      );



    virtual returnValue setUnitBackwardSeed( );



// =======================================================================================
//
//                                   EVALUATION ROUTINES
//
// =======================================================================================



        returnValue evaluate( const OCPiterate &x );



        returnValue evaluateSensitivities();


        returnValue evaluateSensitivities( BlockMatrix &hessian );


        returnValue evaluateSensitivitiesGN( BlockMatrix &hessian );




// =======================================================================================
//
//                               RESULTS OF THE EVALUATION
//
// =======================================================================================


    virtual returnValue getObjectiveValue( double &objectiveValue );



    virtual returnValue getForwardSensitivities( BlockMatrix &D  ,
                                                 int order         );



    virtual returnValue getBackwardSensitivities( BlockMatrix &D  ,
                                                  int order         );





// =======================================================================================
//
//                                     DIMENSIONS
//
// =======================================================================================


        inline int getNX    () const;

        inline int getNXA   () const;

        inline int getNP   () const;

        inline int getNU   () const;

        inline int getNW  () const;


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


        inline BooleanType hasLSQform();


        inline BooleanType isAffine();


        inline BooleanType isQuadratic();


        inline BooleanType isConvex();


        inline returnValue setReference( const VariablesGrid &ref );


        BooleanType isEmpty() const;

        returnValue getLSQTerms( LsqElements& _elements ) const;
        returnValue getLSQEndTerms( LsqElements& _elements ) const;

        returnValue getLSQTerms( LsqExternElements& _elements ) const;
        returnValue getLSQEndTerms( LsqExternElements& _elements ) const;

        returnValue getLSQLinearTerms( LsqLinearElements& _elements ) const;

        uint getNumMayerTerms( ) const;
        uint getNumLagrangeTerms( ) const;

        returnValue getMayerTerm( uint index, Function& mayerTerm ) const;
        returnValue getLagrangeTerm( uint index, Function& lagrangeTerm ) const;

    //
    // DATA MEMBERS:
    //
    protected:

    LSQTerm    **lsqTerm   ;   
    LSQEndTerm **lsqEndTerm;   
    MayerTerm  **mayerTerm ;   
    uint        nLSQ      ;   
    uint        nEndLSQ   ;   
    uint        nMayer    ;   
    LsqElements cgLsqElements;
    LsqElements cgLsqEndTermElements;

    LsqExternElements cgExternLsqElements;
    LsqExternElements cgExternLsqEndTermElements;

    LsqLinearElements cgLsqLinearElements;
};

CLOSE_NAMESPACE_ACADO

#include <acado/objective/objective.ipp>

#endif  // ACADO_TOOLKIT_OBJECTIVE_HPP

/*
 *    end of file
 */