intermediate-qp-matrices.hh

Go to the documentation of this file.

/*
 * Copyright 2011,
 *
 * Olivier  Stasse
 * Andrei   Herdt
 *
 * JRL, CNRS/AIST
 *
 * This file is part of walkGenJrl.
 * walkGenJrl is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * walkGenJrl is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Lesser Public License for more details.
 * You should have received a copy of the GNU Lesser General Public License
 * along with walkGenJrl.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Research carried out within the scope of the
 *  Joint Japanese-French Robotics Laboratory (JRL)
 */
 
#ifndef INTERMEDQPMAT_HH_
#define INTERMEDQPMAT_HH_
 
#include <PreviewControl/rigid-body-system.hh>
#include <fstream>
#include <iostream>
#include <privatepgtypes.hh>
 
namespace PatternGeneratorJRL {
class IntermedQPMat {
  //
  // Public types
  //
 public:
  struct state_variant_s {
 
    reference_t Ref;
 
    com_t CoM;
 
    trunk_t Trunk;
 
    Eigen::MatrixXd V;
    Eigen::MatrixXd Vshift;
    Eigen::MatrixXd VT;
    Eigen::VectorXd VcX, VcY;
    Eigen::VectorXd VcshiftX, VcshiftY;
    Eigen::VectorXd Vc_fX, Vc_fY;
    Eigen::MatrixXd V_f;
    support_state_t SupportState;
  };
  typedef state_variant_s state_variant_t;
 
  struct objective_variant_s {
    double weight;
 
    objective_e type;
 
    std::ostream &print(std::ostream &o) const;
    void dump(const char *filename) const;
  };
  typedef objective_variant_s objective_variant_t;
 
  //
  // Public methods
  //
 public:
  IntermedQPMat();
  ~IntermedQPMat();
 
  inline state_variant_t const &State() const { return StateMatrices_; };
  inline state_variant_t &State() { return StateMatrices_; };
 
  objective_variant_t const &Objective(objective_e type) const;
  objective_variant_t &Objective(objective_e type);
 
  linear_inequality_t const &Inequalities(ineq_e type) const;
  linear_inequality_t &Inequalities(ineq_e type);
 
  inline com_t const &CoM() const { return StateMatrices_.CoM; };
  inline void CoM(const com_t &CoM) { StateMatrices_.CoM = CoM; };
 
  inline trunk_t const &Trunk() const { return StateMatrices_.Trunk; }
  inline void Trunk(const trunk_t &Trunk) { StateMatrices_.Trunk = Trunk; }
 
  inline reference_t const &Reference() const { return StateMatrices_.Ref; };
  inline reference_t &Reference() { return StateMatrices_.Ref; };
  inline void Reference(const reference_t &Ref) { StateMatrices_.Ref = Ref; };
 
  inline support_state_t const &SupportState() const {
    return StateMatrices_.SupportState;
  };
  inline support_state_t &SupportState() {
    return StateMatrices_.SupportState;
  };
  inline void SupportState(const support_state_t &SupportState) {
    StateMatrices_.SupportState = SupportState;
  };
 
  void dump_objective(objective_e type, std::ostream &aos);
  void dump_state(std::ostream &aos);
  void dump_objective(const char *filename, objective_e type);
  void dump_state(const char *filename);
 
  //
  // Private members
  //
 private:
  objective_variant_t MeanVelocity_, InstantVelocity_, COPCentering_, JerkMin_;
 
  state_variant_t StateMatrices_;
 
  linear_inequality_t IneqCoP_, IneqCoM_, IneqFeet_;
};
 
std::ostream &operator<<(std::ostream &o,
                         const IntermedQPMat::objective_variant_s &r);
}  // namespace PatternGeneratorJRL
 
#endif /* INTERMEDQPMAT_HH_ */