IpCGPenaltyLSAcceptor.hpp

Go to the documentation of this file.

// Copyright (C) 2005, 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpCGPenaltyLSAcceptor.hpp 1861 2010-12-21 21:34:47Z andreasw $
//
// Authors:  Andreas Waechter                 IBM    2005-10-13

#ifndef __IPCGPENALTYLSACCEPTOR_HPP__
#define __IPCGPENALTYLSACCEPTOR_HPP__

#include "IpPiecewisePenalty.hpp"
#include "IpBacktrackingLSAcceptor.hpp"
#include "IpPDSystemSolver.hpp"
#include "IpIpoptAlg.hpp"
#include "IpCGPenaltyCq.hpp"

namespace Ipopt
{

  class CGPenaltyLSAcceptor : public BacktrackingLSAcceptor
  {
  public:
    CGPenaltyLSAcceptor(const SmartPtr<PDSystemSolver>& pd_solver);

    virtual ~CGPenaltyLSAcceptor();

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

    virtual void Reset();

    virtual void InitThisLineSearch(bool in_watchdog);

    virtual void PrepareRestoPhaseStart();

    virtual Number CalculateAlphaMin();

    virtual bool CheckAcceptabilityOfTrialPoint(Number alpha_primal);

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

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

    virtual char UpdateForNextIteration(Number alpha_primal_test);

    virtual void StartWatchDog();

    virtual void StopWatchDog();

    virtual bool RestoredIterate();
    virtual bool NeverRestorationPhase();

    virtual bool DoFallback();

    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);

  private:
    CGPenaltyLSAcceptor(const CGPenaltyLSAcceptor&);

    void operator=(const CGPenaltyLSAcceptor&);

    CGPenaltyData& CGPenData()
    {
      CGPenaltyData& cg_pen_data =
        static_cast<CGPenaltyData&>(IpData().AdditionalData());
      DBG_ASSERT(dynamic_cast<CGPenaltyData*>(&IpData().AdditionalData()));
      return cg_pen_data;
    }

    CGPenaltyCq& CGPenCq()
    {
      CGPenaltyCq& cg_pen_cq =
        static_cast<CGPenaltyCq&>(IpCq().AdditionalCq());
      DBG_ASSERT(dynamic_cast<CGPenaltyCq*>(&IpCq().AdditionalCq()));
      return cg_pen_cq;
    }

    bool IsAcceptableToPiecewisePenalty(Number alpha_primal_test);

    bool ArmijoHolds(Number alpha_primal_test);

    //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);

    bool CurrentIsBest();
    void StoreBestPoint();
    bool RestoreBestPoint();
    bool MultipliersDiverged();
    char UpdatePenaltyParameter();

    Number eta_penalty_;
    Number penalty_update_infeasibility_tol_;
    Number eta_min_;
    Number penalty_update_compl_tol_;
    Number chi_hat_;
    Number chi_tilde_;
    Number chi_cup_;
    Number gamma_hat_;
    Number gamma_tilde_;
    Number penalty_max_;
    Number epsilon_c_;
    Number piecewisepenalty_gamma_obj_;
    Number piecewisepenalty_gamma_infeasi_;

    Number pen_theta_max_;
    Number pen_theta_max_fact_;
    // Number used to indicate that mu has been decreased
    Number pen_curr_mu_;

    Number theta_min_;

    bool accepted_by_Armijo_;

    Number min_alpha_primal_;

    /*Initial constraint violation*/
    Number reference_theta_;

    Index max_soc_;
    Number kappa_soc_;

    Index counter_first_type_penalty_updates_;
    Index counter_second_type_penalty_updates_;
    Number curr_eta_;

    Index ls_counter_;
    Number best_KKT_error_;
    SmartPtr<const IteratesVector> best_iterate_;
    Number mult_diverg_feasibility_tol_;
    Number mult_diverg_y_tol_;

    Number reference_penalty_function_;
    Number reference_direct_deriv_penalty_function_;
    Number reference_curr_direct_f_nrm_;
    Number watchdog_penalty_function_;
    Number watchdog_direct_deriv_penalty_function_;
    SmartPtr<const IteratesVector> watchdog_delta_cgpen_;

    bool never_use_piecewise_penalty_ls_;
    // piecewise penalty list
    PiecewisePenalty PiecewisePenalty_;
    bool reset_piecewise_penalty_;

    Index jump_for_tiny_step_;

    SmartPtr<PDSystemSolver> pd_solver_;
  };





} // namespace Ipopt

#endif