constraint.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_CONSTRAINT_HPP
#define ACADO_TOOLKIT_CONSTRAINT_HPP

#include <acado/constraint/box_constraint.hpp>
#include <acado/constraint/boundary_constraint.hpp>
#include <acado/constraint/coupled_path_constraint.hpp>
#include <acado/constraint/path_constraint.hpp>
#include <acado/constraint/algebraic_consistency_constraint.hpp>
#include <acado/constraint/point_constraint.hpp>


BEGIN_NAMESPACE_ACADO


class Constraint : public BoxConstraint{

        friend class OptimizationAlgorithmBase;
        friend class OptimizationAlgorithm;
        friend class RealTimeAlgorithm;
        friend class TESTExport;
        friend class ExportNLPSolver;

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

        Constraint( );

        Constraint( const Constraint& rhs );

        virtual ~Constraint( );

        Constraint& operator=( const Constraint& rhs );


        returnValue init( const Grid& grid_, const int& numberOfStages_ = 1 );


        // ===========================================================================
        //
        //                          CONTINOUS CONSTRAINTS
        //                       --------------------------
        //
        //
        //     (general form  lb(i) <= h( t,x(i),u(i),p,... ) <= ub(i)  for all i)
        //
        // ===========================================================================


        returnValue add( const double lb_, const Expression& arg, const double ub_  );


        returnValue add( const DVector lb_, const Expression& arg, const double ub_  );


        returnValue add( const double lb_, const Expression& arg, const DVector ub_  );


        returnValue add( const DVector lb_, const Expression& arg, const DVector ub_  );


        // ===========================================================================
        //
        //                           DISCRETE CONSTRAINTS
        //                       --------------------------
        //
        //
        //   (general form  lb(i) <= h( t,x(i),u(i),p,... ) <= ub(i)  for a given i)
        //
        // ===========================================================================


        returnValue add( const int index_, const double lb_, const Expression& arg, const double ub_  );


        // ===========================================================================
        //
        //                       COUPLED BOUNDARY CONSTRAINTS
        //                       ----------------------------
        //
        //
        //   (general form  lb <=   h_1( t_0,x(t_0),u(t_0),p,... )
        //                        + h_2( t_e,x(t_e),u(t_e),p,... ) <= ub(i)  )
        //
        //    where t_0 is the first and t_e the last time point in the grid.
        //
        // ===========================================================================

        returnValue add( const double lb_, const Expression& arg1,
                                const Expression& arg2, const double ub_ );



        // ===========================================================================
        //
        //                         GENERAL COUPLED CONSTRAINTS
        //                       -------------------------------
        //
        //
        //   (general form  lb <= sum_i  h_i( t_i,x(t_i),u(t_i),p,... ) <= ub(i)  )
        //
        //
        // ===========================================================================

        returnValue add( const double lb_, const Expression *arguments, const double ub_ );




        // ===========================================================================
        //
        //                        ALGEBRAIC CONSISTENCY CONSTRAINTS
        //                       -----------------------------------
        //
        // ===========================================================================

        returnValue add( const uint&                 endOfStage_  ,  
                                const DifferentialEquation& dae              );



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


        returnValue add( const ConstraintComponent& component );


        returnValue add( const int index_, const ConstraintComponent& component );




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


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


    virtual returnValue setUnitForwardSeed( );



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



    virtual returnValue setUnitBackwardSeed( );



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



        returnValue evaluate( const OCPiterate& iter );




        returnValue evaluateSensitivities();


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




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


    virtual returnValue getConstraintResiduum( BlockMatrix &lowerRes, 
                                               BlockMatrix &upperRes   );


    virtual returnValue getBoundResiduum( BlockMatrix &lowerRes, 
                                          BlockMatrix &upperRes   );



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



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





//  =========================================================================
//
//                               MISCELLANEOUS:
//
//  =========================================================================

        inline Grid& getGrid();

        inline int getNC();

        inline int getNX    () const;

        inline int getNXA   () const;

        inline int getNP   () const;

        inline int getNU   () const;

        inline int getNW  () const;


        inline int getNumberOfBlocks() const;


        inline int getBlockDim( int idx ) const;

        inline DVector getBlockDims( ) const;



        inline BooleanType isAffine() const;

                inline BooleanType isBoxConstraint() const;

        BooleanType isEmpty() const;

        returnValue getPathConstraints(Function& function_, DMatrix& lb_, DMatrix& ub_) const;

        returnValue getPointConstraint(const unsigned index, Function& function_, DMatrix& lb_, DMatrix& ub_) const;

    //
    // DATA MEMBERS:
    //
    protected:


        BoundaryConstraint              *boundary_constraint             ;
        CoupledPathConstraint           *coupled_path_constraint         ;
        PathConstraint                  *path_constraint                 ;
        AlgebraicConsistencyConstraint  *algebraic_consistency_constraint;
        PointConstraint                **point_constraints               ;


    // PROTECTED MEMBER FUNCTIONS:
    // ---------------------------

    protected:

        returnValue add( const int index_, const double lb_, Expression* arg, const double ub_  );
                
        returnValue add( const DVector lb_, Expression* arg, const DVector ub_  );


        virtual returnValue getBounds( const OCPiterate& iter );

        void deleteAll();

};


CLOSE_NAMESPACE_ACADO



#include <acado/constraint/constraint.ipp>


#endif  // ACADO_TOOLKIT_CONSTRAINT_HPP

/*
 *    end of file
 */