IpStdAugSystemSolver.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpStdAugSystemSolver.hpp 1861 2010-12-21 21:34:47Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IP_STDAUGSYSTEMSOLVER_HPP__
#define __IP_STDAUGSYSTEMSOLVER_HPP__
 
#include "IpAugSystemSolver.hpp"
#include "IpCompoundMatrix.hpp"
#include "IpCompoundSymMatrix.hpp"
#include "IpCompoundVector.hpp"
#include "IpSumSymMatrix.hpp"
#include "IpDiagMatrix.hpp"
#include "IpIdentityMatrix.hpp"
 
namespace Ipopt
{
  class StdAugSystemSolver : public AugSystemSolver
  {
  public:
    StdAugSystemSolver(SymLinearSolver& LinSolver);
 
    virtual ~StdAugSystemSolver();
 
    bool InitializeImpl(const OptionsList& options,
                        const std::string& prefix);
 
    virtual ESymSolverStatus MultiSolve(
      const SymMatrix* W,
      double W_factor,
      const Vector* D_x,
      double delta_x,
      const Vector* D_s,
      double delta_s,
      const Matrix* J_c,
      const Vector* D_c,
      double delta_c,
      const Matrix* J_d,
      const Vector* D_d,
      double delta_d,
      std::vector<SmartPtr<const Vector> >& rhs_xV,
      std::vector<SmartPtr<const Vector> >& rhs_sV,
      std::vector<SmartPtr<const Vector> >& rhs_cV,
      std::vector<SmartPtr<const Vector> >& rhs_dV,
      std::vector<SmartPtr<Vector> >& sol_xV,
      std::vector<SmartPtr<Vector> >& sol_sV,
      std::vector<SmartPtr<Vector> >& sol_cV,
      std::vector<SmartPtr<Vector> >& sol_dV,
      bool check_NegEVals,
      Index numberOfNegEVals);
 
    virtual Index NumberOfNegEVals() const;
 
    virtual bool ProvidesInertia() const;
 
    virtual bool IncreaseQuality();
 
  private:
    StdAugSystemSolver();
    StdAugSystemSolver(const StdAugSystemSolver&);
 
    void operator=(const StdAugSystemSolver&);
 
 
    void CreateAugmentedSpace(const SymMatrix& W,
                              const Matrix& J_c,
                              const Matrix& J_d,
                              const Vector& proto_x,
                              const Vector& proto_s,
                              const Vector& proto_c,
                              const Vector& proto_d);
 
 
    void CreateAugmentedSystem(const SymMatrix* W,
                               double W_factor,
                               const Vector* D_x,
                               double delta_x,
                               const Vector* D_s,
                               double delta_s,
                               const Matrix& J_c,
                               const Vector* D_c,
                               double delta_c,
                               const Matrix& J_d,
                               const Vector* D_d,
                               double delta_d,
                               const Vector& proto_x,
                               const Vector& proto_s,
                               const Vector& proto_c,
                               const Vector& proto_d);
 
    bool AugmentedSystemRequiresChange(const SymMatrix* W,
                                       double W_factor,
                                       const Vector* D_x,
                                       double delta_x,
                                       const Vector* D_s,
                                       double delta_s,
                                       const Matrix& J_c,
                                       const Vector* D_c,
                                       double delta_c,
                                       const Matrix& J_d,
                                       const Vector* D_d,
                                       double delta_d);
 
    SmartPtr<SymLinearSolver> linsolver_;
 
    SmartPtr<CompoundSymMatrixSpace> augmented_system_space_;
    SmartPtr<SumSymMatrixSpace> sumsym_space_x_;
    SmartPtr<DiagMatrixSpace> diag_space_x_;
    SmartPtr<DiagMatrixSpace> diag_space_s_;
    SmartPtr<DiagMatrixSpace> diag_space_c_;
    SmartPtr<IdentityMatrixSpace> ident_space_ds_;
    SmartPtr<DiagMatrixSpace> diag_space_d_;
 
    SmartPtr<CompoundVectorSpace> augmented_vector_space_;
 
    TaggedObject::Tag w_tag_;
    double w_factor_;
    TaggedObject::Tag d_x_tag_;
    double delta_x_;
    TaggedObject::Tag d_s_tag_;
    double delta_s_;
    TaggedObject::Tag j_c_tag_;
    TaggedObject::Tag d_c_tag_;
    double delta_c_;
    TaggedObject::Tag j_d_tag_;
    TaggedObject::Tag d_d_tag_;
    double delta_d_;
 
    TaggedObject::Tag augsys_tag_;
 
    SmartPtr<CompoundSymMatrix> augmented_system_;
 
    SmartPtr<const SymMatrix> old_w_;
 
    bool warm_start_same_structure_;
  };
 
} // namespace Ipopt
 
#endif