MoochoPack_NLPAlgoState.hpp

Go to the documentation of this file.

// @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.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef RSQP_STATE_H
#define RSQP_STATE_H

#include <deque>

#include "MoochoPack_Types.hpp"
#include "IterationPack_IterQuantityAccess.hpp"
#include "IterationPack_AlgorithmState.hpp"
#include "IterationPack_cast_iq.hpp"
#include "IterationPack_IterQuantityAccessContiguous.hpp"
#include "AbstractLinAlgPack_VectorSpace.hpp"
#include "AbstractLinAlgPack_Permutation.hpp"
#include "ConstrainedOptPack_DecompositionSystem.hpp"
#include "AbstractLinAlgPack_MatrixOp.hpp"
//#include "DenseLinAlgPack_IVector.hpp"
#include "Teuchos_StandardCompositionMacros.hpp"
#include "Teuchos_StandardMemberCompositionMacros.hpp"

namespace MoochoPack {


// Iteration Info
extern const std::string num_basis_name;
// NLP Problem Info 
extern const std::string x_name;
extern const std::string f_name;
extern const std::string Gf_name;
extern const std::string HL_name;
extern const std::string c_name;
extern const std::string h_name;
extern const std::string Gc_name;
// Constraint Gradient Null Space / Range Space Decomposition Info
extern const std::string Y_name;
extern const std::string Z_name;
extern const std::string R_name;
extern const std::string Uy_name;
extern const std::string Uz_name;
// Search Direction Info
extern const std::string py_name;
extern const std::string Ypy_name;
extern const std::string pz_name;
extern const std::string Zpz_name;
extern const std::string d_name;
// Reduced QP Subproblem Info
extern const std::string rGf_name;
extern const std::string rHL_name;
extern const std::string w_name;
extern const std::string zeta_name;
extern const std::string qp_grad_name;
extern const std::string eta_name;
// Global Convergence Info
extern const std::string alpha_name;
extern const std::string merit_func_nlp_name;
extern const std::string mu_name;
extern const std::string phi_name;
// KKT Info
extern const std::string opt_kkt_err_name;
extern const std::string feas_kkt_err_name;
extern const std::string comp_kkt_err_name;
extern const std::string GL_name;
extern const std::string rGL_name;
extern const std::string lambda_name;
extern const std::string nu_name;



#define STATE_IQ_DECL(TYPE,NAME)                                          \
  virtual IterQuantityAccess<TYPE>&       NAME();                       \
  virtual const IterQuantityAccess<TYPE>& NAME() const;                 \
private:                                                                  \
  iq_id_encap NAME ## _iq_id_;                                          \
public:

#define STATE_INDEX_IQ_DECL(NAME)                                    \
    STATE_IQ_DECL(index_type,NAME)                                   \


#define STATE_SCALAR_IQ_DECL(NAME)                                   \
    STATE_IQ_DECL(value_type,NAME)                                   \


#define STATE_VECTOR_IQ_DECL(NAME)                                   \
    STATE_IQ_DECL(VectorMutable,NAME)                          \


#define STATE_IQ_DEF(CLASS,TYPE,NAME,NAME_STR)                            \
IterQuantityAccess<TYPE>&                                                 \
CLASS::NAME()                                                             \
{                                                                         \
  update_iq_id( NAME_STR, &NAME ## _iq_id_ );                           \
  return IterationPack::cast_iq<TYPE>(                           \
        *this, NAME ## _iq_id_.iq_id, NAME_STR );                         \
}                                                                         \
const IterQuantityAccess<TYPE>&                                           \
CLASS::NAME() const                                                       \
{                                                                         \
  return const_cast<CLASS*>(this)->NAME();                              \
}

#define STATE_INDEX_IQ_DEF(CLASS,NAME,NAME_STR)                           \
IterQuantityAccess<index_type>&                                           \
CLASS::NAME()                                                             \
{                                                                         \
  update_index_type_iq_id( NAME_STR, &NAME ## _iq_id_ );                \
  return IterationPack::cast_iq<index_type>(                     \
        *this, NAME ## _iq_id_.iq_id, NAME_STR );                         \
}                                                                         \
const IterQuantityAccess<index_type>&                                     \
CLASS::NAME() const                                                       \
{                                                                         \
  return const_cast<CLASS*>(this)->NAME();                              \
}

#define STATE_SCALAR_IQ_DEF(CLASS,NAME,NAME_STR)                          \
IterQuantityAccess<value_type>&                                           \
CLASS::NAME()                                                             \
{                                                                         \
  update_value_type_iq_id( NAME_STR, &NAME ## _iq_id_ );                \
  return IterationPack::cast_iq<value_type>(                     \
        *this, NAME ## _iq_id_.iq_id, NAME_STR );                         \
}                                                                         \
const IterQuantityAccess<value_type>&                                     \
CLASS::NAME() const                                                       \
{                                                                         \
  return const_cast<CLASS*>(this)->NAME();                              \
}

#define STATE_VECTOR_IQ_DEF(CLASS,NAME,NAME_STR,VEC_SPC,VEC_RN)           \
IterQuantityAccess<VectorMutable>&                                  \
CLASS::NAME()                                                             \
{                                                                         \
    update_vector_iq_id( NAME_STR, VEC_SPC, VEC_RN, &NAME ## _iq_id_ );   \
  return IterationPack::cast_iq<VectorMutable>(            \
        *this, NAME ## _iq_id_.iq_id, NAME_STR );                         \
}                                                                         \
const IterQuantityAccess<VectorMutable>&                            \
CLASS::NAME() const                                                       \
{                                                                         \
  return const_cast<CLASS*>(this)->NAME();                          \
}


class NLPAlgoState
  : public IterationPack::AlgorithmState // doxygen needs full path
{
public:


  class InvalidType : public std::logic_error
  {public: InvalidType(const std::string& what_arg) : std::logic_error(what_arg) {}};
  
  typedef Teuchos::RCP<const VectorSpace>    vec_space_ptr_t;


protected:

  // /////////////////////////////
  // Protected types.

  struct iq_id_encap {
    iq_id_encap() : iq_id(DOES_NOT_EXIST) {}
    iq_id_type iq_id;
  };

public:


  // ToDo: Implement all set_space_xx methods to update factories
  // for all vector iteration quantities.

  STANDARD_COMPOSITION_MEMBERS( DecompositionSystem, decomp_sys );
  STANDARD_CONST_COMPOSITION_MEMBERS( VectorSpace, space_x );
  STANDARD_CONST_COMPOSITION_MEMBERS( VectorSpace, space_c );
  void set_space_range (const vec_space_ptr_t& space_range );
  vec_space_ptr_t& get_space_range();
  const vec_space_ptr_t& get_space_range() const;
  const VectorSpace& space_range() const;
  void set_space_null (const vec_space_ptr_t& space_null );
  vec_space_ptr_t& get_space_null();
  const vec_space_ptr_t& get_space_null() const;
  const VectorSpace& space_null() const;

  NLPAlgoState(
    const decomp_sys_ptr_t& decomp_sys   = Teuchos::null
    ,const vec_space_ptr_t& space_x      = Teuchos::null
    ,const vec_space_ptr_t& space_c      = Teuchos::null
    ,const vec_space_ptr_t& space_range  = Teuchos::null
    ,const vec_space_ptr_t& space_null   = Teuchos::null
    );

  virtual ~NLPAlgoState() {}



  STATE_INDEX_IQ_DECL(num_basis)
  
  //@}

  

  STATE_VECTOR_IQ_DECL(x)
  STATE_SCALAR_IQ_DECL(f)
  STATE_VECTOR_IQ_DECL(Gf)
  STATE_IQ_DECL(MatrixSymOp,HL)
  STATE_VECTOR_IQ_DECL(c)
  STATE_IQ_DECL(MatrixOp,Gc)



  STATE_IQ_DECL(MatrixOp,Y)
  STATE_IQ_DECL(MatrixOp,Z)
  STATE_IQ_DECL(MatrixOpNonsing,R)
  STATE_IQ_DECL(MatrixOp,Uy)
  STATE_IQ_DECL(MatrixOp,Uz)



  STATE_VECTOR_IQ_DECL(py)
  STATE_VECTOR_IQ_DECL(Ypy)
  STATE_VECTOR_IQ_DECL(pz)
  STATE_VECTOR_IQ_DECL(Zpz)
  STATE_VECTOR_IQ_DECL(d)



  STATE_VECTOR_IQ_DECL(rGf)
  STATE_IQ_DECL(MatrixSymOp,rHL)
  STATE_VECTOR_IQ_DECL(w)
  STATE_SCALAR_IQ_DECL(zeta)
  STATE_VECTOR_IQ_DECL(qp_grad)
  STATE_SCALAR_IQ_DECL(eta)



  STATE_SCALAR_IQ_DECL(alpha)
  STATE_IQ_DECL(MeritFuncNLP,merit_func_nlp)
  STATE_SCALAR_IQ_DECL(mu)
  STATE_SCALAR_IQ_DECL(phi)



  STATE_SCALAR_IQ_DECL(opt_kkt_err)
  STATE_SCALAR_IQ_DECL(feas_kkt_err)
  STATE_SCALAR_IQ_DECL(comp_kkt_err)
  STATE_VECTOR_IQ_DECL(GL)
  STATE_VECTOR_IQ_DECL(rGL)
  STATE_VECTOR_IQ_DECL(lambda)
  STATE_VECTOR_IQ_DECL(nu)



  STANDARD_MEMBER_COMPOSITION_MEMBERS( Range1D, var_dep );
  STANDARD_MEMBER_COMPOSITION_MEMBERS( Range1D, var_indep );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( Range1D, equ_decomp );
  STANDARD_MEMBER_COMPOSITION_MEMBERS( Range1D, equ_undecomp );



  STANDARD_COMPOSITION_MEMBERS( Permutation, P_var_current );
  STANDARD_COMPOSITION_MEMBERS( Permutation, P_var_last );
  STANDARD_COMPOSITION_MEMBERS( Permutation, P_equ_current );
  STANDARD_COMPOSITION_MEMBERS( Permutation, P_equ_last );


protected:

  enum { NUM_VEC_SPACE_TYPES = 5 };
  enum EVecSpaceType {
    VST_SPACE_X       = 0
    ,VST_SPACE_C      = 1
    ,VST_SPACE_RANGE  = 2
    ,VST_SPACE_NULL   = 3
  };

  // /////////////////////////////
  // Protected member functions

  // These implementations are used to avoid code blot and help in debugging
  // (can't debug macros very well).

  void update_iq_id(
    const std::string&                iq_name
    ,iq_id_encap*                     iq_id
    ) const;
  void update_index_type_iq_id(
    const std::string&                iq_name
    ,iq_id_encap*                     iq_id
    );
  void update_value_type_iq_id(
    const std::string&                iq_name
    ,iq_id_encap*                     iq_id
    );
  void update_vector_iq_id(
    const std::string&                iq_name
    ,const VectorSpace::space_ptr_t&  vec_space
    ,EVecSpaceType                    vec_space_type
    ,iq_id_encap*                     iq_id
    );

private:

  // ////////////////////////////
  // Private types

  typedef std::deque<iq_id_type>  iq_vector_list_t;
  
  // ////////////////////////////
  // Private data member

  vec_space_ptr_t    space_range_;
  vec_space_ptr_t    space_null_;

  iq_vector_list_t   vector_iqs_lists_[NUM_VEC_SPACE_TYPES];

  // ////////////////////////////
  // Private member functions.
  
  // Update the vector factories for all of the iteration quantities
  // in the input list.
  void update_vector_factories(
    EVecSpaceType             vec_space_type
    ,const vec_space_ptr_t&   vec_space
    );

  // not defined and not to be called
  NLPAlgoState(const NLPAlgoState&);
  NLPAlgoState& operator=(const NLPAlgoState&);

};  // end class NLPAlgoState

// ////////////////////////////////////
// Inline members

inline
NLPAlgoState::vec_space_ptr_t& NLPAlgoState::get_space_range()
{ return space_range_ ; }

inline
const NLPAlgoState::vec_space_ptr_t& NLPAlgoState::get_space_range() const
{ return space_range_; }

inline
const VectorSpace& NLPAlgoState::space_range() const
{ return *space_range_; }

inline
NLPAlgoState::vec_space_ptr_t& NLPAlgoState::get_space_null()
{ return space_null_ ; }

inline
const NLPAlgoState::vec_space_ptr_t& NLPAlgoState::get_space_null() const
{ return space_null_; }

inline
const VectorSpace& NLPAlgoState::space_null() const
{ return *space_null_; }

} // end namespace MoochoPack

#endif  // RSQP_STATE_H