Teko_EpetraHelpers.hpp

// @HEADER
// *****************************************************************************
//      Teko: A package for block and physics based preconditioning
//
// Copyright 2010 NTESS and the Teko contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef __Teko_EpetraHelpers_hpp__
#define __Teko_EpetraHelpers_hpp__

// stl includes
#include <string>

// Epetra includes
#include "Epetra_Operator.h"
#include "Epetra_CrsMatrix.h"
#include "Epetra_MultiVector.h"

// Teuchos includes
#include "Teuchos_RCP.hpp"

// Thyra includes
#include "Thyra_VectorBase.hpp"
#include "Thyra_DefaultSpmdMultiVector.hpp"

namespace Teko {

namespace Epetra {

void fillDefaultSpmdMultiVector(Teuchos::RCP<Thyra::DefaultSpmdMultiVector<double> >& spmdMV,
                                Teuchos::RCP<Epetra_MultiVector>& epetraMV);

const Teuchos::RCP<const Thyra::LinearOpBase<double> > thyraDiagOp(
    const Teuchos::RCP<const Epetra_Vector>& ev, const Epetra_Map& map,
    const std::string& lbl = "ANYM");

const Teuchos::RCP<Thyra::LinearOpBase<double> > thyraDiagOp(const Teuchos::RCP<Epetra_Vector>& ev,
                                                             const Epetra_Map& map,
                                                             const std::string& lbl = "ANYM");

void identityRowIndices(const Epetra_Map& rowMap, const Epetra_CrsMatrix& mat,
                        std::vector<int>& outIndices);

void zeroMultiVectorRowIndices(Epetra_MultiVector& mv, const std::vector<int>& zeroIndices);

class ZeroedOperator : public Epetra_Operator {
 public:
  ZeroedOperator(const std::vector<int>& zeroIndices,
                 const Teuchos::RCP<const Epetra_Operator>& op);



  virtual ~ZeroedOperator() {}

  int SetUseTranspose(bool /* useTranspose */) { return -1; }

  int Apply(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const;

  int ApplyInverse(const Epetra_MultiVector& /* X */, Epetra_MultiVector& /* Y */) const {
    return -1;
  }

  double NormInf() const { return -1.0; }

  const char* Label() const { return label_.c_str(); }

  bool UseTranspose() const { return false; }

  bool HasNormInf() const { return false; }

  const Epetra_Comm& Comm() const { return epetraOp_->Comm(); }

  const Epetra_Map& OperatorDomainMap() const { return epetraOp_->OperatorDomainMap(); }

  const Epetra_Map& OperatorRangeMap() const { return epetraOp_->OperatorRangeMap(); }


 protected:
  std::vector<int> zeroIndices_;
  const Teuchos::RCP<const Epetra_Operator> epetraOp_;
  std::string label_;
};

}  // end namespace Epetra
}  // end namespace Teko

#endif