Ifpack2_MDF_decl.hpp

// @HEADER
// *****************************************************************************
//       Ifpack2: Templated Object-Oriented Algebraic Preconditioner Package
//
// Copyright 2009 NTESS and the Ifpack2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
 
#ifndef IFPACK2_MDF_DECL_HPP
#define IFPACK2_MDF_DECL_HPP
 
#include "Ifpack2_Preconditioner.hpp"
#include "Ifpack2_Details_CanChangeMatrix.hpp"
#include "Tpetra_CrsMatrix_decl.hpp"
#include "Ifpack2_ScalingType.hpp"
#include "Ifpack2_IlukGraph.hpp"
#include "Ifpack2_LocalSparseTriangularSolver_decl.hpp"
#include "KokkosSparse_mdf.hpp"
 
#include <type_traits>
 
namespace Teuchos {
class ParameterList;  // forward declaration
}
namespace Ifpack2 {
 
template <class MatrixType>
class MDF : virtual public Ifpack2::Preconditioner<typename MatrixType::scalar_type,
                                                   typename MatrixType::local_ordinal_type,
                                                   typename MatrixType::global_ordinal_type,
                                                   typename MatrixType::node_type>,
            virtual public Ifpack2::Details::CanChangeMatrix<Tpetra::RowMatrix<typename MatrixType::scalar_type,
                                                                               typename MatrixType::local_ordinal_type,
                                                                               typename MatrixType::global_ordinal_type,
                                                                               typename MatrixType::node_type> > {
 public:
  typedef typename MatrixType::scalar_type scalar_type;
 
  typedef typename MatrixType::local_ordinal_type local_ordinal_type;
 
  typedef typename MatrixType::global_ordinal_type global_ordinal_type;
 
  typedef typename MatrixType::node_type node_type;
 
  typedef typename Teuchos::ScalarTraits<scalar_type>::magnitudeType magnitude_type;
 
  typedef typename node_type::device_type device_type;
 
  typedef typename node_type::execution_space execution_space;
 
  typedef Tpetra::RowMatrix<scalar_type,
                            local_ordinal_type,
                            global_ordinal_type,
                            node_type>
      row_matrix_type;
 
  static_assert(std::is_same<MatrixType, row_matrix_type>::value, "Ifpack2::MDF: The template parameter MatrixType must be a Tpetra::RowMatrix specialization.  Please don't use Tpetra::CrsMatrix (a subclass of Tpetra::RowMatrix) here anymore.");
 
  typedef Tpetra::CrsMatrix<scalar_type,
                            local_ordinal_type,
                            global_ordinal_type,
                            node_type>
      crs_matrix_type;
 
  typedef typename crs_matrix_type::impl_scalar_type impl_scalar_type;
 
  template <class NewMatrixType>
  friend class MDF;
 
  typedef typename crs_matrix_type::global_inds_host_view_type global_inds_host_view_type;
  typedef typename crs_matrix_type::local_inds_host_view_type local_inds_host_view_type;
  typedef typename crs_matrix_type::values_host_view_type values_host_view_type;
 
  typedef typename crs_matrix_type::nonconst_global_inds_host_view_type nonconst_global_inds_host_view_type;
  typedef typename crs_matrix_type::nonconst_local_inds_host_view_type nonconst_local_inds_host_view_type;
  typedef typename crs_matrix_type::nonconst_values_host_view_type nonconst_values_host_view_type;
 
 
 
  typedef typename crs_matrix_type::local_matrix_device_type local_matrix_device_type;
  typedef typename local_matrix_device_type::StaticCrsGraphType::row_map_type lno_row_view_t;
  typedef typename local_matrix_device_type::StaticCrsGraphType::entries_type lno_nonzero_view_t;
  typedef typename local_matrix_device_type::values_type scalar_nonzero_view_t;
  typedef typename local_matrix_device_type::StaticCrsGraphType::device_type::memory_space TemporaryMemorySpace;
  typedef typename local_matrix_device_type::StaticCrsGraphType::device_type::memory_space PersistentMemorySpace;
  typedef typename local_matrix_device_type::StaticCrsGraphType::device_type::execution_space HandleExecSpace;
  typedef typename KokkosKernels::Experimental::KokkosKernelsHandle<typename lno_row_view_t::const_value_type, typename lno_nonzero_view_t::const_value_type, typename scalar_nonzero_view_t::value_type,
                                                                    HandleExecSpace, TemporaryMemorySpace, PersistentMemorySpace>
      kk_handle_type;
 
  MDF(const Teuchos::RCP<const row_matrix_type>& A_in);
 
  MDF(const Teuchos::RCP<const crs_matrix_type>& A_in);
 
 private:
  MDF(const MDF<MatrixType>& src);
 
 public:
  virtual ~MDF() = default;
 
  void setParameters(const Teuchos::ParameterList& params);
 
  void initialize();
 
  void compute();
 
  bool isInitialized() const {
    return isInitialized_;
  }
  bool isComputed() const {
    return isComputed_;
  }
 
  int getNumInitialize() const {
    return numInitialize_;
  }
  int getNumCompute() const {
    return numCompute_;
  }
  int getNumApply() const {
    return numApply_;
  }
 
  double getInitializeTime() const {
    return initializeTime_;
  }
  double getComputeTime() const {
    return computeTime_;
  }
  double getApplyTime() const {
    return applyTime_;
  }
 
  size_t getNodeSmootherComplexity() const;
 
 
 
  virtual void
  setMatrix(const Teuchos::RCP<const row_matrix_type>& A);
 
 
 
  std::string description() const;
 
 
 
  Teuchos::RCP<const Tpetra::Map<local_ordinal_type, global_ordinal_type, node_type> >
  getDomainMap() const;
 
  Teuchos::RCP<const Tpetra::Map<local_ordinal_type, global_ordinal_type, node_type> >
  getRangeMap() const;
 
  void
  apply(const Tpetra::MultiVector<scalar_type, local_ordinal_type, global_ordinal_type, node_type>& X,
        Tpetra::MultiVector<scalar_type, local_ordinal_type, global_ordinal_type, node_type>& Y,
        Teuchos::ETransp mode = Teuchos::NO_TRANS,
        scalar_type alpha     = Teuchos::ScalarTraits<scalar_type>::one(),
        scalar_type beta      = Teuchos::ScalarTraits<scalar_type>::zero()) const;
 
 private:
  // Split off to a different impl call so that nested apply calls don't mess up apply counts/timers
  void apply_impl(const Tpetra::MultiVector<scalar_type, local_ordinal_type, global_ordinal_type, node_type>& X,
                  Tpetra::MultiVector<scalar_type, local_ordinal_type, global_ordinal_type, node_type>& Y,
                  Teuchos::ETransp mode = Teuchos::NO_TRANS,
                  scalar_type alpha     = Teuchos::ScalarTraits<scalar_type>::one(),
                  scalar_type beta      = Teuchos::ScalarTraits<scalar_type>::zero()) const;
 
  void
  multiply(const Tpetra::MultiVector<scalar_type, local_ordinal_type, global_ordinal_type, node_type>& X,
           Tpetra::MultiVector<scalar_type, local_ordinal_type, global_ordinal_type, node_type>& Y,
           const Teuchos::ETransp mode = Teuchos::NO_TRANS) const;
 
 public:
  using MDF_handle_device_type = KokkosSparse::Experimental::MDF_handle<local_matrix_device_type>;
  using permutations_type      = Teuchos::ArrayRCP<local_ordinal_type>;
 
  Teuchos::RCP<const row_matrix_type> getMatrix() const;
 
  int getLevelOfFill() const { return LevelOfFill_; }
 
  Tpetra::CombineMode getOverlapMode() {
    TEUCHOS_TEST_FOR_EXCEPTION(
        true, std::logic_error,
        "Ifpack2::MDF::SetOverlapMode: "
        "MDF no longer implements overlap on its own.  "
        "Use MDF with AdditiveSchwarz if you want overlap.");
  }
 
  Tpetra::global_size_t getGlobalNumEntries() const {
    return getL().getGlobalNumEntries() + getU().getGlobalNumEntries();
  }
 
  const crs_matrix_type& getL() const;
 
  const crs_matrix_type& getU() const;
 
  permutations_type& getPermutations() const;
 
  permutations_type& getReversePermutations() const;
 
  Teuchos::RCP<const crs_matrix_type> getCrsMatrix() const;
 
 private:
  typedef Tpetra::MultiVector<scalar_type, local_ordinal_type, global_ordinal_type, node_type> MV;
  typedef Teuchos::ScalarTraits<scalar_type> STS;
  typedef Teuchos::ScalarTraits<magnitude_type> STM;
 
  void allocateSolvers();
  void allocatePermutations(bool force = false);
  static void checkOrderingConsistency(const row_matrix_type& A);
  // void initAllValues (const row_matrix_type& A);
 
  static Teuchos::RCP<const row_matrix_type>
  makeLocalFilter(const Teuchos::RCP<const row_matrix_type>& A);
 
 protected:
  typedef Tpetra::Vector<scalar_type, local_ordinal_type, global_ordinal_type, node_type> vec_type;
 
  Teuchos::RCP<const row_matrix_type> A_;
 
  // The MDF handle
  Teuchos::RCP<MDF_handle_device_type> MDF_handle_;
 
  Teuchos::RCP<const row_matrix_type> A_local_;
  lno_row_view_t A_local_rowmap_;
  lno_nonzero_view_t A_local_entries_;
  scalar_nonzero_view_t A_local_values_;
 
  Teuchos::RCP<crs_matrix_type> L_;
  Teuchos::RCP<LocalSparseTriangularSolver<row_matrix_type> > L_solver_;
  Teuchos::RCP<crs_matrix_type> U_;
  Teuchos::RCP<LocalSparseTriangularSolver<row_matrix_type> > U_solver_;
 
  permutations_type permutations_;
 
  permutations_type reversePermutations_;
 
  int Verbosity_;
 
  int LevelOfFill_;
  double Overalloc_;
 
  bool isAllocated_;
  bool isInitialized_;
  bool isComputed_;
 
  int numInitialize_;
  int numCompute_;
  mutable int numApply_;
 
  double initializeTime_;
  double computeTime_;
  mutable double applyTime_;
};
 
}  // namespace Ifpack2
 
#endif /* IFPACK2_MDF_DECL_HPP */