BelosMultiVec.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                 Belos: Block Linear Solvers Package
//
// Copyright 2004-2016 NTESS and the Belos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef BELOS_MULTI_VEC_HPP
#define BELOS_MULTI_VEC_HPP
 
 
#include "BelosMultiVecTraits.hpp"
#include "BelosTypes.hpp"
#include "BelosConfigDefs.hpp"
 
namespace Belos {
 
template <class ScalarType, class DM = DefaultDenseMatrix<int, ScalarType>>
class MultiVec {
public:
 
 
  MultiVec() {};
  
  virtual ~MultiVec () {};
  
 
  
  virtual MultiVec<ScalarType,DM> * Clone ( const int numvecs ) const = 0;
  
  virtual MultiVec<ScalarType,DM> * CloneCopy () const = 0;
  
  virtual MultiVec<ScalarType,DM> * CloneCopy ( const std::vector<int>& index ) const = 0;
  
  virtual MultiVec<ScalarType,DM> * CloneViewNonConst ( const std::vector<int>& index ) = 0;
  
  virtual const MultiVec<ScalarType,DM> * CloneView ( const std::vector<int>& index ) const = 0;
 
 
 
  virtual ptrdiff_t GetGlobalLength () const = 0;
 
  virtual int GetNumberVecs () const = 0;
 
 
 
  virtual void 
  MvTimesMatAddMv (const ScalarType alpha, 
       const MultiVec<ScalarType,DM>& A, 
       const DM& B, const ScalarType beta) = 0;
  
  virtual void MvAddMv ( const ScalarType alpha, 
                         const MultiVec<ScalarType,DM>& A, 
                         const ScalarType beta, 
                         const MultiVec<ScalarType,DM>& B ) = 0;
  
  virtual void MvScale ( const ScalarType alpha ) = 0;
  
  virtual void MvScale ( const std::vector<ScalarType>& alpha ) = 0;
  
  virtual void MvTransMv ( const ScalarType alpha, const MultiVec<ScalarType,DM>& A, DM& B) const = 0;
 
  virtual void MvDot ( const MultiVec<ScalarType,DM>& A, std::vector<ScalarType>& b ) const = 0;
  
 
  
  virtual void MvNorm ( std::vector<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>& normvec, NormType type = TwoNorm ) const = 0;
  
 
 
  virtual void SetBlock ( const MultiVec<ScalarType,DM>& A, const std::vector<int>& index ) = 0;
 
  virtual void MvRandom () = 0;
  
  virtual void MvInit ( const ScalarType alpha ) = 0;
  
 
 
  virtual void MvPrint ( std::ostream& os ) const = 0;
 
#ifdef HAVE_BELOS_TSQR
 
 
  virtual void 
  factorExplicit (MultiVec<ScalarType,DM>& Q, 
      DM& R,
      const bool forceNonnegativeDiagonal=false)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "The Belos::MultiVec<" 
      << Teuchos::TypeNameTraits<ScalarType>::name() << "> subclass which you "
      "are using does not implement the TSQR-related method factorExplicit().");
  }
 
  virtual int
  revealRank (DM& R,
        const typename Teuchos::ScalarTraits<ScalarType>::magnitudeType& tol)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "The Belos::MultiVec<" 
      << Teuchos::TypeNameTraits<ScalarType>::name() << "> subclass which you "
      "are using does not implement the TSQR-related method revealRank().");
  }
 
#endif // HAVE_BELOS_TSQR
};
 
 
namespace details {
template<class ScalarType, class DM = DefaultDenseMatrix<int, ScalarType>>
class MultiVecTsqrAdapter {
public:
  typedef MultiVec<ScalarType, DM> MV;
  typedef ScalarType scalar_type; 
  typedef int ordinal_type; // This doesn't matter either
  typedef int node_type; // Nor does this
  typedef typename Teuchos::ScalarTraits<scalar_type>::magnitudeType magnitude_type;
  
  void
  factorExplicit (MV& A,
      MV& Q,
      DM& R,
      const bool forceNonnegativeDiagonal=false)
  {
    A.factorExplicit (Q, R, forceNonnegativeDiagonal);
  }
 
  int
  revealRank (MV& Q,
        DM& R,
        const magnitude_type& tol)
  {
    return Q.revealRank (R, tol);
  }
 
  void setParameterList (const Teuchos::RCP<Teuchos::ParameterList>& params) {
    (void) params;
  }
  
  Teuchos::RCP<const Teuchos::ParameterList> getValidParameters () const {
    return Teuchos::parameterList ();
  }
};
} // namespace details
 
  template<class ScalarType, class DM>
  class MultiVecTraits<ScalarType,MultiVec<ScalarType,DM>,DM> {
  public:
 
 
    static Teuchos::RCP<MultiVec<ScalarType,DM> > 
    Clone (const MultiVec<ScalarType,DM>& mv, const int numvecs) {
      return Teuchos::rcp (const_cast<MultiVec<ScalarType,DM>&> (mv).Clone (numvecs)); 
    }
    static Teuchos::RCP<MultiVec<ScalarType,DM> > CloneCopy( const MultiVec<ScalarType,DM>& mv )
    { return Teuchos::rcp( const_cast<MultiVec<ScalarType,DM>&>(mv).CloneCopy() ); }
    static Teuchos::RCP<MultiVec<ScalarType,DM> > CloneCopy( const MultiVec<ScalarType,DM>& mv, const std::vector<int>& index )
    { return Teuchos::rcp( const_cast<MultiVec<ScalarType,DM>&>(mv).CloneCopy(index) ); }
    static Teuchos::RCP<MultiVec<ScalarType,DM> > 
    CloneViewNonConst (MultiVec<ScalarType,DM>& mv, const std::vector<int>& index)
    { 
      return Teuchos::rcp( mv.CloneViewNonConst(index) ); 
    }
 
    static Teuchos::RCP<MultiVec<ScalarType,DM> > 
    CloneViewNonConst (MultiVec<ScalarType,DM>& mv, const Teuchos::Range1D& index)
    { 
      // mfh 02 Mar 2013: For now, we'll just use the above index
      // vector version of CloneViewNonConst to implement this, since
      // that doesn't require adding to the MultiVec interface.
      std::vector<int> indVec (index.size ());
      for (int k = 0; k < index.size (); ++k) {
  indVec[k] = k;
      }
      return CloneViewNonConst (mv, indVec);
    }
 
    static Teuchos::RCP<const MultiVec<ScalarType,DM> > 
    CloneView (const MultiVec<ScalarType,DM>& mv, const std::vector<int>& index) {
      return Teuchos::rcp( const_cast<MultiVec<ScalarType,DM>&>(mv).CloneView(index) ); 
    }
 
    static Teuchos::RCP<const MultiVec<ScalarType,DM> > 
    CloneView (const MultiVec<ScalarType,DM>& mv, const Teuchos::Range1D& index)
    { 
      // mfh 02 Mar 2013: For now, we'll just use the above index
      // vector version of CloneView to implement this, since that
      // doesn't require adding to the MultiVec interface.
      std::vector<int> indVec (index.size ());
      for (int k = 0; k < index.size (); ++k) {
  indVec[k] = k;
      }
      return CloneView (mv, indVec);
    }
 
    static ptrdiff_t GetGlobalLength( const MultiVec<ScalarType,DM>& mv )
    { return mv.GetGlobalLength(); }
    static int GetNumberVecs( const MultiVec<ScalarType,DM>& mv )
    { return mv.GetNumberVecs(); }
    static void MvTimesMatAddMv( ScalarType alpha, const MultiVec<ScalarType,DM>& A, 
         const DM& B, 
         ScalarType beta, MultiVec<ScalarType,DM>& mv )
    { mv.MvTimesMatAddMv(alpha, A, B, beta); }
    static void MvAddMv( ScalarType alpha, const MultiVec<ScalarType,DM>& A, ScalarType beta, const MultiVec<ScalarType,DM>& B, MultiVec<ScalarType,DM>& mv )
    { mv.MvAddMv(alpha, A, beta, B); }
    static void MvScale ( MultiVec<ScalarType,DM>& mv, const ScalarType alpha )
    { mv.MvScale( alpha ); } 
 
    static void MvScale ( MultiVec<ScalarType,DM>& mv, const std::vector<ScalarType>& alpha )
    { mv.MvScale(alpha); }
    static void MvTransMv( const ScalarType alpha, const MultiVec<ScalarType,DM>& A, const MultiVec<ScalarType,DM>& mv, DM& B )
    { mv.MvTransMv(alpha, A, B); }
    static void MvDot( const MultiVec<ScalarType,DM>& mv, const MultiVec<ScalarType,DM>& A, std::vector<ScalarType>& b )
    { mv.MvDot( A, b ); }
    static void MvNorm( const MultiVec<ScalarType,DM>& mv, std::vector<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>& normvec, NormType type = TwoNorm )
    { mv.MvNorm(normvec,type); }
    static void SetBlock( const MultiVec<ScalarType,DM>& A, const std::vector<int>& index, MultiVec<ScalarType,DM>& mv )
    { mv.SetBlock(A, index); }
 
    static void 
    Assign (const MultiVec<ScalarType,DM>& A, 
      MultiVec<ScalarType,DM>& mv) 
    {
      // mfh 02 Mar 2013: For now, we'll just use SetBlock to implement this,
      // since that doesn't require adding to the MultiVec interface.
      const int numVecsRhs = GetNumberVecs (A);
      const int numVecsLhs = GetNumberVecs (mv);
 
      TEUCHOS_TEST_FOR_EXCEPTION(
        numVecsLhs != numVecsRhs, std::invalid_argument, 
  "Belos::MultiVecTraits::Assign: Input multivector A has " << numVecsRhs
  << " columns, which differs from the number of columns " << numVecsLhs
  << " in the output multivector mv.");
 
      // mfh 02 Mar 2013: It's pretty silly to build this each time.
      // However, at least that makes the code correct.
      std::vector<int> index (numVecsRhs);
      for (int k = 0; k < numVecsRhs; ++k) {
  index[k] = k;
      }
      SetBlock (A, index, mv);
    }
 
    static void MvRandom( MultiVec<ScalarType, DM>& mv )
    { mv.MvRandom(); }
    static void MvInit( MultiVec<ScalarType, DM>& mv, ScalarType alpha = Teuchos::ScalarTraits<ScalarType>::zero() )
    { mv.MvInit(alpha); }
    static void MvPrint( const MultiVec<ScalarType, DM>& mv, std::ostream& os )
    { mv.MvPrint(os); }
 
#ifdef HAVE_BELOS_TSQR
    typedef details::MultiVecTsqrAdapter<ScalarType,DM> tsqr_adaptor_type;
#endif // HAVE_BELOS_TSQR
  };
 
 
} // namespace Belos
 
#endif
 
// end of file BelosMultiVec.hpp