IpCGPenaltyData.hpp

Go to the documentation of this file.

// Copyright (C) 2007, 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Andreas Waechter           IBM     2007-06-04
//                   based on IpIpoptData.hpp
 
#ifndef __IPCGPENALTYDATA_HPP__
#define __IPCGPENALTYDATA_HPP__
 
#include "IpIteratesVector.hpp"
#include "IpOptionsList.hpp"
#include "IpIpoptData.hpp"
 
namespace Ipopt
{
 
class CGPenaltyData: public IpoptAdditionalData
{
public:
 
   CGPenaltyData();
 
   ~CGPenaltyData();
 
   bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix);
 
   bool InitializeDataStructures();
 
   SmartPtr<const IteratesVector> delta_cgpen() const;
 
   void set_delta_cgpen(
      SmartPtr<IteratesVector>& delta_pen
   );
 
   void set_delta_cgpen(
      SmartPtr<const IteratesVector>& delta_pen
   );
 
   SmartPtr<const IteratesVector> delta_cgfast() const;
 
   void set_delta_cgfast(
      SmartPtr<IteratesVector>& delta_fast
   );
 
   bool HaveCgPenDeltas() const
   {
      return have_cgpen_deltas_;
   }
 
   void SetHaveCgPenDeltas(
      bool have_cgpen_deltas
   )
   {
      have_cgpen_deltas_ = have_cgpen_deltas;
   }
 
   bool HaveCgFastDeltas() const
   {
      return have_cgfast_deltas_;
   }
 
   void SetHaveCgFastDeltas(
      bool have_cgfast_deltas
   )
   {
      have_cgfast_deltas_ = have_cgfast_deltas;
   }
 
 
   void AcceptTrialPoint();
 
   Number CurrPenaltyPert()
   {
      return curr_penalty_pert_;
   }
 
   void SetCurrPenaltyPert(
      Number curr_penalty_pert)
   {
      curr_penalty_pert_ = curr_penalty_pert;
   }
 
   void SetNeverTryPureNewton(
      bool never_try_pure_Newton
   )
   {
      never_try_pure_Newton_ = never_try_pure_Newton;
   }
 
   Index NeverTryPureNewton()
   {
      return never_try_pure_Newton_;
   }
 
   Index restor_iter()
   {
      return restor_iter_;
   }
 
   void SetRestorIter(
      Index restor_iter
   )
   {
      restor_iter_ = restor_iter;
   }
 
   Number restor_counter()
   {
      return restor_counter_;
   }
 
   void SetRestorCounter(
      Number restor_counter
   )
   {
      restor_counter_ = restor_counter;
   }
 
   void SetPrimalStepSize(
      Number max_alpha_x
   )
   {
      max_alpha_x_ = max_alpha_x;
   }
 
   Number PrimalStepSize()
   {
      return max_alpha_x_;
   }
 
   Number curr_penalty() const
   {
      DBG_ASSERT(penalty_initialized_);
      return curr_penalty_;
   }
 
   void Set_penalty(
      Number penalty
   )
   {
      curr_penalty_ = penalty;
      penalty_initialized_ = true;
   }
 
   void SetPenaltyUninitialized()
   {
      penalty_initialized_ = false;
   }
 
   bool PenaltyInitialized() const
   {
      return penalty_initialized_;
   }
 
   Number curr_kkt_penalty() const
   {
      DBG_ASSERT(kkt_penalty_initialized_);
      return curr_kkt_penalty_;
   }
 
   void Set_kkt_penalty(
      Number kkt_penalty
   )
   {
      curr_kkt_penalty_ = kkt_penalty;
      kkt_penalty_initialized_ = true;
   }
 
   void SetKKTPenaltyUninitialized()
   {
      kkt_penalty_initialized_ = false;
   }
 
   bool KKTPenaltyInitialized() const
   {
      return kkt_penalty_initialized_;
   }
 
private:
 
   SmartPtr<const IteratesVector> delta_cgpen_;
 
   // ToDo we could cue off of a null delta_cgpen_
   bool have_cgpen_deltas_;
 
   SmartPtr<const IteratesVector> delta_cgfast_;
 
   // ToDo we could cue off of a null delta_cgfast_
   bool have_cgfast_deltas_;
 
 
   bool never_try_pure_Newton_;
 
   Index restor_iter_;
   Number restor_counter_;
 
   Number curr_penalty_;
   bool penalty_initialized_;
   Number curr_kkt_penalty_;
   bool kkt_penalty_initialized_;
   Number curr_penalty_pert_;
   Number max_alpha_x_;
 
   bool initialize_called_;
 
 
   CGPenaltyData(
      const CGPenaltyData&
   );
 
   void operator=(
      const CGPenaltyData&
   );
 
#if IPOPT_CHECKLEVEL > 0
   TaggedObject::Tag debug_delta_cgpen_tag_;
   TaggedObject::Tag debug_delta_cgfast_tag_;
   TaggedObject::Tag debug_delta_cgpen_tag_sum_;
   TaggedObject::Tag debug_delta_cgfast_tag_sum_;
#endif
 
};
 
inline SmartPtr<const IteratesVector> CGPenaltyData::delta_cgpen() const
{
   DBG_ASSERT(IsNull(delta_cgpen_) || (delta_cgpen_->GetTag() == debug_delta_cgpen_tag_ && delta_cgpen_->GetTagSum() == debug_delta_cgpen_tag_sum_) );
 
   return delta_cgpen_;
}
 
inline SmartPtr<const IteratesVector> CGPenaltyData::delta_cgfast() const
{
   DBG_ASSERT(IsNull(delta_cgfast_) || (delta_cgfast_->GetTag() == debug_delta_cgfast_tag_ && delta_cgfast_->GetTagSum() == debug_delta_cgfast_tag_sum_) );
 
   return delta_cgfast_;
}
 
inline
void CGPenaltyData::set_delta_cgpen(
   SmartPtr<IteratesVector>& delta_cgpen
)
{
   delta_cgpen_ = ConstPtr(delta_cgpen);
#if IPOPT_CHECKLEVEL > 0
 
   if (IsValid(delta_cgpen))
   {
      debug_delta_cgpen_tag_ = delta_cgpen->GetTag();
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
   }
   else
   {
      debug_delta_cgpen_tag_ = 0;
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
   }
#endif
 
   delta_cgpen = NULL;
}
 
inline
void CGPenaltyData::set_delta_cgpen(
   SmartPtr<const IteratesVector>& delta_cgpen
)
{
   delta_cgpen_ = delta_cgpen;
#if IPOPT_CHECKLEVEL > 0
 
   if (IsValid(delta_cgpen))
   {
      debug_delta_cgpen_tag_ = delta_cgpen->GetTag();
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
   }
   else
   {
      debug_delta_cgpen_tag_ = 0;
      debug_delta_cgpen_tag_sum_ = delta_cgpen->GetTagSum();
   }
#endif
 
   delta_cgpen = NULL;
}
 
inline
void CGPenaltyData::set_delta_cgfast(
   SmartPtr<IteratesVector>& delta_cgfast
)
{
   delta_cgfast_ = ConstPtr(delta_cgfast);
#if IPOPT_CHECKLEVEL > 0
 
   if (IsValid(delta_cgfast))
   {
      debug_delta_cgfast_tag_ = delta_cgfast->GetTag();
      debug_delta_cgfast_tag_sum_ = delta_cgfast->GetTagSum();
   }
   else
   {
      debug_delta_cgfast_tag_ = 0;
      debug_delta_cgfast_tag_sum_ = delta_cgfast->GetTagSum();
   }
#endif
 
   delta_cgfast = NULL;
}
 
} // namespace Ipopt
 
#endif