abstract_time_indexed_problem.h

Go to the documentation of this file.

//
// Copyright (c) 2019, University of Edinburgh
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//  * Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of  nor the names of its contributors may be used to
//    endorse or promote products derived from this software without specific
//    prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
 
#ifndef EXOTICA_CORE_ABSTRACT_TIME_INDEXED_PROBLEM_H_
#define EXOTICA_CORE_ABSTRACT_TIME_INDEXED_PROBLEM_H_
 
#include <Eigen/Sparse>
 
#include <exotica_core/planning_problem.h>
#include <exotica_core/tasks.h>
 
namespace exotica
{
class AbstractTimeIndexedProblem : public PlanningProblem
{
public:
    AbstractTimeIndexedProblem();
    virtual ~AbstractTimeIndexedProblem();
 
    void Update(Eigen::VectorXdRefConst x_trajectory_in);
 
    virtual void Update(Eigen::VectorXdRefConst x_in, int t);
 
    double GetDuration() const;
 
    std::vector<Eigen::VectorXd> GetInitialTrajectory() const;
 
    void SetInitialTrajectory(const std::vector<Eigen::VectorXd>& q_init_in);
 
    virtual void PreUpdate();
 
    void SetGoal(const std::string& task_name, Eigen::VectorXdRefConst goal, int t = 0);
 
    Eigen::VectorXd GetGoal(const std::string& task_name, int t = 0);
 
    void SetRho(const std::string& task_name, const double rho, int t = 0);
 
    double GetRho(const std::string& task_name, int t = 0);
 
    void SetGoalEQ(const std::string& task_name, Eigen::VectorXdRefConst goal, int t = 0);
 
    Eigen::VectorXd GetGoalEQ(const std::string& task_name, int t = 0);
 
    void SetRhoEQ(const std::string& task_name, const double rho, int t = 0);
 
    double GetRhoEQ(const std::string& task_name, int t = 0);
 
    void SetGoalNEQ(const std::string& task_name, Eigen::VectorXdRefConst goal, int t = 0);
 
    Eigen::VectorXd GetGoalNEQ(const std::string& task_name, int t = 0);
 
    void SetRhoNEQ(const std::string& task_name, const double rho, int t = 0);
 
    double GetRhoNEQ(const std::string& task_name, int t = 0);
 
    Eigen::MatrixXd GetBounds() const;
 
    int GetT() const;
 
    void SetT(const int T_in);
 
    double GetTau() const;
 
    void SetTau(const double tau_in);
 
    double get_ct() const;
 
    double GetScalarTaskCost(int t) const;
 
    Eigen::RowVectorXd GetScalarTaskJacobian(int t) const;
 
    double GetScalarTransitionCost(int t) const;
 
    Eigen::RowVectorXd GetScalarTransitionJacobian(int t) const;
 
    double GetCost() const;
 
    Eigen::RowVectorXd GetCostJacobian() const;
 
    Eigen::VectorXd GetEquality() const;
 
    Eigen::VectorXd GetInequality() const;
 
    Eigen::SparseMatrix<double> GetEqualityJacobian() const;
 
    Eigen::SparseMatrix<double> GetInequalityJacobian() const;
 
    std::vector<Eigen::Triplet<double>> GetEqualityJacobianTriplets() const;
 
    int get_active_nonlinear_equality_constraints_dimension() const;
 
    Eigen::VectorXd GetEquality(int t) const;
 
    Eigen::MatrixXd GetEqualityJacobian(int t) const;
 
    Eigen::VectorXd GetInequality(int t) const;
 
    Eigen::MatrixXd GetInequalityJacobian(int t) const;
 
    std::vector<Eigen::Triplet<double>> GetInequalityJacobianTriplets() const;
 
    int get_active_nonlinear_inequality_constraints_dimension() const;
 
    int get_joint_velocity_constraint_dimension() const;
 
    Eigen::VectorXd GetJointVelocityConstraint() const;
 
    Eigen::MatrixXd GetJointVelocityConstraintBounds() const;
 
    std::vector<Eigen::Triplet<double>> GetJointVelocityConstraintJacobianTriplets() const;
 
    Eigen::VectorXd GetJointVelocityLimits() const;
 
    void SetJointVelocityLimits(const Eigen::VectorXd& qdot_max_in);
 
    TimeIndexedTask cost;        
    TimeIndexedTask inequality;  
    TimeIndexedTask equality;    
 
    Eigen::MatrixXd W;  // TODO(wxm): Make private and add getter and setter (#209)
 
    // TODO: Make private and add getter (no need to be public!)
    std::vector<TaskSpaceVector> Phi;
    std::vector<Eigen::MatrixXd> jacobian;
    std::vector<Hessian> hessian;
 
    // TODO: Make private and add getter/setter
    int length_Phi;
    int length_jacobian;
    int num_tasks;
    bool use_bounds;
 
protected:
    virtual void ReinitializeVariables();
 
    inline void ValidateTimeIndex(int& t_in) const
    {
        if (t_in >= T_ || t_in < -1)
        {
            ThrowPretty("Requested t=" << t_in << " out of range, needs to be 0 =< t < " << T_);
        }
        else if (t_in == -1)
        {
            t_in = (T_ - 1);
        }
    }
 
    int T_ = 0;       
    double tau_ = 0;  
 
    std::vector<Eigen::VectorXd> x;      
    std::vector<Eigen::VectorXd> xdiff;  // equivalent to dx = x(t)-x(t-1)
 
    double w_scale_ = 1.0;  
 
    TaskSpaceVector cost_Phi;
    TaskSpaceVector inequality_Phi;
    TaskSpaceVector equality_Phi;
 
    std::vector<Eigen::VectorXd> initial_trajectory_;
    std::vector<std::shared_ptr<KinematicResponse>> kinematic_solutions_;
 
    double ct;  
 
    Eigen::VectorXd q_dot_max_;  
    Eigen::VectorXd xdiff_max_;  
 
    // The first element in the pair is the timestep (t) and the second element is the task.id (id).
    std::vector<std::pair<int, int>> active_nonlinear_equality_constraints_;
    std::vector<std::pair<int, int>> active_nonlinear_inequality_constraints_;
    int active_nonlinear_equality_constraints_dimension_ = 0;
    int active_nonlinear_inequality_constraints_dimension_ = 0;
 
    // Terms related with the joint velocity constraint - the Jacobian triplets are constant so can be cached.
    int joint_velocity_constraint_dimension_ = 0;
    std::vector<Eigen::Triplet<double>> joint_velocity_constraint_jacobian_triplets_;
};
}  // namespace exotica
 
#endif  // EXOTICA_CORE_ABSTRACT_TIME_INDEXED_PROBLEM_H_