IpMumpsSolverInterface.hpp

Go to the documentation of this file.

// Copyright (C) 2006, 2007 Damien Hocking, KBC Advanced Technologies
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors: Damien Hocking                 KBC    2006-03-20
//        (included his original contribution into Ipopt package on 2006-03-25)
//          Andreas Waechter               IBM    2006-03-25
//           (minor changes and corrections)
//          Scott Turnberg                 CMU    2006-05-12
//           (major revision)
//           (incorporated by AW on 2006-11-11 into Ipopt package)
 
#ifndef __IPMUMPSSOLVERINTERFACE_HPP__
#define __IPMUMPSSOLVERINTERFACE_HPP__
 
#include "IpSparseSymLinearSolverInterface.hpp"
 
namespace Ipopt
{
 
class MumpsSolverInterface: public SparseSymLinearSolverInterface
{
public:
 
   MumpsSolverInterface();
 
   virtual ~MumpsSolverInterface();
 
   bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual ESymSolverStatus InitializeStructure(
      Index        dim,
      Index        nonzeros,
      const Index* airn,
      const Index* ajcn
   );
 
   virtual double* GetValuesArrayPtr();
 
   virtual ESymSolverStatus MultiSolve(
      bool         new_matrix,
      const Index* airn,
      const Index* ajcn,
      Index        nrhs,
      double*      rhs_vals,
      bool         check_NegEVals,
      Index        numberOfNegEVals
   );
 
   virtual Index NumberOfNegEVals() const;
 
   //* @name Options of Linear solver */
   virtual bool IncreaseQuality();
 
   virtual bool ProvidesInertia() const
   {
      return true;
   }
 
   EMatrixFormat MatrixFormat() const
   {
      return Triplet_Format;
   }
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
   virtual bool ProvidesDegeneracyDetection() const;
 
   virtual ESymSolverStatus DetermineDependentRows(
      const Index*      ia,
      const Index*      ja,
      std::list<Index>& c_deps
   );
 
private:
 
   MumpsSolverInterface(
      const MumpsSolverInterface&
   );
 
   void operator=(
      const MumpsSolverInterface&
   );
 
 
   void* mumps_ptr_;
 
 
   Index negevals_;
 
 
   bool initialized_;
   bool pivtol_changed_;
   bool refactorize_;
   static int instancecount_mpi;
 
 
   Number pivtol_;
 
   Number pivtolmax_;
 
   Index mem_percent_;
 
   Index mumps_permuting_scaling_;
 
   Index mumps_pivot_order_;
 
   Index mumps_scaling_;
 
   Number mumps_dep_tol_;
 
   bool warm_start_same_structure_;
 
   bool have_symbolic_factorization_;
 
 
   ESymSolverStatus SymbolicFactorization();
 
   ESymSolverStatus Factorization(
      bool  check_NegEVals,
      Index numberOfNegEVals
   );
 
   ESymSolverStatus Solve(
      Index   nrhs,
      double* rhs_vals
   );
};
 
} // namespace Ipopt
#endif