IpInexactLSAcceptor.hpp

Go to the documentation of this file.

// Copyright (C) 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpInexactLSAcceptor.hpp 1861 2010-12-21 21:34:47Z andreasw $
//
// Authors:  Andreas Waechter                 IBM    2008-09-11
//               derived file from IpPenaltyLSAcceptor.hpp (rev 019)

#ifndef __IPINEXACTLSACCEPTOR_HPP__
#define __IPINEXACTLSACCEPTOR_HPP__

#include "IpBacktrackingLSAcceptor.hpp"
#include "IpInexactCq.hpp"

namespace Ipopt
{

  class InexactLSAcceptor : public BacktrackingLSAcceptor
  {
  public:
    InexactLSAcceptor();

    virtual ~InexactLSAcceptor();

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

    bool IsAcceptableToCurrentIterate(Number trial_barr, Number trial_theta,
                                      bool called_from_restoration=false) const;

    virtual Number ComputeAlphaForY(Number alpha_primal,
                                    Number alpha_dual,
                                    SmartPtr<IteratesVector>& delta);

    virtual bool HasComputeAlphaForY() const
    {
      return true;
    }

    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);

  protected:
    InexactData& InexData()
    {
      InexactData& inexact_data =
        static_cast<InexactData&>(IpData().AdditionalData());
      DBG_ASSERT(dynamic_cast<InexactData*>(&IpData().AdditionalData()));
      return inexact_data;
    }

    InexactCq& InexCq()
    {
      InexactCq& inexact_cq =
        static_cast<InexactCq&>(IpCq().AdditionalCq());
      DBG_ASSERT(dynamic_cast<InexactCq*>(&IpCq().AdditionalCq()));
      return inexact_cq;
    }

  private:
    InexactLSAcceptor(const InexactLSAcceptor&);

    void operator=(const InexactLSAcceptor&);

    Number CalcPred(Number alpha);

    void ResetSlacks();

    Number nu_init_;
    Number nu_low_init_;
    Number nu_low_fact_;
    Number nu_inc_;
    Number eta_;
    Number rho_;
    Number tcc_theta_;
    Number nu_update_inf_skip_tol_;
    bool flexible_penalty_function_;

    Number reference_theta_;
    Number reference_barr_;
    Number reference_pred_;
    Number watchdog_theta_;
    Number watchdog_barr_;
    Number watchdog_pred_;

    Number nu_;
    Number last_nu_;
    Number nu_low_;
    Number last_nu_low_;
    Number inexact_decomposition_activate_tol_;
    Number inexact_decomposition_inactivate_tol_;

    bool in_tt2_;

    Number resto_pred_;

    bool accepted_by_low_only_;
  };

} // namespace Ipopt

#endif