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.
//
// 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_;
 
 
   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_;
   PiecewisePenalty PiecewisePenalty_;
   bool reset_piecewise_penalty_;
 
   Index jump_for_tiny_step_;
 
   SmartPtr<PDSystemSolver> pd_solver_;
};
 
} // namespace Ipopt
 
#endif