MueLu_FlatOperator_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//        MueLu: A package for multigrid based preconditioning
//
// Copyright 2012 NTESS and the MueLu contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef MUELU_FLATOPERATOR_DECL_HPP
#define MUELU_FLATOPERATOR_DECL_HPP
 
#include "MueLu_Constraint.hpp"
#include "Teuchos_RCP.hpp"
#include "Xpetra_Map.hpp"
#include "Xpetra_MapFactory.hpp"
#include "Xpetra_MatrixMatrix.hpp"
#include "Xpetra_MultiVector.hpp"
#include "Xpetra_Operator.hpp"
 
#include "MueLu_VerboseObject.hpp"
 
namespace MueLu {
 
 
template <class Scalar,
          class LocalOrdinal,
          class GlobalOrdinal,
          class Node = Tpetra::KokkosClassic::DefaultNode::DefaultNodeType>
class FlatOperator
  : public Xpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>,
    public VerboseObject {
 public:
 
  virtual const Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> getDomainMap() const {
    return map_;
  }
 
  virtual const Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> getRangeMap() const {
    return map_;
  }
 
 
  virtual void
  apply(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &X,
        Xpetra::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;
 
  virtual bool hasTransposeApply() const {
    return false;
  }
 
 
 
 
  std::string description() const {
    return mat_->description();
  }
 
  void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel = Teuchos::Describable::verbLevel_default) const {
    mat_->describe(out, verbLevel);
  }
 
 
 
 
  FlatOperator() = default;
 
  FlatOperator(const Teuchos::RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> mat,
               const Teuchos::RCP<MueLu::Constraint<Scalar, LocalOrdinal, GlobalOrdinal, Node>> constraint);
 
  void CheckMaps() {
  }
 
  void AllocateTemporaryMatrix() const {
    if (tempMat_.is_null()) {
      auto pattern = constraint_->GetPattern();
      tempMat_     = Xpetra::MatrixFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Build(pattern);
      tempMat_->fillComplete();
    }
  }
 
  void residual(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &X,
                const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B,
                Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &R) const {
    const auto one  = Teuchos::ScalarTraits<Scalar>::one();
    const auto zero = Teuchos::ScalarTraits<Scalar>::zero();
 
    apply(X, R, Teuchos::NO_TRANS, one, zero);
    R.update(one, B, -one);
  }
 
 
 private:
  RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> mat_;
  RCP<MueLu::Constraint<Scalar, LocalOrdinal, GlobalOrdinal, Node>> constraint_;
  RCP<Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> map_;
  mutable RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tempMat_;
 
};  // FlatOperator class
 
}  // namespace MueLu
 
#define MUELU_FLATOPERATOR_SHORT
#endif