multiple-impulses.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_IMPULSES_MULTIPLE_IMPULSES_HPP_
#define CROCODDYL_MULTIBODY_IMPULSES_MULTIPLE_IMPULSES_HPP_
 
#include "crocoddyl/multibody/fwd.hpp"
#include "crocoddyl/multibody/impulse-base.hpp"
 
namespace crocoddyl {
 
template <typename _Scalar>
struct ImpulseItemTpl {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef ImpulseModelAbstractTpl<Scalar> ImpulseModelAbstract;
 
  ImpulseItemTpl() {}
  ImpulseItemTpl(const std::string& name,
                 std::shared_ptr<ImpulseModelAbstract> impulse,
                 const bool active = true)
      : name(name), impulse(impulse), active(active) {}
 
  template <typename NewScalar>
  ImpulseItemTpl<NewScalar> cast() const {
    typedef ImpulseItemTpl<NewScalar> ReturnType;
    ReturnType ret(name, impulse->template cast<NewScalar>(), active);
    return ret;
  }
 
  friend std::ostream& operator<<(std::ostream& os,
                                  const ImpulseItemTpl<Scalar>& model) {
    os << "{" << *model.impulse << "}";
    return os;
  }
 
  std::string name;
  std::shared_ptr<ImpulseModelAbstract> impulse;
  bool active;
};
 
template <typename _Scalar>
class ImpulseModelMultipleTpl {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef StateMultibodyTpl<Scalar> StateMultibody;
  typedef ImpulseDataAbstractTpl<Scalar> ImpulseDataAbstract;
  typedef ImpulseDataMultipleTpl<Scalar> ImpulseDataMultiple;
  typedef ImpulseModelAbstractTpl<Scalar> ImpulseModelAbstract;
 
  typedef ImpulseItemTpl<Scalar> ImpulseItem;
 
  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<ImpulseItem> >
      ImpulseModelContainer;
  typedef std::map<std::string, std::shared_ptr<ImpulseDataAbstract> >
      ImpulseDataContainer;
  typedef typename pinocchio::container::aligned_vector<
      pinocchio::ForceTpl<Scalar> >::iterator ForceIterator;
 
  explicit ImpulseModelMultipleTpl(std::shared_ptr<StateMultibody> state);
  ~ImpulseModelMultipleTpl();
 
  void addImpulse(const std::string& name,
                  std::shared_ptr<ImpulseModelAbstract> impulse,
                  const bool active = true);
 
  void removeImpulse(const std::string& name);
 
  void changeImpulseStatus(const std::string& name, const bool active);
 
  void calc(const std::shared_ptr<ImpulseDataMultiple>& data,
            const Eigen::Ref<const VectorXs>& x);
 
  void calcDiff(const std::shared_ptr<ImpulseDataMultiple>& data,
                const Eigen::Ref<const VectorXs>& x);
 
  void updateVelocity(const std::shared_ptr<ImpulseDataMultiple>& data,
                      const VectorXs& vnext) const;
 
  void updateForce(const std::shared_ptr<ImpulseDataMultiple>& data,
                   const VectorXs& impulse);
 
  void updateVelocityDiff(const std::shared_ptr<ImpulseDataMultiple>& data,
                          const MatrixXs& dvnext_dx) const;
 
  void updateForceDiff(const std::shared_ptr<ImpulseDataMultiple>& data,
                       const MatrixXs& df_dx) const;
 
  void updateRneaDiff(const std::shared_ptr<ImpulseDataMultiple>& data,
                      pinocchio::DataTpl<Scalar>& pinocchio) const;
 
  std::shared_ptr<ImpulseDataMultiple> createData(
      pinocchio::DataTpl<Scalar>* const data);
 
  template <typename NewScalar>
  ImpulseModelMultipleTpl<NewScalar> cast() const;
 
  const std::shared_ptr<StateMultibody>& get_state() const;
 
  const ImpulseModelContainer& get_impulses() const;
 
  std::size_t get_nc() const;
 
  std::size_t get_nc_total() const;
 
  const std::set<std::string>& get_active_set() const;
 
  const std::set<std::string>& get_inactive_set() const;
 
  bool getImpulseStatus(const std::string& name) const;
 
  template <class Scalar>
  friend std::ostream& operator<<(std::ostream& os,
                                  const ImpulseModelMultipleTpl<Scalar>& model);
 
 private:
  std::shared_ptr<StateMultibody> state_;
  ImpulseModelContainer impulses_;
  std::size_t nc_;
  std::size_t nc_total_;
  std::set<std::string> active_set_;
  std::set<std::string> inactive_set_;
};
 
template <typename _Scalar>
struct ImpulseDataMultipleTpl {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ImpulseModelMultipleTpl<Scalar> ImpulseModelMultiple;
  typedef ImpulseItemTpl<Scalar> ImpulseItem;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  template <template <typename Scalar> class Model>
  ImpulseDataMultipleTpl(Model<Scalar>* const model,
                         pinocchio::DataTpl<Scalar>* const data)
      : Jc(model->get_nc_total(), model->get_state()->get_nv()),
        dv0_dq(model->get_nc_total(), model->get_state()->get_nv()),
        vnext(model->get_state()->get_nv()),
        dvnext_dx(model->get_state()->get_nv(), model->get_state()->get_ndx()),
        fext(model->get_state()->get_pinocchio()->njoints,
             pinocchio::ForceTpl<Scalar>::Zero()) {
    Jc.setZero();
    dv0_dq.setZero();
    vnext.setZero();
    dvnext_dx.setZero();
    for (typename ImpulseModelMultiple::ImpulseModelContainer::const_iterator
             it = model->get_impulses().begin();
         it != model->get_impulses().end(); ++it) {
      const std::shared_ptr<ImpulseItem>& item = it->second;
      impulses.insert(
          std::make_pair(item->name, item->impulse->createData(data)));
    }
  }
 
  MatrixXs Jc;  
  MatrixXs
      dv0_dq;  
  VectorXs vnext;  
  MatrixXs
      dvnext_dx;  
  typename ImpulseModelMultiple::ImpulseDataContainer
      impulses;  
  pinocchio::container::aligned_vector<pinocchio::ForceTpl<Scalar> >
      fext;  
};
 
}  // namespace crocoddyl
 
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include "crocoddyl/multibody/impulses/multiple-impulses.hxx"
 
CROCODDYL_DECLARE_EXTERN_TEMPLATE_STRUCT(crocoddyl::ImpulseItemTpl)
CROCODDYL_DECLARE_EXTERN_TEMPLATE_CLASS(crocoddyl::ImpulseModelMultipleTpl)
CROCODDYL_DECLARE_EXTERN_TEMPLATE_STRUCT(crocoddyl::ImpulseDataMultipleTpl)
 
#endif  // CROCODDYL_MULTIBODY_IMPULSES_MULTIPLE_IMPULSES_HPP_