Tpetra_MixedScalarMultiplyOp.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_MIXEDSCALARMULTIPLYOP_HPP
#define TPETRA_MIXEDSCALARMULTIPLYOP_HPP
 
 
#include "Tpetra_Operator.hpp"
#include "Tpetra_Util.hpp"
#include "Tpetra_Details_Behavior.hpp"
#include "Tpetra_Details_Profiling.hpp"
 
namespace Tpetra {
 
template <class Scalar,
          class OpScalar,
          class LocalOrdinal,
          class GlobalOrdinal,
          class Node>
class MixedScalarMultiplyOp : public Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node> {
 public:
  using op_type =
      Operator<OpScalar, LocalOrdinal, GlobalOrdinal, Node>;
  using map_type = Map<LocalOrdinal, GlobalOrdinal, Node>;
 
 public:
 
 
  MixedScalarMultiplyOp(const Teuchos::RCP<const op_type>& A)
    : op_(A) {
    Allocate(1);
  }
 
  ~MixedScalarMultiplyOp() override = default;
 
 
 
  void
  apply(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& X,
        MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Y,
        Teuchos::ETransp mode = Teuchos::NO_TRANS,
        Scalar alpha          = Teuchos::ScalarTraits<Scalar>::one(),
        Scalar beta           = Teuchos::ScalarTraits<Scalar>::zero()) const override {
    TEUCHOS_TEST_FOR_EXCEPTION(X.getNumVectors() != Y.getNumVectors(), std::runtime_error,
                               Teuchos::typeName(*this) << "::apply(X,Y): X and Y must have the same number of vectors.");
 
    if (X.getNumVectors() != X_->getNumVectors()) {
      Allocate(X.getNumVectors());
    }
 
    Tpetra::deep_copy(*X_, X);
    op_->apply(*X_, *Y_, mode, Teuchos::as<OpScalar>(alpha), Teuchos::as<OpScalar>(beta));
    Tpetra::deep_copy(Y, *Y_);
  }
 
  bool hasTransposeApply() const override {
    return true;
  }
 
  Teuchos::RCP<const map_type> getDomainMap() const override {
    return op_->getDomainMap();
  }
 
  Teuchos::RCP<const map_type> getRangeMap() const override {
    return op_->getRangeMap();
  }
 
 
 protected:
  typedef MultiVector<OpScalar, LocalOrdinal, GlobalOrdinal, Node> MV;
 
  const Teuchos::RCP<const op_type> op_;
  mutable Teuchos::RCP<MV> X_, Y_;
 
  void
  Allocate(int numVecs) const {
    X_ = rcp(new MV(op_->getDomainMap(), numVecs));
    Y_ = rcp(new MV(op_->getRangeMap(), numVecs));
  }
};
 
template <class Scalar,
          class OpScalar,
          class LocalOrdinal,
          class GlobalOrdinal,
          class Node>
Teuchos::RCP<
    MixedScalarMultiplyOp<Scalar, OpScalar, LocalOrdinal, GlobalOrdinal, Node> >
createMixedScalarMultiplyOp(const Teuchos::RCP<
                            const Operator<OpScalar, LocalOrdinal, GlobalOrdinal, Node> >& A) {
  typedef MixedScalarMultiplyOp<Scalar, OpScalar, LocalOrdinal,
                                GlobalOrdinal, Node>
      op_type;
  return Teuchos::rcp(new op_type(A));
}
 
}  // end of namespace Tpetra
 
#endif  // TPETRA_MIXEDSCALARMULTIPLYOP_HPP