contact-invdyn.hpp

// BSD 3-Clause License
//
// Copyright (C) 2021-2025, Heriot-Watt University, University of Edinburgh
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.

#ifndef CROCODDYL_MULTIBODY_ACTIONS_CONTACT_INVDYN_HPP_
#define CROCODDYL_MULTIBODY_ACTIONS_CONTACT_INVDYN_HPP_

#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/multibody/contacts/multiple-contacts.hpp"
#include "crocoddyl/multibody/data/contacts.hpp"
#include "crocoddyl/multibody/fwd.hpp"
#include "crocoddyl/multibody/states/multibody.hpp"

namespace crocoddyl {

template <typename _Scalar>
class DifferentialActionModelContactInvDynamicsTpl
 : public DifferentialActionModelAbstractTpl<_Scalar> {
 public:
 EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 CROCODDYL_DERIVED_CAST(DifferentialActionModelBase,
 DifferentialActionModelContactInvDynamicsTpl)

 typedef _Scalar Scalar;
 typedef DifferentialActionModelAbstractTpl<Scalar> Base;
 typedef DifferentialActionDataContactInvDynamicsTpl<Scalar> Data;
 typedef StateMultibodyTpl<Scalar> StateMultibody;
 typedef ActuationModelAbstractTpl<Scalar> ActuationModelAbstract;
 typedef CostModelSumTpl<Scalar> CostModelSum;
 typedef ConstraintModelManagerTpl<Scalar> ConstraintModelManager;
 typedef ContactModelMultipleTpl<Scalar> ContactModelMultiple;
 typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
 typedef DifferentialActionDataAbstractTpl<Scalar>
 DifferentialActionDataAbstract;
 typedef ContactItemTpl<Scalar> ContactItem;
 typedef MathBaseTpl<Scalar> MathBase;
 typedef typename MathBase::VectorXs VectorXs;
 typedef typename MathBase::MatrixXs MatrixXs;

 DifferentialActionModelContactInvDynamicsTpl(
 std::shared_ptr<StateMultibody> state,
 std::shared_ptr<ActuationModelAbstract> actuation,
 std::shared_ptr<ContactModelMultiple> contacts,
 std::shared_ptr<CostModelSum> costs);

 DifferentialActionModelContactInvDynamicsTpl(
 std::shared_ptr<StateMultibody> state,
 std::shared_ptr<ActuationModelAbstract> actuation,
 std::shared_ptr<ContactModelMultiple> contacts,
 std::shared_ptr<CostModelSum> costs,
 std::shared_ptr<ConstraintModelManager> constraints);
 virtual ~DifferentialActionModelContactInvDynamicsTpl() = default;

 virtual void calc(const std::shared_ptr<DifferentialActionDataAbstract>& data,
 const Eigen::Ref<const VectorXs>& x,
 const Eigen::Ref<const VectorXs>& u) override;

 virtual void calc(const std::shared_ptr<DifferentialActionDataAbstract>& data,
 const Eigen::Ref<const VectorXs>& x) override;

 virtual void calcDiff(
 const std::shared_ptr<DifferentialActionDataAbstract>& data,
 const Eigen::Ref<const VectorXs>& x,
 const Eigen::Ref<const VectorXs>& u) override;

 virtual void calcDiff(
 const std::shared_ptr<DifferentialActionDataAbstract>& data,
 const Eigen::Ref<const VectorXs>& x) override;

 virtual std::shared_ptr<DifferentialActionDataAbstract> createData() override;

 template <typename NewScalar>
 DifferentialActionModelContactInvDynamicsTpl<NewScalar> cast() const;

 virtual bool checkData(
 const std::shared_ptr<DifferentialActionDataAbstract>& data) override;

 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)) override;

 virtual std::size_t get_ng() const override;

 virtual std::size_t get_nh() const override;

 virtual std::size_t get_ng_T() const override;

 virtual std::size_t get_nh_T() const override;

 virtual const VectorXs& get_g_lb() const override;

 virtual const VectorXs& get_g_ub() const override;

 const std::shared_ptr<ActuationModelAbstract>& get_actuation() const;

 const std::shared_ptr<ContactModelMultiple>& get_contacts() 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 override;

 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<ContactModelMultiple> contacts_;
 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
 CROCODDYL_INNER_DERIVED_CAST(ResidualModelBase,
 DifferentialActionModelContactInvDynamicsTpl,
 ResidualModelActuation)

 typedef _Scalar Scalar;
 typedef MathBaseTpl<Scalar> MathBase;
 typedef ResidualModelAbstractTpl<Scalar> Base;
 typedef StateMultibodyTpl<Scalar> StateMultibody;
 typedef ResidualDataAbstractTpl<Scalar> ResidualDataAbstract;
 typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
 typedef typename MathBase::VectorXs VectorXs;

 ResidualModelActuation(std::shared_ptr<StateMultibody> state,
 const std::size_t nu, const std::size_t nc)
 : Base(state, state->get_nv() - nu, state->get_nv() + nc, true, true,
 true),
 na_(nu),
 nc_(nc) {}
 virtual ~ResidualModelActuation() = default;

 virtual void calc(const std::shared_ptr<ResidualDataAbstract>& data,
 const Eigen::Ref<const VectorXs>&,
 const Eigen::Ref<const VectorXs>&) override {
 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>&) override {
 data->r.setZero();
 }

 virtual void calcDiff(const std::shared_ptr<ResidualDataAbstract>& data,
 const Eigen::Ref<const VectorXs>&,
 const Eigen::Ref<const VectorXs>&) override {
 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;
 d->dtau_du.leftCols(nv) = d->pinocchio->M;
 d->dtau_du.rightCols(nc_) = -d->contact->Jc.transpose();
 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->dtau_du.row(k);
 nrow += 1;
 }
 }
 }

 virtual void calcDiff(const std::shared_ptr<ResidualDataAbstract>& data,
 const Eigen::Ref<const VectorXs>&) override {
 data->Rx.setZero();
 data->Ru.setZero();
 }

 virtual std::shared_ptr<ResidualDataAbstract> createData(
 DataCollectorAbstract* const data) override {
 return std::allocate_shared<typename Data::ResidualDataActuation>(
 Eigen::aligned_allocator<typename Data::ResidualDataActuation>(),
 this, data);
 }

 template <typename NewScalar>
 typename DifferentialActionModelContactInvDynamicsTpl<
 NewScalar>::ResidualModelActuation
 cast() const {
 typedef typename DifferentialActionModelContactInvDynamicsTpl<
 NewScalar>::ResidualModelActuation ReturnType;
 typedef StateMultibodyTpl<NewScalar> StateType;
 ReturnType ret(std::static_pointer_cast<StateType>(
 state_->template cast<NewScalar>()),
 na_, nc_);
 return ret;
 }

 virtual void print(std::ostream& os) const override {
 os << "ResidualModelActuation {nx=" << state_->get_nx()
 << ", ndx=" << state_->get_ndx() << ", nu=" << nu_ << ", na=" << na_
 << "}";
 }

 protected:
 using Base::nu_;
 using Base::state_;

 private:
 std::size_t na_;
 std::size_t nc_;
 };

 public:
 class ResidualModelContact : public ResidualModelAbstractTpl<_Scalar> {
 public:
 EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 CROCODDYL_INNER_DERIVED_CAST(ResidualModelBase,
 DifferentialActionModelContactInvDynamicsTpl,
 ResidualModelContact)

 typedef _Scalar Scalar;
 typedef MathBaseTpl<Scalar> MathBase;
 typedef ResidualModelAbstractTpl<Scalar> Base;
 typedef StateMultibodyTpl<Scalar> StateMultibody;
 typedef ResidualDataAbstractTpl<Scalar> ResidualDataAbstract;
 typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
 typedef typename MathBase::VectorXs VectorXs;
 typedef typename MathBase::MatrixXs MatrixXs;

 ResidualModelContact(std::shared_ptr<StateMultibody> state,
 const pinocchio::FrameIndex id, const std::size_t nr,
 const std::size_t nc)
 : Base(state, nr, state->get_nv() + nc, true, true, true),
 id_(id),
 frame_name_(state->get_pinocchio()->frames[id].name),
 nc_(nc) {}
 virtual ~ResidualModelContact() = default;

 void calc(const std::shared_ptr<ResidualDataAbstract>& data,
 const Eigen::Ref<const VectorXs>&,
 const Eigen::Ref<const VectorXs>&) override {
 typename Data::ResidualDataContact* d =
 static_cast<typename Data::ResidualDataContact*>(data.get());
 d->r = d->contact->a0;
 }

 virtual void calc(const std::shared_ptr<ResidualDataAbstract>& data,
 const Eigen::Ref<const VectorXs>&) override {
 data->r.setZero();
 }

 void calcDiff(const std::shared_ptr<ResidualDataAbstract>& data,
 const Eigen::Ref<const VectorXs>&,
 const Eigen::Ref<const VectorXs>&) override {
 typename Data::ResidualDataContact* d =
 static_cast<typename Data::ResidualDataContact*>(data.get());
 d->Rx = d->contact->da0_dx;
 d->Ru.leftCols(state_->get_nv()) = d->contact->Jc;
 }

 virtual void calcDiff(const std::shared_ptr<ResidualDataAbstract>& data,
 const Eigen::Ref<const VectorXs>&) override {
 data->Rx.setZero();
 data->Ru.setZero();
 }

 virtual std::shared_ptr<ResidualDataAbstract> createData(
 DataCollectorAbstract* const data) override {
 return std::allocate_shared<typename Data::ResidualDataContact>(
 Eigen::aligned_allocator<typename Data::ResidualDataContact>(), this,
 data, id_);
 }

 template <typename NewScalar>
 typename DifferentialActionModelContactInvDynamicsTpl<
 NewScalar>::ResidualModelContact
 cast() const {
 typedef typename DifferentialActionModelContactInvDynamicsTpl<
 NewScalar>::ResidualModelContact ReturnType;
 typedef StateMultibodyTpl<NewScalar> StateType;
 ReturnType ret(std::static_pointer_cast<StateType>(
 state_->template cast<NewScalar>()),
 id_, nr_, nc_);
 return ret;
 }

 virtual void print(std::ostream& os) const override {
 os << "ResidualModelContact {frame=" << frame_name_ << ", nr=" << nr_
 << "}";
 }

 protected:
 using Base::nr_;
 using Base::nu_;
 using Base::state_;

 private:
 pinocchio::FrameIndex id_;
 std::string frame_name_;
 std::size_t nc_;
 };
};
template <typename _Scalar>
struct DifferentialActionDataContactInvDynamicsTpl
 : public DifferentialActionDataAbstractTpl<_Scalar> {
 EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 typedef _Scalar Scalar;
 typedef MathBaseTpl<Scalar> MathBase;
 typedef DifferentialActionDataAbstractTpl<Scalar> Base;
 typedef JointDataAbstractTpl<Scalar> JointDataAbstract;
 typedef DataCollectorJointActMultibodyInContactTpl<Scalar>
 DataCollectorJointActMultibodyInContact;
 typedef CostDataSumTpl<Scalar> CostDataSum;
 typedef ConstraintDataManagerTpl<Scalar> ConstraintDataManager;
 typedef ContactModelMultipleTpl<Scalar> ContactModelMultiple;
 typedef ContactItemTpl<Scalar> ContactItem;
 typedef typename MathBase::VectorXs VectorXs;
 typedef typename MathBase::MatrixXs MatrixXs;

 template <template <typename Scalar> class Model>
 explicit DifferentialActionDataContactInvDynamicsTpl(
 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()),
 model->get_contacts()->createData(&pinocchio)),
 tmp_xstatic(model->get_state()->get_nx()),
 tmp_rstatic(model->get_actuation()->get_nu() +
 model->get_contacts()->get_nc()),
 tmp_Jstatic(model->get_state()->get_nv(),
 model->get_actuation()->get_nu() +
 model->get_contacts()->get_nc()) {
 // Set constant values for Fu, df_dx, and df_du
 const std::size_t nv = model->get_state()->get_nv();
 const std::size_t nc = model->get_contacts()->get_nc_total();
 Fu.leftCols(nv).diagonal().setOnes();
 multibody.joint->da_du.leftCols(nv).diagonal().setOnes();
 MatrixXs df_dx = MatrixXs::Zero(nc, model->get_state()->get_ndx());
 MatrixXs df_du = MatrixXs::Zero(nc, model->get_nu());
 std::size_t fid = 0;
 for (typename ContactModelMultiple::ContactModelContainer::const_iterator
 it = model->get_contacts()->get_contacts().begin();
 it != model->get_contacts()->get_contacts().end(); ++it) {
 const std::size_t nc = it->second->contact->get_nc();
 df_du.block(fid, nv + fid, nc, nc).diagonal().setOnes();
 fid += nc;
 }
 std::vector<bool> contact_status;
 for (typename ContactModelMultiple::ContactModelContainer::const_iterator
 it = model->get_contacts()->get_contacts().begin();
 it != model->get_contacts()->get_contacts().end(); ++it) {
 const std::shared_ptr<ContactItem>& m_i = it->second;
 contact_status.push_back(m_i->active);
 m_i->active = true;
 }
 model->get_contacts()->updateForceDiff(multibody.contacts, df_dx, df_du);
 std::size_t cid = 0;
 for (typename ContactModelMultiple::ContactModelContainer::const_iterator
 it = model->get_contacts()->get_contacts().begin();
 it != model->get_contacts()->get_contacts().end(); ++it) {
 const std::shared_ptr<ContactItem>& m_i = it->second;
 m_i->active = contact_status[cid];
 cid++;
 }
 costs = model->get_costs()->createData(&multibody);
 constraints = model->get_constraints()->createData(&multibody);
 costs->shareMemory(this);
 constraints->shareMemory(this);

 tmp_xstatic.setZero();
 tmp_rstatic.setZero();
 tmp_Jstatic.setZero();
 }
 virtual ~DifferentialActionDataContactInvDynamicsTpl() = default;

 pinocchio::DataTpl<Scalar> pinocchio;
 DataCollectorJointActMultibodyInContact multibody;
 std::shared_ptr<CostDataSum> costs;
 std::shared_ptr<ConstraintDataManager> constraints;
 VectorXs
 tmp_xstatic;
 VectorXs
 tmp_rstatic;
 MatrixXs tmp_Jstatic;

 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 DataCollectorActMultibodyInContactTpl<Scalar>
 DataCollectorActMultibodyInContact;
 typedef ActuationDataAbstractTpl<Scalar> ActuationDataAbstract;
 typedef ContactDataMultipleTpl<Scalar> ContactDataMultiple;
 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_du(model->get_state()->get_nv(), model->get_nu()) {
 // Check that proper shared data has been passed
 DataCollectorActMultibodyInContact* d =
 dynamic_cast<DataCollectorActMultibodyInContact*>(shared);
 if (d == NULL) {
 throw_pretty(
 "Invalid argument: the shared data should be derived from "
 "DataCollectorActMultibodyInContact");
 }
 // Avoids data casting at runtime
 pinocchio = d->pinocchio;
 actuation = d->actuation;
 contact = d->contacts;
 dtau_dx.setZero();
 dtau_du.setZero();
 }
 virtual ~ResidualDataActuation() = default;

 pinocchio::DataTpl<Scalar>* pinocchio;
 std::shared_ptr<ActuationDataAbstract> actuation;
 std::shared_ptr<ContactDataMultiple> contact;
 MatrixXs dtau_dx;
 MatrixXs dtau_du;
 using Base::r;
 using Base::Ru;
 using Base::Rx;
 using Base::shared;
 };

 struct ResidualDataContact : public ResidualDataAbstractTpl<_Scalar> {
 EIGEN_MAKE_ALIGNED_OPERATOR_NEW

 typedef _Scalar Scalar;
 typedef MathBaseTpl<Scalar> MathBase;
 typedef ResidualDataAbstractTpl<Scalar> Base;
 typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
 typedef DataCollectorMultibodyInContactTpl<Scalar>
 DataCollectorMultibodyInContact;
 typedef ContactModelMultipleTpl<Scalar> ContactModelMultiple;

 template <template <typename Scalar> class Model>
 ResidualDataContact(Model<Scalar>* const model,
 DataCollectorAbstract* const data, const std::size_t id)
 : Base(model, data) {
 DataCollectorMultibodyInContact* d =
 dynamic_cast<DataCollectorMultibodyInContact*>(shared);
 if (d == NULL) {
 throw_pretty(
 "Invalid argument: the shared data should be derived from "
 "DataCollectorMultibodyInContact");
 }
 typename ContactModelMultiple::ContactDataContainer::iterator it, end;
 for (it = d->contacts->contacts.begin(),
 end = d->contacts->contacts.end();
 it != end; ++it) {
 if (id == it->second->frame) { // TODO(cmastalli): use model->get_id()
 // and avoid to pass id in constructor
 contact = it->second.get();
 break;
 }
 }
 }
 virtual ~ResidualDataContact() = default;

 ContactDataAbstractTpl<Scalar>* contact;
 using Base::r;
 using Base::Ru;
 using Base::Rx;
 using Base::shared;
 };
};
} // namespace crocoddyl

/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include <crocoddyl/multibody/actions/contact-invdyn.hxx>

CROCODDYL_DECLARE_EXTERN_TEMPLATE_CLASS(
 crocoddyl::DifferentialActionModelContactInvDynamicsTpl)
CROCODDYL_DECLARE_EXTERN_TEMPLATE_STRUCT(
 crocoddyl::DifferentialActionDataContactInvDynamicsTpl)

#endif // CROCODDYL_MULTIBODY_ACTIONS_CONTACT_INVDYN_HPP_