Ifpack2_Details_FastILU_Base_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//       Ifpack2: Templated Object-Oriented Algebraic Preconditioner Package
//
// Copyright 2009 NTESS and the Ifpack2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
 
#ifndef __IFPACK2_FASTILU_BASE_DECL_HPP__
#define __IFPACK2_FASTILU_BASE_DECL_HPP__
 
#include <Tpetra_RowMatrix.hpp>
#include <Tpetra_CrsMatrix.hpp>
#include <Tpetra_KokkosCompat_DefaultNode.hpp>
#include <KokkosSparse_CrsMatrix.hpp>
#include <Ifpack2_Preconditioner.hpp>
#include <Ifpack2_Details_CanChangeMatrix.hpp>
#include <shylu_fastutil.hpp>
 
#ifdef HAVE_IFPACK2_METIS
#include "metis.h"
#endif
 
namespace Ifpack2 {
namespace Details {
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
class FastILU_Base : public Ifpack2::Preconditioner<Scalar, LocalOrdinal, GlobalOrdinal, Node>,
                     public Ifpack2::Details::CanChangeMatrix<
                         Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> {
 public:
  typedef typename Node::device_type device_type;
  typedef typename device_type::execution_space execution_space;
  typedef typename Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::impl_scalar_type ImplScalar;
  typedef Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> TRowMatrix;
  typedef Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> TCrsMatrix;
  typedef Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> TMultiVec;
  typedef KokkosSparse::CrsMatrix<Scalar, LocalOrdinal, execution_space> KCrsMatrix;
  typedef Kokkos::View<LocalOrdinal*, execution_space> OrdinalArray;
  typedef typename Kokkos::View<LocalOrdinal*, execution_space>::host_mirror_type OrdinalArrayHost;
  typedef Kokkos::View<ImplScalar*, execution_space> ImplScalarArray;
  typedef Kokkos::View<Scalar*, execution_space> ScalarArray;
  typedef Kokkos::View<const Scalar*, execution_space> ConstScalarArray;
#ifdef HAVE_IFPACK2_METIS
  typedef Kokkos::View<idx_t*, Kokkos::HostSpace> MetisArrayHost;
#endif
 
  FastILU_Base(Teuchos::RCP<const TRowMatrix> mat_);
 
  Teuchos::RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>
  getDomainMap() const;
 
  Teuchos::RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>
  getRangeMap() const;
 
  void
  apply(const TMultiVec& X,
        TMultiVec& Y,
        Teuchos::ETransp mode = Teuchos::NO_TRANS,
        Scalar alpha          = Teuchos::ScalarTraits<Scalar>::one(),
        Scalar beta           = Teuchos::ScalarTraits<Scalar>::zero()) const;
 
  void setParameters(const Teuchos::ParameterList& List);
 
  bool isBlockCrs() const;
 
  void initialize();
 
  bool isInitialized() const;
 
  void compute();
 
  bool isComputed() const;
 
  Teuchos::RCP<const TRowMatrix> getMatrix() const;
 
  int getNumInitialize() const;
 
  int getNumCompute() const;
 
  int getNumApply() const;
 
  double getInitializeTime() const;
 
  double getComputeTime() const;
 
  double getApplyTime() const;
 
  double getCopyTime() const;
 
  virtual int getSweeps() const = 0;
 
  virtual std::string getSpTrsvType() const = 0;
 
  virtual int getNTrisol() const = 0;
 
  virtual void checkLocalILU() const;
 
  virtual void checkLocalIC() const;
 
  std::string description() const;
 
  void setMatrix(const Teuchos::RCP<const TRowMatrix>& A);
 
 protected:
  Teuchos::RCP<const TRowMatrix> mat_;
  bool initFlag_;
  bool computedFlag_;
  int nInit_;
  int nComputed_;
  mutable int nApply_;
  // Cached local CRS matrix used for efficient value extraction.
  // If mat_ is already a Tpetra::CrsMatrix, localCrs_ aliases it.
  // If mat_ is a generic RowMatrix wrapper, localCrsNonConst_ owns a materialized CRS copy.
  Teuchos::RCP<const TCrsMatrix> localCrs_;
  Teuchos::RCP<TCrsMatrix> localCrsNonConst_;
  bool localCrsIsOwnedCopy_;
 
  // store the local CRS components
  ImplScalarArray localValues_;        // set at beginning of compute()
  OrdinalArray localRowPtrs_;          // set in initialize()
  OrdinalArray localColInds_;          // set in initialize()
  OrdinalArrayHost localRowPtrsHost_;  // set in initialize() and used to get localValues_ in compute()
 
  double initTime_;
  double computeTime_;
  mutable double applyTime_;
  double crsCopyTime_;  // total time spent deep copying values, rowptrs, colinds out of mat
 
  // Store validated parameter values (instead of keeping a ParameterList around)
  struct Params {
    Params() {}
    Params(const Teuchos::ParameterList& pL, std::string precType);
    bool use_metis;
    FastILU::SpTRSV sptrsv_algo;
    int nFact;
    int nTrisol;
    int level;
    int blkSize;
    double omega;
    double shift;
    bool guessFlag;
    int blockSizeILU;
    int blockSize;
    bool blockCrs;
    int blockCrsSize;
    bool fillBlocks;
    static Params getDefaults();
  };
 
  Params params_;
 
#ifdef HAVE_IFPACK2_METIS
  MetisArrayHost metis_perm_;
  MetisArrayHost metis_iperm_;
#endif
 
  // \pre !mat_.is_null()
  virtual void initLocalPrec() = 0;
  virtual void computeLocalPrec() = 0;
  virtual void applyLocalPrec(ImplScalarArray x, ImplScalarArray y) const = 0;
  virtual std::string getName() const = 0;
};
 
}  // namespace Details
}  // namespace Ifpack2
 
#endif