control-base.hpp

// BSD 3-Clause License
//
// Copyright (C) 2021, University of Edinburgh, University of Trento
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
 
#ifndef CROCODDYL_CORE_CONTROL_BASE_HPP_
#define CROCODDYL_CORE_CONTROL_BASE_HPP_
 
#include <boost/shared_ptr.hpp>
 
#include "crocoddyl/core/fwd.hpp"
#include "crocoddyl/core/mathbase.hpp"
#include "crocoddyl/core/utils/exception.hpp"
 
namespace crocoddyl {
 
template <typename _Scalar>
class ControlParametrizationModelAbstractTpl {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ControlParametrizationDataAbstractTpl<Scalar> ControlParametrizationDataAbstract;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  ControlParametrizationModelAbstractTpl(const std::size_t nw, const std::size_t nu);
  virtual ~ControlParametrizationModelAbstractTpl();
 
  virtual void calc(const boost::shared_ptr<ControlParametrizationDataAbstract>& data, const Scalar t,
                    const Eigen::Ref<const VectorXs>& u) const = 0;
 
  virtual void calcDiff(const boost::shared_ptr<ControlParametrizationDataAbstract>& data, const Scalar t,
                        const Eigen::Ref<const VectorXs>& u) const = 0;
 
  virtual boost::shared_ptr<ControlParametrizationDataAbstract> createData();
 
  virtual void params(const boost::shared_ptr<ControlParametrizationDataAbstract>& data, const Scalar t,
                      const Eigen::Ref<const VectorXs>& w) const = 0;
 
  virtual void convertBounds(const Eigen::Ref<const VectorXs>& w_lb, const Eigen::Ref<const VectorXs>& w_ub,
                             Eigen::Ref<VectorXs> u_lb, Eigen::Ref<VectorXs> u_ub) const = 0;
 
  virtual void multiplyByJacobian(const boost::shared_ptr<ControlParametrizationDataAbstract>& data,
                                  const Eigen::Ref<const MatrixXs>& A, Eigen::Ref<MatrixXs> out,
                                  const AssignmentOp = setto) const = 0;
 
  virtual MatrixXs multiplyByJacobian_J(const boost::shared_ptr<ControlParametrizationDataAbstract>& data,
                                        const Eigen::Ref<const MatrixXs>& A, const AssignmentOp = setto) const;
 
  virtual void multiplyJacobianTransposeBy(const boost::shared_ptr<ControlParametrizationDataAbstract>& data,
                                           const Eigen::Ref<const MatrixXs>& A, Eigen::Ref<MatrixXs> out,
                                           const AssignmentOp = setto) const = 0;
 
  virtual MatrixXs multiplyJacobianTransposeBy_J(const boost::shared_ptr<ControlParametrizationDataAbstract>& data,
                                                 const Eigen::Ref<const MatrixXs>& A,
                                                 const AssignmentOp = setto) const;
 
  virtual bool checkData(const boost::shared_ptr<ControlParametrizationDataAbstract>& data);
 
  std::size_t get_nw() const;
 
  std::size_t get_nu() const;
 
 protected:
  std::size_t nw_;  
  std::size_t nu_;  
};
 
template <typename _Scalar>
struct ControlParametrizationDataAbstractTpl {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  template <template <typename Scalar> class Model>
  explicit ControlParametrizationDataAbstractTpl(Model<Scalar>* const model)
      : w(model->get_nw()), u(model->get_nu()), dw_du(model->get_nw(), model->get_nu()) {
    w.setZero();
    u.setZero();
    dw_du.setZero();
  }
  virtual ~ControlParametrizationDataAbstractTpl() {}
 
  VectorXs w;      
  VectorXs u;      
  MatrixXs dw_du;  
};
 
}  // namespace crocoddyl
 
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include "crocoddyl/core/control-base.hxx"
 
#endif  // CROCODDYL_CORE_CONTROL_BASE_HPP_