free-invdyn.hpp

 
// BSD 3-Clause License
//
// Copyright (C) 2021-2024, Heriot-Watt University, University of Edinburgh
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
 
#ifndef CROCODDYL_MULTIBODY_ACTIONS_FREE_INVDYN_HPP_
#define CROCODDYL_MULTIBODY_ACTIONS_FREE_INVDYN_HPP_
 
#include <stdexcept>
 
#include "crocoddyl/core/actuation-base.hpp"
#include "crocoddyl/core/constraints/constraint-manager.hpp"
#include "crocoddyl/core/costs/cost-sum.hpp"
#include "crocoddyl/core/diff-action-base.hpp"
#include "crocoddyl/core/residual-base.hpp"
#include "crocoddyl/core/utils/exception.hpp"
#include "crocoddyl/multibody/data/multibody.hpp"
#include "crocoddyl/multibody/fwd.hpp"
#include "crocoddyl/multibody/states/multibody.hpp"
 
namespace crocoddyl {
 
template <typename _Scalar>
class DifferentialActionModelFreeInvDynamicsTpl
    : public DifferentialActionModelAbstractTpl<_Scalar> {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef DifferentialActionModelAbstractTpl<Scalar> Base;
  typedef DifferentialActionDataFreeInvDynamicsTpl<Scalar> Data;
  typedef DifferentialActionDataAbstractTpl<Scalar>
      DifferentialActionDataAbstract;
  typedef CostModelSumTpl<Scalar> CostModelSum;
  typedef ConstraintModelManagerTpl<Scalar> ConstraintModelManager;
  typedef StateMultibodyTpl<Scalar> StateMultibody;
  typedef ActuationModelAbstractTpl<Scalar> ActuationModelAbstract;
  typedef ConstraintModelResidualTpl<Scalar> ConstraintModelResidual;
  typedef typename MathBase::VectorXs VectorXs;
 
  DifferentialActionModelFreeInvDynamicsTpl(
      std::shared_ptr<StateMultibody> state,
      std::shared_ptr<ActuationModelAbstract> actuation,
      std::shared_ptr<CostModelSum> costs);
 
  DifferentialActionModelFreeInvDynamicsTpl(
      std::shared_ptr<StateMultibody> state,
      std::shared_ptr<ActuationModelAbstract> actuation,
      std::shared_ptr<CostModelSum> costs,
      std::shared_ptr<ConstraintModelManager> constraints);
  virtual ~DifferentialActionModelFreeInvDynamicsTpl();
 
  virtual void calc(const std::shared_ptr<DifferentialActionDataAbstract>& data,
                    const Eigen::Ref<const VectorXs>& x,
                    const Eigen::Ref<const VectorXs>& u);
 
  virtual void calc(const std::shared_ptr<DifferentialActionDataAbstract>& data,
                    const Eigen::Ref<const VectorXs>& x);
 
  virtual void calcDiff(
      const std::shared_ptr<DifferentialActionDataAbstract>& data,
      const Eigen::Ref<const VectorXs>& x, const Eigen::Ref<const VectorXs>& u);
 
  virtual void calcDiff(
      const std::shared_ptr<DifferentialActionDataAbstract>& data,
      const Eigen::Ref<const VectorXs>& x);
 
  virtual std::shared_ptr<DifferentialActionDataAbstract> createData();
 
  virtual bool checkData(
      const std::shared_ptr<DifferentialActionDataAbstract>& data);
 
  virtual void quasiStatic(
      const std::shared_ptr<DifferentialActionDataAbstract>& data,
      Eigen::Ref<VectorXs> u, const Eigen::Ref<const VectorXs>& x,
      const std::size_t maxiter = 100, const Scalar tol = Scalar(1e-9));
 
  virtual std::size_t get_ng() const;
 
  virtual std::size_t get_nh() const;
 
  virtual std::size_t get_ng_T() const;
 
  virtual std::size_t get_nh_T() const;
 
  virtual const VectorXs& get_g_lb() const;
 
  virtual const VectorXs& get_g_ub() const;
 
  const std::shared_ptr<ActuationModelAbstract>& get_actuation() const;
 
  const std::shared_ptr<CostModelSum>& get_costs() const;
 
  const std::shared_ptr<ConstraintModelManager>& get_constraints() const;
 
  pinocchio::ModelTpl<Scalar>& get_pinocchio() const;
 
  virtual void print(std::ostream& os) const;
 
 protected:
  using Base::g_lb_;   
  using Base::g_ub_;   
  using Base::ng_;     
  using Base::nh_;     
  using Base::nu_;     
  using Base::state_;  
 
 private:
  void init(const std::shared_ptr<StateMultibody>& state);
  std::shared_ptr<ActuationModelAbstract> actuation_;    
  std::shared_ptr<CostModelSum> costs_;                  
  std::shared_ptr<ConstraintModelManager> constraints_;  
  pinocchio::ModelTpl<Scalar>& pinocchio_;               
 
 public:
  class ResidualModelActuation : public ResidualModelAbstractTpl<_Scalar> {
   public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    typedef _Scalar Scalar;
    typedef MathBaseTpl<Scalar> MathBase;
    typedef ResidualModelAbstractTpl<Scalar> Base;
    typedef StateMultibodyTpl<Scalar> StateMultibody;
    typedef ResidualDataAbstractTpl<Scalar> ResidualDataAbstract;
    typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
    typedef ActuationModelAbstractTpl<Scalar> ActuationModelAbstract;
    typedef typename MathBase::VectorXs VectorXs;
    typedef typename MathBase::MatrixXs MatrixXs;
 
    ResidualModelActuation(std::shared_ptr<StateMultibody> state,
                           const std::size_t nu)
        : Base(state, state->get_nv() - nu, state->get_nv(), true, true, true),
          na_(nu) {}
    virtual ~ResidualModelActuation() {}
 
    virtual void calc(const std::shared_ptr<ResidualDataAbstract>& data,
                      const Eigen::Ref<const VectorXs>&,
                      const Eigen::Ref<const VectorXs>&) {
      typename Data::ResidualDataActuation* d =
          static_cast<typename Data::ResidualDataActuation*>(data.get());
      // Update the under-actuation set and residual
      std::size_t nrow = 0;
      for (std::size_t k = 0;
           k < static_cast<std::size_t>(d->actuation->tau_set.size()); ++k) {
        if (!d->actuation->tau_set[k]) {
          data->r(nrow) = d->pinocchio->tau(k);
          nrow += 1;
        }
      }
    }
 
    virtual void calc(const std::shared_ptr<ResidualDataAbstract>& data,
                      const Eigen::Ref<const VectorXs>&) {
      data->r.setZero();
    }
 
    virtual void calcDiff(const std::shared_ptr<ResidualDataAbstract>& data,
                          const Eigen::Ref<const VectorXs>&,
                          const Eigen::Ref<const VectorXs>&) {
      typename Data::ResidualDataActuation* d =
          static_cast<typename Data::ResidualDataActuation*>(data.get());
      std::size_t nrow = 0;
      const std::size_t nv = state_->get_nv();
      d->dtau_dx.leftCols(nv) = d->pinocchio->dtau_dq;
      d->dtau_dx.rightCols(nv) = d->pinocchio->dtau_dv;
      d->dtau_dx -= d->actuation->dtau_dx;
      for (std::size_t k = 0;
           k < static_cast<std::size_t>(d->actuation->tau_set.size()); ++k) {
        if (!d->actuation->tau_set[k]) {
          d->Rx.row(nrow) = d->dtau_dx.row(k);
          d->Ru.row(nrow) = d->pinocchio->M.row(k);
          nrow += 1;
        }
      }
    }
 
    virtual void calcDiff(const std::shared_ptr<ResidualDataAbstract>& data,
                          const Eigen::Ref<const VectorXs>&) {
      data->Rx.setZero();
      data->Ru.setZero();
    }
 
    virtual std::shared_ptr<ResidualDataAbstract> createData(
        DataCollectorAbstract* const data) {
      return std::allocate_shared<typename Data::ResidualDataActuation>(
          Eigen::aligned_allocator<typename Data::ResidualDataActuation>(),
          this, data);
    }
 
    virtual void print(std::ostream& os) const {
      os << "ResidualModelActuation {nx=" << state_->get_nx()
         << ", ndx=" << state_->get_ndx() << ", nu=" << nu_ << ", na=" << na_
         << "}";
    }
 
   protected:
    std::size_t na_;  
    using Base::nu_;
    using Base::state_;
  };
};
 
template <typename _Scalar>
struct DifferentialActionDataFreeInvDynamicsTpl
    : public DifferentialActionDataAbstractTpl<_Scalar> {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef DifferentialActionDataAbstractTpl<Scalar> Base;
  typedef JointDataAbstractTpl<Scalar> JointDataAbstract;
  typedef DataCollectorJointActMultibodyTpl<Scalar>
      DataCollectorJointActMultibody;
  typedef CostDataSumTpl<Scalar> CostDataSum;
  typedef ConstraintDataManagerTpl<Scalar> ConstraintDataManager;
  typedef typename MathBase::VectorXs VectorXs;
 
  template <template <typename Scalar> class Model>
  explicit DifferentialActionDataFreeInvDynamicsTpl(Model<Scalar>* const model)
      : Base(model),
        pinocchio(pinocchio::DataTpl<Scalar>(model->get_pinocchio())),
        multibody(
            &pinocchio, model->get_actuation()->createData(),
            std::make_shared<JointDataAbstract>(
                model->get_state(), model->get_actuation(), model->get_nu())),
        costs(model->get_costs()->createData(&multibody)),
        constraints(model->get_constraints()->createData(&multibody)),
        tmp_xstatic(model->get_state()->get_nx()) {
    const std::size_t nv = model->get_state()->get_nv();
    Fu.leftCols(nv).diagonal().setOnes();
    multibody.joint->da_du.leftCols(nv).diagonal().setOnes();
    costs->shareMemory(this);
    constraints->shareMemory(this);
    tmp_xstatic.setZero();
  }
 
  pinocchio::DataTpl<Scalar> pinocchio;                
  DataCollectorJointActMultibody multibody;            
  std::shared_ptr<CostDataSum> costs;                  
  std::shared_ptr<ConstraintDataManager> constraints;  
  VectorXs
      tmp_xstatic;  
  using Base::cost;
  using Base::Fu;
  using Base::Fx;
  using Base::Lu;
  using Base::Luu;
  using Base::Lx;
  using Base::Lxu;
  using Base::Lxx;
  using Base::r;
  using Base::xout;
 
  struct ResidualDataActuation : public ResidualDataAbstractTpl<_Scalar> {
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    typedef _Scalar Scalar;
    typedef MathBaseTpl<Scalar> MathBase;
    typedef ResidualDataAbstractTpl<Scalar> Base;
    typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
    typedef DataCollectorActMultibodyTpl<Scalar> DataCollectorActMultibody;
    typedef ActuationDataAbstractTpl<Scalar> ActuationDataAbstract;
    typedef typename MathBase::MatrixXs MatrixXs;
 
    template <template <typename Scalar> class Model>
    ResidualDataActuation(Model<Scalar>* const model,
                          DataCollectorAbstract* const data)
        : Base(model, data),
          dtau_dx(model->get_state()->get_nv(), model->get_state()->get_ndx()) {
      dtau_dx.setZero();
      // Check that proper shared data has been passed
      DataCollectorActMultibody* d =
          dynamic_cast<DataCollectorActMultibody*>(shared);
      if (d == NULL) {
        throw_pretty(
            "Invalid argument: the shared data should be derived from "
            "DataCollectorActMultibody");
      }
 
      // Avoids data casting at runtime
      pinocchio = d->pinocchio;
      actuation = d->actuation;
    }
 
    pinocchio::DataTpl<Scalar>* pinocchio;             
    std::shared_ptr<ActuationDataAbstract> actuation;  
    MatrixXs dtau_dx;
    using Base::r;
    using Base::Ru;
    using Base::Rx;
    using Base::shared;
  };
};
 
}  // namespace crocoddyl
 
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include <crocoddyl/multibody/actions/free-invdyn.hxx>
 
#endif  // CROCODDYL_MULTIBODY_ACTIONS_FREE_INVDYN_HPP_