MoochoPack_LineSearchFilter_Step.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef LINE_SEARCH_FILTER_STEP_H
#define LINE_SEARCH_FILTER_STEP_H

#include <list>

#include "MoochoPack_Types.hpp"
#include "IterationPack_AlgorithmStep.hpp"
#include "IterationPack_CastIQMember.hpp"
#include "Teuchos_StandardCompositionMacros.hpp"
#include "Teuchos_StandardMemberCompositionMacros.hpp"

#include "IterationPack_AlgorithmState.hpp"

namespace MoochoPack {
 
// structure for storing filter points 
class FilterEntry 
{
public:
  FilterEntry( value_type new_f, value_type new_theta, int new_iter)
    : f(new_f), theta(new_theta), iter(new_iter) {}
    
  value_type f;
  value_type theta;
  int iter;
};

// It is critical that an std::list be used because of the way iterators are
// used!
typedef std::list< FilterEntry > Filter_T;

const std::string FILTER_IQ_STRING = "LS_FilterEntries";

class LineSearchFilter_Step
  : public IterationPack::AlgorithmStep // doxygen needs full path
{
public:
    

  static value_type F_MIN_UNBOUNDED;
  
  
  
  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, gamma_theta );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, gamma_f );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, f_min );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, gamma_alpha );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, delta );
  
  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, s_f );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, s_theta );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, theta_small_fact );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, theta_max );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, eta_f );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, back_track_frac );

  LineSearchFilter_Step(
    Teuchos::RCP<NLPInterfacePack::NLP> nlp
    ,const std::string         obj_iq_name      = "f"
    ,const std::string         grad_obj_iq_name = "Gf"
    ,const value_type          &gamma_theta      = 1e-5
    ,const value_type          &gamma_f          = 1e-5
    ,const value_type          &f_min            = F_MIN_UNBOUNDED
    ,const value_type          &gamma_alpha      = 5e-2
    ,const value_type          &delta            = 1e-4
    ,const value_type          &s_theta          = 1.1
    ,const value_type          &s_f              = 2.3
    ,const value_type          &theta_small_fact = 1e-4 
    ,const value_type          &theta_max        = 1e10
    ,const value_type          &eta_f            = 1e-4
    ,const value_type          &back_track_frac  = 0.5
    );

  
  ~LineSearchFilter_Step();


  bool do_step( Algorithm& algo, poss_type step_poss,
                IterationPack::EDoStepType type,
                poss_type assoc_step_poss);
  void print_step( const Algorithm& algo, poss_type step_poss,
                   IterationPack::EDoStepType type,
                   poss_type assoc_step_poss, std::ostream& out,
                   const std::string& leading_str ) const;

private:

  // /////////////////////////////
  // Private data members

  // Private Data
  CastIQMember<Filter_T> filter_;

  CastIQMember<value_type> obj_f_;

  CastIQMember<VectorMutable> grad_obj_f_;

  // nlp to use for calculations
  Teuchos::RCP<NLPInterfacePack::NLP> nlp_;

  // /////////////////////////////
  // Private member functions

  // Validate input parameters - fix if possible
  bool ValidatePoint(
    const IterQuantityAccess<VectorMutable>& x,
    const IterQuantityAccess<value_type>& f,
    const IterQuantityAccess<VectorMutable>* c,
    const IterQuantityAccess<VectorMutable>* h,
    const bool throw_excpt
    ) const;

  // Check that new point is not within taboo region of filter
  bool CheckFilterAcceptability(
    const value_type f, 
    const value_type theta,
    const AlgorithmState& s
    ) const;
  
  // Check the Armijo condition on f
  bool CheckArmijo(
    const value_type Gf_t_dk, 
    const value_type alpha_k, 
    const IterQuantityAccess<value_type>& f_iq
    ) const;

  // Check if f or c has sufficient reduction
  bool CheckFractionalReduction(
    const IterQuantityAccess<value_type>& f_iq,
    const value_type gamma_f_used,
    const value_type theta_kp1, 
    const value_type theta_k
    ) const;

  // Calculate the new point given d and alpha
  void UpdatePoint(
    const VectorMutable& d,
    value_type alpha, 
    IterQuantityAccess<VectorMutable>& x,
    IterQuantityAccess<value_type>& f,
    IterQuantityAccess<VectorMutable>* c,
    IterQuantityAccess<VectorMutable>* h,
    NLP& nlp
    ) const;

  // Calculate the minimum alpha before hitting restoration phase
  value_type CalculateAlphaMin(
    const value_type gamma_f_used,
    const value_type Gf_t_dk, 
    const value_type theta_k,
    const value_type theta_small
    ) const;

  // Calculate the constraint norm
  value_type CalculateTheta_k(
    const IterQuantityAccess<VectorMutable>* c,
    const IterQuantityAccess<VectorMutable>* h,
    int k
    ) const;

  // Calculate the value of gamma_k to use
  value_type CalculateGammaFUsed(
    const IterQuantityAccess<value_type> &f,
    const value_type theta_k,
    const EJournalOutputLevel olevel,
    std::ostream &out
    ) const;

  // decide if we should switch to Armijo for objective
  bool ShouldSwitchToArmijo(
    const value_type Gf_t_dk,
    const value_type alpha_k,
    const value_type theta_k,
    const value_type theta_small
    ) const;

  // Update the filter from the last iteration
  void UpdateFilter( IterationPack::AlgorithmState& s ) const;

  // Update the filter from the last iteration and Augment it with
  // the new point
  void AugmentFilter(
    const value_type gamma_f_used,
    const value_type f_with_boundary,
    const value_type theta_with_boundary,
    IterationPack::AlgorithmState& s,
    const EJournalOutputLevel olevel,
    std::ostream &out
    ) const;
    
};  // end class LineSearchFilter_Step

} // end namespace MoochoPack 

#endif  // LINE_SEARCH_FILTER_STEP_H