split_direction.hpp

Go to the documentation of this file.

#ifndef ROBOTOC_SPLIT_DIRECTION_HPP_
#define ROBOTOC_SPLIT_DIRECTION_HPP_
 
#include <iostream>
 
#include "Eigen/Core"
 
#include "robotoc/robot/robot.hpp"
#include "robotoc/robot/contact_status.hpp"
#include "robotoc/robot/impact_status.hpp"
 
 
namespace robotoc {
 
class SplitDirection {
public:
  SplitDirection(const Robot& robot);
 
  SplitDirection();
 
  ~SplitDirection() = default;
 
  SplitDirection(const SplitDirection&) = default;
 
  SplitDirection& operator=(const SplitDirection&) = default;
 
  SplitDirection(SplitDirection&&) noexcept = default;
 
  SplitDirection& operator=(SplitDirection&&) noexcept = default;
 
  void setContactDimension(const int dimf);
 
  void setSwitchingConstraintDimension(const int dims);
 
  Eigen::VectorXd dx;
 
  Eigen::VectorBlock<Eigen::VectorXd> dq();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dq() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> dv();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dv() const;
 
  Eigen::VectorXd du;
 
  Eigen::VectorBlock<Eigen::VectorXd> daf();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> daf() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> da();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> da() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> ddvf();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> ddvf() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> ddv();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> ddv() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> df();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> df() const;
 
  Eigen::VectorXd dlmdgmm;
 
  Eigen::VectorBlock<Eigen::VectorXd> dlmd();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dlmd() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> dgmm();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dgmm() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> dbetamu();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dbetamu() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> dbeta();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dbeta() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> dmu();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dmu() const;
 
  Eigen::VectorXd dnu_passive;
 
  Eigen::VectorBlock<Eigen::VectorXd> dxi();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> dxi() const;
 
  double dts;
 
  double dts_next;
 
  void setZero();
 
  int dimf() const;
 
  int dims() const;
 
  bool isDimensionConsistent() const;
 
  bool isApprox(const SplitDirection& other) const;
 
  void setRandom();
 
  void setRandom(const ContactStatus& contact_status);
 
  void setRandom(const ImpactStatus& impact_status);
 
  void setRandom(const ContactStatus& contact_status,
                 const ImpactStatus& impact_status);
 
  static SplitDirection Random(const Robot& robot);
 
  static SplitDirection Random(const Robot& robot, 
                               const ContactStatus& contact_status);
 
  static SplitDirection Random(const Robot& robot, 
                               const ImpactStatus& impact_status);
 
  static SplitDirection Random(const Robot& robot, 
                               const ContactStatus& contact_status,
                               const ImpactStatus& impact_status);
 
  void disp(std::ostream& os) const;
 
  friend std::ostream& operator<<(std::ostream& os, const SplitDirection& d);
 
private:
  Eigen::VectorXd daf_full_, dbetamu_full_, dxi_full_;
  int dimv_, dimu_, dim_passive_, dimf_, dims_;
 
};
 
} // namespace robotoc 
 
#include "robotoc/core/split_direction.hxx"
 
#endif // ROBOTOC_SPLIT_OCP_DIRECTION_HPP_