Ifpack2_Factory_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_FACTORY_DECL_HPP
#define IFPACK2_FACTORY_DECL_HPP
 
#include "Ifpack2_ConfigDefs.hpp"
#include "Ifpack2_Preconditioner.hpp"
#include "Ifpack2_Details_Factory.hpp"
 
#include "Ifpack2_Chebyshev.hpp"
#include "Ifpack2_RILUK.hpp"
#include "Ifpack2_Experimental_RBILUK.hpp"
 
#include <type_traits>
 
namespace Ifpack2 {
 
bool supportsUnsymmetric(const std::string& prec_type);
 
class Factory {
 public:
  template <class MatrixType>
  static Teuchos::RCP<Preconditioner<typename MatrixType::scalar_type,
                                     typename MatrixType::local_ordinal_type,
                                     typename MatrixType::global_ordinal_type,
                                     typename MatrixType::node_type> >
  create(const std::string& precType,
         const Teuchos::RCP<const MatrixType>& matrix) {
    using Teuchos::RCP;
    using Teuchos::rcp_implicit_cast;
    typedef typename MatrixType::scalar_type SC;
    typedef typename MatrixType::local_ordinal_type LO;
    typedef typename MatrixType::global_ordinal_type GO;
    typedef typename MatrixType::node_type NT;
    typedef Tpetra::RowMatrix<SC, LO, GO, NT> row_matrix_type;
 
    RCP<const row_matrix_type> A;
    if (!matrix.is_null()) {
      A = rcp_implicit_cast<const row_matrix_type>(matrix);
    }
    Ifpack2::Details::Factory<SC, LO, GO, NT> factory;
    return factory.create(precType, A);
  }
 
  template <class MatrixType>
  static Teuchos::RCP<Preconditioner<typename MatrixType::scalar_type,
                                     typename MatrixType::local_ordinal_type,
                                     typename MatrixType::global_ordinal_type,
                                     typename MatrixType::node_type> >
  create(const std::string& precType,
         const Teuchos::RCP<const MatrixType>& matrix,
         const Teuchos::RCP<const Tpetra::MultiVector<typename Teuchos::ScalarTraits<typename MatrixType::scalar_type>::magnitudeType,
                                                      typename MatrixType::local_ordinal_type,
                                                      typename MatrixType::global_ordinal_type,
                                                      typename MatrixType::node_type> >& coordinates) {
    using Teuchos::RCP;
    using Teuchos::rcp_implicit_cast;
    typedef typename MatrixType::scalar_type SC;
    typedef typename MatrixType::local_ordinal_type LO;
    typedef typename MatrixType::global_ordinal_type GO;
    typedef typename MatrixType::node_type NT;
    typedef Tpetra::RowMatrix<SC, LO, GO, NT> row_matrix_type;
 
    RCP<const row_matrix_type> A;
    if (!matrix.is_null()) {
      A = rcp_implicit_cast<const row_matrix_type>(matrix);
    }
    Ifpack2::Details::Factory<SC, LO, GO, NT> factory;
    return factory.create(precType, A, coordinates);
  }
 
  template <class MatrixType>
  static Teuchos::RCP<Preconditioner<typename MatrixType::scalar_type,
                                     typename MatrixType::local_ordinal_type,
                                     typename MatrixType::global_ordinal_type,
                                     typename MatrixType::node_type> >
  create(const std::string& precType,
         const Teuchos::RCP<const MatrixType>& matrix,
         const int overlap) {
    using Teuchos::RCP;
    using Teuchos::rcp_implicit_cast;
    typedef typename MatrixType::scalar_type SC;
    typedef typename MatrixType::local_ordinal_type LO;
    typedef typename MatrixType::global_ordinal_type GO;
    typedef typename MatrixType::node_type NT;
    typedef Tpetra::RowMatrix<SC, LO, GO, NT> row_matrix_type;
 
    RCP<const row_matrix_type> A;
    if (!matrix.is_null()) {
      A = rcp_implicit_cast<const row_matrix_type>(matrix);
    }
    Ifpack2::Details::Factory<SC, LO, GO, NT> factory;
    return factory.create(precType, A, overlap);
  }
 
  template <class MatrixType>
  static std::vector<std::string>
  getSupportedNames() {
    using SC = typename MatrixType::scalar_type;
    using LO = typename MatrixType::local_ordinal_type;
    using GO = typename MatrixType::global_ordinal_type;
    using NT = typename MatrixType::node_type;
 
    Ifpack2::Details::Factory<SC, LO, GO, NT> factory;
    return factory.getSupportedNames();
  }
 
  template <class MatrixType>
  static bool
  isSupported(const std::string& precType) {
    typedef typename MatrixType::scalar_type SC;
    typedef typename MatrixType::local_ordinal_type LO;
    typedef typename MatrixType::global_ordinal_type GO;
    typedef typename MatrixType::node_type NT;
 
    Ifpack2::Details::Factory<SC, LO, GO, NT> factory;
    return factory.isSupported(precType);
  }
};
 
}  // namespace Ifpack2
 
#endif  // IFPACK2_FACTORY_DECL_HPP