Amesos2_Control.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//           Amesos2: Templated Direct Sparse Solver Package
//
// Copyright 2011 NTESS and the Amesos2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef AMESOS2_CONTROL_HPP
#define AMESOS2_CONTROL_HPP
 
#include <Teuchos_ParameterList.hpp>
#include <Teuchos_RCP.hpp>
 
namespace Amesos2 {
 
 
struct Control {
  Control()
    : verbose_(0)
    , debug_(0)
    , useTranspose_(false)
    , useIterRefine_(false)
    , maxNumIterRefines_(2)
    , verboseIterRefine_(false)
    , addToDiag_("0.0")
    , addZeroToDiag_(false)
    , matrixProperty_(0)
    , rcond_threshold_(1e-12)
    , refactorize_(false)
    , scaleMethod_(0)
    , reindex_(false)
    { }
 
  ~Control() { };
 
  void setControlParameters(
    const Teuchos::RCP<Teuchos::ParameterList> & parameterList );
 
  int verbose_;
 
  int debug_;
 
 
  bool useTranspose_;
 
  bool useIterRefine_;
 
  int maxNumIterRefines_;
 
  bool verboseIterRefine_;
 
  std::string addToDiag_;
 
 
  bool addZeroToDiag_;
 
 
  int matrixProperty_;
 
 
  double rcond_threshold_; // if we refactorize, the factorization
  // may suffer in numeric quality.  We
  // compute rcond = min (abs (diag (U))) /
  // max (abs(diag (U))).  If this ratio is
  // <= rcond_threshold_, then the
  // "refactorization" is scrapped, and we
  // factor with full partial pivoting
  // instead.
 
 
  bool refactorize_; // if true, and if the Symbolic and Numeric
  // objects have already been created, then
  // attempt to "refactorize" (factor the matrix
  // with no changes to the pivot order since the
  // last call the klu_btf_factor).
 
 
  int scaleMethod_; // Most methods (klu, UMFPACK, Mumps, ...) can
  // scale the input matrix prior to
  // factorization.  This can improve pivoting,
  // reduces fill-in, and leads to a better
  // quality factorization.  The options are:
  // 0: no scaling
  // 1: use the default method for the specific
  // package
  // 2: use the method's 1st alternative (if it
  // has one)
  // 3: use the method's 2nd alternative, and so
  // on.
  //
  // Amesos2_Klu is, at present, the only code
  // which implements this
 
 
  bool reindex_;
 
};                              // end class Control
 
 
} // end namespace Amesos2
 
#endif  // AMESOS2_CONTROL_HPP