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_