aico_solver.h

Go to the documentation of this file.

//
// Copyright (c) 2018, 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.
//

// This code is based on algorithm developed by Marc Toussaint
// M. Toussaint: Robot Trajectory Optimization using Approximate Inference. In Proc. of the Int. Conf. on Machine Learning (ICML 2009), 1049-1056, ACM, 2009.
// http://ipvs.informatik.uni-stuttgart.de/mlr/papers/09-toussaint-ICML.pdf
// Original code available at http://ipvs.informatik.uni-stuttgart.de/mlr/marc/source-code/index.html





#ifndef EXOTICA_AICO_SOLVER_AICO_SOLVER_H_
#define EXOTICA_AICO_SOLVER_AICO_SOLVER_H_

#include <iostream>

#include <exotica_core/motion_solver.h>
#include <exotica_core/problems/unconstrained_time_indexed_problem.h>

#include <exotica_aico_solver/incremental_gaussian.h>
#include <exotica_aico_solver/math_operations.h>

#include <exotica_aico_solver/aico_solver_initializer.h>

namespace exotica
{
class AICOSolver : public MotionSolver, public Instantiable<AICOSolverInitializer>
{
public:
    AICOSolver();
    void Instantiate(const AICOSolverInitializer& init) override;
    virtual ~AICOSolver();

    void Solve(Eigen::MatrixXd& solution) override;

    void SpecifyProblem(PlanningProblemPtr pointer) override;

protected:
    void InitMessages();

    void InitTrajectory(const std::vector<Eigen::VectorXd>& q_init);

private:
    UnconstrainedTimeIndexedProblemPtr prob_;  
    double damping = 0.01;                     
    double damping_init_ = 0.0;                
    double minimum_step_tolerance_ = 1e-5;     
    double step_tolerance_ = 1e-5;             
    double function_tolerance_ = 1e-5;         
    int max_backtrack_iterations_ = 10;        
    bool use_bwd_msg_ = false;                 
    Eigen::VectorXd bwd_msg_v_;                
    Eigen::MatrixXd bwd_msg_Vinv_;             
    bool sweep_improved_cost_;                 
    int iteration_count_;                      

    std::vector<SinglePassMeanCovariance> q_stat_;  

    std::vector<Eigen::VectorXd> s;     
    std::vector<Eigen::MatrixXd> Sinv;  
    std::vector<Eigen::VectorXd> v;     
    std::vector<Eigen::MatrixXd> Vinv;  
    std::vector<Eigen::VectorXd> r;     
    std::vector<Eigen::MatrixXd> R;     
    Eigen::VectorXd rhat;               
    std::vector<Eigen::VectorXd> b;     
    std::vector<Eigen::MatrixXd> Binv;  
    std::vector<Eigen::VectorXd> q;     
    std::vector<Eigen::VectorXd> qhat;  
    Eigen::VectorXd cost_control_;      
    Eigen::VectorXd cost_task_;         

    std::vector<Eigen::VectorXd> s_old;     
    std::vector<Eigen::MatrixXd> Sinv_old;  
    std::vector<Eigen::VectorXd> v_old;     
    std::vector<Eigen::MatrixXd> Vinv_old;  
    std::vector<Eigen::VectorXd> r_old;     
    std::vector<Eigen::MatrixXd> R_old;     
    Eigen::VectorXd rhat_old;               
    std::vector<Eigen::VectorXd> b_old;     
    std::vector<Eigen::MatrixXd> Binv_old;  
    std::vector<Eigen::VectorXd> q_old;     
    std::vector<Eigen::VectorXd> qhat_old;  
    Eigen::VectorXd cost_control_old_;      
    Eigen::MatrixXd cost_task_old_;         

    std::vector<Eigen::VectorXd> damping_reference_;         
    double cost_ = 0.0;                                      
    double cost_old_ = std::numeric_limits<double>::max();   
    double cost_prev_ = std::numeric_limits<double>::max();  
    double b_step_ = 0.0;                                    
    double b_step_old_;

    Eigen::MatrixXd W;     
    Eigen::MatrixXd Winv;  

    int last_T_;  

    int sweep_ = 0;  
    int best_sweep_ = 0;
    int best_sweep_old_ = 0;
    enum SweepMode
    {
        FORWARD = 0,
        SYMMETRIC,
        LOCAL_GAUSS_NEWTON,
        LOCAL_GAUSS_NEWTON_DAMPED
    };
    int sweep_mode_ = 0;  
    int update_count_ = 0;

    bool verbose_ = false;

    void UpdateFwdMessage(int t);

    void UpdateBwdMessage(int t);

    void UpdateTaskMessage(int t,
                           const Eigen::Ref<const Eigen::VectorXd>& qhat_t, double tolerance,
                           double max_step_size = -1.);

    void UpdateTimestep(int t, bool update_fwd, bool update_bwd,
                        int max_relocation_iterations, double tolerance, bool force_relocation,
                        double max_step_size = -1.);

    void UpdateTimestepGaussNewton(int t, bool update_fwd, bool update_bwd,
                                   int max_relocation_iterations, double tolerance, double max_step_size = -1.);

    double EvaluateTrajectory(const std::vector<Eigen::VectorXd>& x, bool skip_update = false);

    void RememberOldState();

    void PerhapsUndoStep();

    double GetTaskCosts(int t);

    double Step();
};
}  // namespace exotica

#endif  // EXOTICA_AICO_SOLVER_AICO_SOLVER_H_