IpBacktrackingLineSearch.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpBacktrackingLineSearch.hpp 759 2006-07-07 03:07:08Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
//           Andreas Waechter                 IBM    2005-10-13
//               derived file from IpFilterLineSearch.hpp

#ifndef __IPBACKTRACKINGLINESEARCH_HPP__
#define __IPBACKTRACKINGLINESEARCH_HPP__

#include "IpLineSearch.hpp"
#include "IpBacktrackingLSAcceptor.hpp"
#include "IpRestoPhase.hpp"
#include "IpConvCheck.hpp"

namespace Ipopt
{

  class BacktrackingLineSearch : public LineSearch
  {
  public:
    BacktrackingLineSearch(const SmartPtr<BacktrackingLSAcceptor>& acceptor,
                           const SmartPtr<RestorationPhase>& resto_phase,
                           const SmartPtr<ConvergenceCheck>& conv_check
                          );

    virtual ~BacktrackingLineSearch();

    virtual bool InitializeImpl(const OptionsList& options,
                                const std::string& prefix);

    virtual void FindAcceptableTrialPoint();

    virtual void Reset();

    virtual void SetRigorousLineSearch(bool rigorous)
    {
      rigorous_ = rigorous;
    }

    virtual bool CheckSkippedLineSearch()
    {
      return skipped_line_search_;
    }

    virtual bool ActivateFallbackMechanism();

    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);

  private:
    BacktrackingLineSearch(const BacktrackingLineSearch&);

    void operator=(const BacktrackingLineSearch&);

    bool DoBacktrackingLineSearch(bool skip_first_trial_point,
                                  Number& alpha_primal,
                                  bool& corr_taken,
                                  bool& soc_taken,
                                  Index& n_steps,
                                  bool& evaluation_error,
                                  SmartPtr<IteratesVector>& actual_delta);

    void StartWatchDog();

    void StopWatchDog(SmartPtr<IteratesVector>& actual_delta);

    bool CheckAcceptabilityOfTrialPoint(Number alpha_primal);

    //ToDo This should probably not be a static member function if we want to
    //     allow for different relaxation parameters values
    static bool Compare_le(Number lhs, Number rhs, Number BasVal);

    void PerformDualStep(Number alpha_primal,
                         Number alpha_dual,
                         SmartPtr<IteratesVector>& delta);

    bool TrySoftRestoStep(SmartPtr<IteratesVector>& actual_delta,
                          bool &satisfies_original_criterion);

    bool TrySecondOrderCorrection(Number alpha_primal_test,
                                  Number& alpha_primal,
                                  SmartPtr<IteratesVector>& actual_delta);

    bool TryCorrector(Number alpha_primal_test,
                      Number& alpha_primal,
                      SmartPtr<IteratesVector>& actual_delta);

    void PerformMagicStep();

    bool DetectTinyStep();

    void StoreAcceptablePoint();

    bool RestoreAcceptablePoint();

    bool CurrentIsAcceptable();

    Number alpha_red_factor_;

    enum AlphaForYEnum {
      PRIMAL_ALPHA_FOR_Y=0,
      DUAL_ALPHA_FOR_Y,
      MIN_ALPHA_FOR_Y,
      MAX_ALPHA_FOR_Y,
      FULL_STEP_FOR_Y,
      MIN_DUAL_INFEAS_ALPHA_FOR_Y,
      SAFE_MIN_DUAL_INFEAS_ALPHA_FOR_Y
    };
    AlphaForYEnum alpha_for_y_;

    Number soft_resto_pderror_reduction_factor_;
    Index max_soft_resto_iters_;

    bool magic_steps_;
    bool accept_every_trial_step_;
    bool expect_infeasible_problem_;
    Number expect_infeasible_problem_ctol_;

    Number tiny_step_tol_;

    Number tiny_step_y_tol_;

    Index watchdog_trial_iter_max_;
    Index watchdog_shortened_iter_trigger_;

    bool start_with_resto_;

    bool in_watchdog_;
    Index watchdog_shortened_iter_;
    Index watchdog_trial_iter_;
    Number watchdog_alpha_primal_test_;
    SmartPtr<const IteratesVector> watchdog_iterate_;
    SmartPtr<const IteratesVector> watchdog_delta_;
    Number last_mu_;

    SmartPtr<const IteratesVector> acceptable_iterate_;
    Index acceptable_iteration_number_;

    bool fallback_activated_;

    bool rigorous_;

    bool skipped_line_search_;

    bool in_soft_resto_phase_;

    Index soft_resto_counter_;

    Index count_successive_shortened_steps_;

    bool tiny_step_last_iteration_;

    SmartPtr<BacktrackingLSAcceptor> acceptor_;
    SmartPtr<RestorationPhase> resto_phase_;
    SmartPtr<ConvergenceCheck> conv_check_;
  };

} // namespace Ipopt

#endif