impulse-fwddyn.hpp

// BSD 3-Clause License
//
// Copyright (C) 2019-2024, LAAS-CNRS, University of Edinburgh,
//                          University of Oxford, Heriot-Watt University
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
 
#ifndef CROCODDYL_MULTIBODY_ACTIONS_IMPULSE_FWDDYN_HPP_
#define CROCODDYL_MULTIBODY_ACTIONS_IMPULSE_FWDDYN_HPP_
 
#include <pinocchio/algorithm/centroidal.hpp>
#include <pinocchio/algorithm/compute-all-terms.hpp>
#include <pinocchio/algorithm/contact-dynamics.hpp>
#include <pinocchio/algorithm/frames.hpp>
#include <pinocchio/algorithm/kinematics-derivatives.hpp>
#include <pinocchio/algorithm/rnea-derivatives.hpp>
#include <stdexcept>
 
#include "crocoddyl/core/action-base.hpp"
#include "crocoddyl/core/constraints/constraint-manager.hpp"
#include "crocoddyl/core/costs/cost-sum.hpp"
#include "crocoddyl/core/utils/exception.hpp"
#include "crocoddyl/multibody/actions/impulse-fwddyn.hpp"
#include "crocoddyl/multibody/actuations/floating-base.hpp"
#include "crocoddyl/multibody/data/impulses.hpp"
#include "crocoddyl/multibody/fwd.hpp"
#include "crocoddyl/multibody/impulses/multiple-impulses.hpp"
#include "crocoddyl/multibody/states/multibody.hpp"
 
namespace crocoddyl {
 
template <typename _Scalar>
class ActionModelImpulseFwdDynamicsTpl
    : public ActionModelAbstractTpl<_Scalar> {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef ActionModelAbstractTpl<Scalar> Base;
  typedef ActionDataImpulseFwdDynamicsTpl<Scalar> Data;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef CostModelSumTpl<Scalar> CostModelSum;
  typedef ConstraintModelManagerTpl<Scalar> ConstraintModelManager;
  typedef StateMultibodyTpl<Scalar> StateMultibody;
  typedef ActionDataAbstractTpl<Scalar> ActionDataAbstract;
  typedef ImpulseModelMultipleTpl<Scalar> ImpulseModelMultiple;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  ActionModelImpulseFwdDynamicsTpl(
      std::shared_ptr<StateMultibody> state,
      std::shared_ptr<ImpulseModelMultiple> impulses,
      std::shared_ptr<CostModelSum> costs, const Scalar r_coeff = Scalar(0.),
      const Scalar JMinvJt_damping = Scalar(0.),
      const bool enable_force = false);
 
  ActionModelImpulseFwdDynamicsTpl(
      std::shared_ptr<StateMultibody> state,
      std::shared_ptr<ImpulseModelMultiple> impulses,
      std::shared_ptr<CostModelSum> costs,
      std::shared_ptr<ConstraintModelManager> constraints,
      const Scalar r_coeff = Scalar(0.),
      const Scalar JMinvJt_damping = Scalar(0.),
      const bool enable_force = false);
  virtual ~ActionModelImpulseFwdDynamicsTpl();
 
  virtual void calc(const std::shared_ptr<ActionDataAbstract>& data,
                    const Eigen::Ref<const VectorXs>& x,
                    const Eigen::Ref<const VectorXs>& u);
 
  virtual void calc(const std::shared_ptr<ActionDataAbstract>& data,
                    const Eigen::Ref<const VectorXs>& x);
 
  virtual void calcDiff(const std::shared_ptr<ActionDataAbstract>& data,
                        const Eigen::Ref<const VectorXs>& x,
                        const Eigen::Ref<const VectorXs>& u);
 
  virtual void calcDiff(const std::shared_ptr<ActionDataAbstract>& data,
                        const Eigen::Ref<const VectorXs>& x);
 
  virtual std::shared_ptr<ActionDataAbstract> createData();
 
  virtual bool checkData(const std::shared_ptr<ActionDataAbstract>& data);
 
  virtual void quasiStatic(const std::shared_ptr<ActionDataAbstract>& 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<ImpulseModelMultiple>& get_impulses() const;
 
  const std::shared_ptr<CostModelSum>& get_costs() const;
 
  const std::shared_ptr<ConstraintModelManager>& get_constraints() const;
 
  pinocchio::ModelTpl<Scalar>& get_pinocchio() const;
 
  const VectorXs& get_armature() const;
 
  const Scalar get_restitution_coefficient() const;
 
  const Scalar get_damping_factor() const;
 
  void set_armature(const VectorXs& armature);
 
  void set_restitution_coefficient(const Scalar r_coeff);
 
  void set_damping_factor(const Scalar damping);
 
  virtual void print(std::ostream& os) const;
 
 protected:
  using Base::g_lb_;   
  using Base::g_ub_;   
  using Base::state_;  
 
 private:
  void init();
  void initCalc(Data* data, const Eigen::Ref<const VectorXs>& x);
  void initCalcDiff(Data* data, const Eigen::Ref<const VectorXs>& x);
  std::shared_ptr<ImpulseModelMultiple> impulses_;       
  std::shared_ptr<CostModelSum> costs_;                  
  std::shared_ptr<ConstraintModelManager> constraints_;  
  pinocchio::ModelTpl<Scalar>& pinocchio_;               
  bool with_armature_;      
  VectorXs armature_;       
  Scalar r_coeff_;          
  Scalar JMinvJt_damping_;  
  bool enable_force_;  
  pinocchio::MotionTpl<Scalar> gravity_;  
};
 
template <typename _Scalar>
struct ActionDataImpulseFwdDynamicsTpl : public ActionDataAbstractTpl<_Scalar> {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ActionDataAbstractTpl<Scalar> Base;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  template <template <typename Scalar> class Model>
  explicit ActionDataImpulseFwdDynamicsTpl(Model<Scalar>* const model)
      : Base(model),
        pinocchio(pinocchio::DataTpl<Scalar>(model->get_pinocchio())),
        multibody(&pinocchio, model->get_impulses()->createData(&pinocchio)),
        costs(model->get_costs()->createData(&multibody)),
        vnone(model->get_state()->get_nv()),
        Kinv(model->get_state()->get_nv() +
                 model->get_impulses()->get_nc_total(),
             model->get_state()->get_nv() +
                 model->get_impulses()->get_nc_total()),
        df_dx(model->get_impulses()->get_nc_total(),
              model->get_state()->get_ndx()),
        dgrav_dq(model->get_state()->get_nv(), model->get_state()->get_nv()) {
    costs->shareMemory(this);
    if (model->get_constraints() != nullptr) {
      constraints = model->get_constraints()->createData(&multibody);
      constraints->shareMemory(this);
    }
    vnone.setZero();
    Kinv.setZero();
    df_dx.setZero();
    dgrav_dq.setZero();
  }
 
  pinocchio::DataTpl<Scalar> pinocchio;
  DataCollectorMultibodyInImpulseTpl<Scalar> multibody;
  std::shared_ptr<CostDataSumTpl<Scalar> > costs;
  std::shared_ptr<ConstraintDataManagerTpl<Scalar> > constraints;
  VectorXs vnone;
  MatrixXs Kinv;
  MatrixXs df_dx;
  MatrixXs dgrav_dq;
};
 
}  // namespace crocoddyl
 
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include <crocoddyl/multibody/actions/impulse-fwddyn.hxx>
 
#endif  // CROCODDYL_MULTIBODY_ACTIONS_IMPULSE_FWDDYN_HPP_