Thyra_TpetraThyraWrappers_decl.hpp

// @HEADER
// *****************************************************************************
//    Thyra: Interfaces and Support for Abstract Numerical Algorithms
//
// Copyright 2004 NTESS and the Thyra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef THYRA_TPETRA_THYRA_WRAPPERS_DECL_HPP
#define THYRA_TPETRA_THYRA_WRAPPERS_DECL_HPP
 
 
#include "Thyra_OperatorVectorTypes.hpp"
#include "Thyra_TpetraVectorSpace_decl.hpp"
#include "Thyra_TpetraVector_decl.hpp"
#include "Thyra_TpetraMultiVector_decl.hpp"
#include "Thyra_TpetraLinearOp_decl.hpp"
#include "Thyra_LinearOpWithSolveFactoryHelpers.hpp"
#include "Thyra_PreconditionerFactoryHelpers.hpp"
#include "Tpetra_CrsMatrix.hpp"
 
namespace Thyra {
 
 
RCP<const Teuchos::Comm<Ordinal> >
convertTpetraToThyraComm( const RCP<const Teuchos::Comm<int> > &tpetraComm );
 
RCP<const Teuchos::Comm<int> >
convertThyraToTpetraComm( const RCP<const Teuchos::Comm<Ordinal> > &thyraComm );
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<const VectorSpaceBase<Scalar> >
createVectorSpace(const RCP<const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > &tpetraMap);
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<VectorBase<Scalar> >
createVector(
  const RCP<Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraVector,
  const RCP<const VectorSpaceBase<Scalar> > space = Teuchos::null
  );
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<const VectorBase<Scalar> >
createConstVector(
  const RCP<const Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraVector,
  const RCP<const VectorSpaceBase<Scalar> > space = Teuchos::null
  );
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<MultiVectorBase<Scalar> >
createMultiVector(
  const RCP<Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraMultiVector,
  const RCP<const VectorSpaceBase<Scalar> > rangeSpace = Teuchos::null,
  const RCP<const VectorSpaceBase<Scalar> > domainSpace = Teuchos::null
  );
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<const MultiVectorBase<Scalar> >
createConstMultiVector(
  const RCP<const Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraMultiVector,
  const RCP<const VectorSpaceBase<Scalar> > rangeSpace = Teuchos::null,
  const RCP<const VectorSpaceBase<Scalar> > domainSpace = Teuchos::null
  );
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<LinearOpBase<Scalar> >
createLinearOp(
  const RCP<Tpetra::Operator<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraOperator,
  const RCP<const VectorSpaceBase<Scalar> > rangeSpace = Teuchos::null,
  const RCP<const VectorSpaceBase<Scalar> > domainSpace = Teuchos::null
  );
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<const LinearOpBase<Scalar> >
createConstLinearOp(
  const RCP<const Tpetra::Operator<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraOperator,
  const RCP<const VectorSpaceBase<Scalar> > rangeSpace = Teuchos::null,
  const RCP<const VectorSpaceBase<Scalar> > domainSpace = Teuchos::null
  );
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<Thyra::PreconditionerBase<Scalar>>
initializePrec(
  const PreconditionerFactoryBase<Scalar> &precFactory,
  const RCP<const Tpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraFwdOp,
  const Teuchos::RCP<PreconditionerBase<Scalar>> &prec = Teuchos::null,
  const ESupportSolveUse supportSolveUse = SUPPORT_SOLVE_UNSPECIFIED);
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<Thyra::PreconditionerBase<Scalar>>
initializePrec(
  const PreconditionerFactoryBase<Scalar> &precFactory,
  const RCP<const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraFwdOp,
  const Teuchos::RCP<PreconditionerBase<Scalar>> &prec = Teuchos::null,
  const ESupportSolveUse supportSolveUse = SUPPORT_SOLVE_UNSPECIFIED);
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<LinearOpWithSolveBase<Scalar>>
linearOpWithSolve(
  const LinearOpWithSolveFactoryBase<Scalar> &lowsFactory,
  const RCP<const Tpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraFwdOp,
  const ESupportSolveUse supportSolveUse = SUPPORT_SOLVE_UNSPECIFIED);
 
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<LinearOpWithSolveBase<Scalar>>
linearOpWithSolve(
  const LinearOpWithSolveFactoryBase<Scalar> &lowsFactory,
  const RCP<const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraFwdOp,
  const ESupportSolveUse supportSolveUse = SUPPORT_SOLVE_UNSPECIFIED);
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<LinearOpWithSolveBase<Scalar>>
initializePreconditionedOp(
  const LinearOpWithSolveFactoryBase<Scalar> &lowsFactory,
  const RCP<const Tpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraFwdOp,
  const RCP<PreconditionerBase<Scalar>> &prec,
  const ESupportSolveUse supportSolveUse = SUPPORT_SOLVE_UNSPECIFIED);
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<LinearOpWithSolveBase<Scalar>>
initializePreconditionedOp(
  const LinearOpWithSolveFactoryBase<Scalar> &lowsFactory,
  const RCP<const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraFwdOp,
  const RCP<PreconditionerBase<Scalar>> &prec,
  const ESupportSolveUse supportSolveUse = SUPPORT_SOLVE_UNSPECIFIED);
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
inline SolveStatus<Scalar>
solve(
  const LinearOpWithSolveBase<Scalar> &A, const EOpTransp A_trans,
  const RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraB,
  const RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> &tpetraX,
  const Ptr<const SolveCriteria<Scalar>> solveCriteria = Teuchos::null);
 
template <class Scalar = Tpetra::Vector<>::scalar_type,
          class LocalOrdinal = Tpetra::Vector<>::local_ordinal_type,
          class GlobalOrdinal = Tpetra::Vector<>::global_ordinal_type,
          class Node = Tpetra::Vector<>::node_type>
class TpetraOperatorVectorExtraction {
public:
 
  static RCP<const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> >
  getTpetraMap(const RCP<const VectorSpaceBase<Scalar> > &vs);
 
  static RCP<Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
  getTpetraVector(const RCP<VectorBase<Scalar> > &v);
 
  static RCP<const Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
  getConstTpetraVector(const RCP<const VectorBase<Scalar> > &v);
 
  static RCP<Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
  getTpetraMultiVector(const RCP<MultiVectorBase<Scalar> > &mv);
 
  static RCP<const Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
  getConstTpetraMultiVector(const RCP<const MultiVectorBase<Scalar> > &mv);
 
  static RCP<Tpetra::Operator<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
  getTpetraOperator(const RCP<LinearOpBase<Scalar> > &op);
 
  static RCP<const Tpetra::Operator<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
  getConstTpetraOperator(const RCP<const LinearOpBase<Scalar> > &op);
 
};
 
 
} // namespace Thyra
 
 
#endif // THYRA_TPETRA_THYRA_WRAPPERS_DECL_HPP