multiple-contacts.hpp

// BSD 3-Clause License
//
// Copyright (C) 2019-2025, LAAS-CNRS, University of Edinburgh,
//                          Heriot-Watt University
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
 
#ifndef CROCODDYL_MULTIBODY_CONTACTS_MULTIPLE_CONTACTS_HPP_
#define CROCODDYL_MULTIBODY_CONTACTS_MULTIPLE_CONTACTS_HPP_
 
#include "crocoddyl/multibody/contact-base.hpp"
#include "crocoddyl/multibody/fwd.hpp"
 
namespace crocoddyl {
 
template <typename _Scalar>
struct ContactItemTpl {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef ContactModelAbstractTpl<Scalar> ContactModelAbstract;
 
  ContactItemTpl() {}
  ContactItemTpl(const std::string& name,
                 std::shared_ptr<ContactModelAbstract> contact,
                 const bool active = true)
      : name(name), contact(contact), active(active) {}
 
  template <typename NewScalar>
  ContactItemTpl<NewScalar> cast() const {
    typedef ContactItemTpl<NewScalar> ReturnType;
    ReturnType ret(name, contact->template cast<NewScalar>(), active);
    return ret;
  }
 
  friend std::ostream& operator<<(std::ostream& os,
                                  const ContactItemTpl<Scalar>& model) {
    os << "{" << *model.contact << "}";
    return os;
  }
 
  std::string name;
  std::shared_ptr<ContactModelAbstract> contact;
  bool active;
};
 
template <typename _Scalar>
class ContactModelMultipleTpl {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef StateMultibodyTpl<Scalar> StateMultibody;
  typedef ContactDataAbstractTpl<Scalar> ContactDataAbstract;
  typedef ContactDataMultipleTpl<Scalar> ContactDataMultiple;
  typedef ContactModelAbstractTpl<Scalar> ContactModelAbstract;
 
  typedef ContactItemTpl<Scalar> ContactItem;
 
  typedef typename MathBase::Vector2s Vector2s;
  typedef typename MathBase::Vector3s Vector3s;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  typedef std::map<std::string, std::shared_ptr<ContactItem> >
      ContactModelContainer;
  typedef std::map<std::string, std::shared_ptr<ContactDataAbstract> >
      ContactDataContainer;
  typedef typename pinocchio::container::aligned_vector<
      pinocchio::ForceTpl<Scalar> >::iterator ForceIterator;
 
  ContactModelMultipleTpl(std::shared_ptr<StateMultibody> state,
                          const std::size_t nu);
 
  ContactModelMultipleTpl(std::shared_ptr<StateMultibody> state);
  ~ContactModelMultipleTpl();
 
  void addContact(const std::string& name,
                  std::shared_ptr<ContactModelAbstract> contact,
                  const bool active = true);
 
  void removeContact(const std::string& name);
 
  void changeContactStatus(const std::string& name, const bool active);
 
  void calc(const std::shared_ptr<ContactDataMultiple>& data,
            const Eigen::Ref<const VectorXs>& x);
 
  void calcDiff(const std::shared_ptr<ContactDataMultiple>& data,
                const Eigen::Ref<const VectorXs>& x);
 
  void updateAcceleration(const std::shared_ptr<ContactDataMultiple>& data,
                          const VectorXs& dv) const;
 
  void updateForce(const std::shared_ptr<ContactDataMultiple>& data,
                   const VectorXs& force);
 
  void updateAccelerationDiff(const std::shared_ptr<ContactDataMultiple>& data,
                              const MatrixXs& ddv_dx) const;
 
  void updateForceDiff(const std::shared_ptr<ContactDataMultiple>& data,
                       const MatrixXs& df_dx, const MatrixXs& df_du) const;
 
  void updateRneaDiff(const std::shared_ptr<ContactDataMultiple>& data,
                      pinocchio::DataTpl<Scalar>& pinocchio) const;
 
  std::shared_ptr<ContactDataMultiple> createData(
      pinocchio::DataTpl<Scalar>* const data);
 
  template <typename NewScalar>
  ContactModelMultipleTpl<NewScalar> cast() const;
 
  const std::shared_ptr<StateMultibody>& get_state() const;
 
  const ContactModelContainer& get_contacts() const;
 
  std::size_t get_nc() const;
 
  std::size_t get_nc_total() const;
 
  std::size_t get_nu() const;
 
  const std::set<std::string>& get_active_set() const;
 
  const std::set<std::string>& get_inactive_set() const;
 
  bool getContactStatus(const std::string& name) const;
 
  bool getComputeAllContacts() const;
 
  void setComputeAllContacts(const bool status);
 
  template <class Scalar>
  friend std::ostream& operator<<(std::ostream& os,
                                  const ContactModelMultipleTpl<Scalar>& model);
 
 private:
  std::shared_ptr<StateMultibody> state_;
  ContactModelContainer contacts_;
  std::size_t nc_;
  std::size_t nc_total_;
  std::size_t nu_;
  std::set<std::string> active_set_;
  std::set<std::string> inactive_set_;
  bool compute_all_contacts_;
};
 
template <typename _Scalar>
struct ContactDataMultipleTpl {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ContactModelMultipleTpl<Scalar> ContactModelMultiple;
  typedef ContactItemTpl<Scalar> ContactItem;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  template <template <typename Scalar> class Model>
  ContactDataMultipleTpl(Model<Scalar>* const model,
                         pinocchio::DataTpl<Scalar>* const data)
      : Jc(model->get_nc_total(), model->get_state()->get_nv()),
        a0(model->get_nc_total()),
        da0_dx(model->get_nc_total(), model->get_state()->get_ndx()),
        dv(model->get_state()->get_nv()),
        ddv_dx(model->get_state()->get_nv(), model->get_state()->get_ndx()),
        fext(model->get_state()->get_pinocchio()->njoints,
             pinocchio::ForceTpl<Scalar>::Zero()) {
    Jc.setZero();
    a0.setZero();
    da0_dx.setZero();
    dv.setZero();
    ddv_dx.setZero();
    for (typename ContactModelMultiple::ContactModelContainer::const_iterator
             it = model->get_contacts().begin();
         it != model->get_contacts().end(); ++it) {
      const std::shared_ptr<ContactItem>& item = it->second;
      contacts.insert(
          std::make_pair(item->name, item->contact->createData(data)));
    }
  }
 
  MatrixXs Jc;  
  VectorXs a0;  
  MatrixXs
      da0_dx;  
  VectorXs dv;  
  MatrixXs
      ddv_dx;  
  typename ContactModelMultiple::ContactDataContainer
      contacts;  
  pinocchio::container::aligned_vector<pinocchio::ForceTpl<Scalar> >
      fext;  
};
 
}  // namespace crocoddyl
 
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include "crocoddyl/multibody/contacts/multiple-contacts.hxx"
 
CROCODDYL_DECLARE_EXTERN_TEMPLATE_STRUCT(crocoddyl::ContactItemTpl)
CROCODDYL_DECLARE_EXTERN_TEMPLATE_CLASS(crocoddyl::ContactModelMultipleTpl)
CROCODDYL_DECLARE_EXTERN_TEMPLATE_STRUCT(crocoddyl::ContactDataMultipleTpl)
 
#endif  // CROCODDYL_MULTIBODY_CONTACTS_MULTIPLE_CONTACTS_HPP_