OptConProblemBase.h

Go to the documentation of this file.

/**********************************************************************************************************************
This file is part of the Control Toolbox (https://github.com/ethz-adrl/control-toolbox), copyright by ETH Zurich.
Licensed under the BSD-2 license (see LICENSE file in main directory)
**********************************************************************************************************************/

#pragma once

#include <ct/optcon/constraint/LinearConstraintContainer.h>
#include <ct/optcon/costfunction/CostFunctionQuadratic.hpp>

namespace ct {
namespace optcon {


template <size_t STATE_DIM,
    size_t CONTROL_DIM,
    typename SYSTEM_T,
    typename LINEAR_SYSTEM_T,
    typename LINEARIZER_T,
    typename SCALAR = double>
class OptConProblemBase
{
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    static const size_t STATE_D = STATE_DIM;
    static const size_t CONTROL_D = CONTROL_DIM;

    // typedefs
    typedef ct::core::StateVector<STATE_DIM, SCALAR> state_vector_t;
    typedef std::shared_ptr<SYSTEM_T> DynamicsPtr_t;
    typedef std::shared_ptr<LINEAR_SYSTEM_T> LinearPtr_t;
    typedef std::shared_ptr<optcon::CostFunctionQuadratic<STATE_DIM, CONTROL_DIM, SCALAR>> CostFunctionPtr_t;
    typedef std::shared_ptr<optcon::LinearConstraintContainer<STATE_DIM, CONTROL_DIM, SCALAR>> ConstraintPtr_t;
    typedef typename SYSTEM_T::time_t time_t;

    OptConProblemBase() = default;

    OptConProblemBase(DynamicsPtr_t nonlinDynamics, CostFunctionPtr_t costFunction, LinearPtr_t linearSystem = nullptr);

    OptConProblemBase(const time_t tf,
        const state_vector_t& x0,
        DynamicsPtr_t nonlinDynamics,
        CostFunctionPtr_t costFunction,
        LinearPtr_t linearSystem = nullptr);

    OptConProblemBase(DynamicsPtr_t nonlinDynamics,
        CostFunctionPtr_t costFunction,
        ConstraintPtr_t inputBoxConstraints,
        ConstraintPtr_t stateBoxConstraints,
        ConstraintPtr_t generalConstraints,
        LinearPtr_t linearSystem = nullptr);

    OptConProblemBase(const time_t tf,
        const state_vector_t& x0,
        DynamicsPtr_t nonlinDynamics,
        CostFunctionPtr_t costFunction,
        ConstraintPtr_t inputBoxConstraints,
        ConstraintPtr_t stateBoxConstraints,
        ConstraintPtr_t generalConstraints,
        LinearPtr_t linearSystem = nullptr);

    void verify() const;

    const DynamicsPtr_t getNonlinearSystem() const;

    const LinearPtr_t getLinearSystem() const;

    const CostFunctionPtr_t getCostFunction() const;

    void setNonlinearSystem(const DynamicsPtr_t dyn);

    void setLinearSystem(const LinearPtr_t lin);

    void setCostFunction(const CostFunctionPtr_t cost);

    void setInputBoxConstraints(const ConstraintPtr_t constraint);

    void setStateBoxConstraints(const ConstraintPtr_t constraint);

    void setGeneralConstraints(const ConstraintPtr_t constraint);

    const ConstraintPtr_t getInputBoxConstraints() const;

    const ConstraintPtr_t getStateBoxConstraints() const;

    const ConstraintPtr_t getGeneralConstraints() const;

    const state_vector_t getInitialState() const;

    void setInitialState(const state_vector_t& x0);

    time_t getTimeHorizon() const;

    void setTimeHorizon(const time_t tf);


private:
    time_t tf_;  

    state_vector_t x0_;  

    DynamicsPtr_t controlledSystem_;  
    CostFunctionPtr_t costFunction_;  
    LinearPtr_t linearizedSystem_;    

    ConstraintPtr_t inputBoxConstraints_;

    ConstraintPtr_t stateBoxConstraints_;

    ConstraintPtr_t generalConstraints_;
};

}  // namespace optcon
}  // namespace ct