BelosStatusTestGenResSubNorm.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_STATUS_TEST_GEN_RESSUBNORM_H
#define BELOS_STATUS_TEST_GEN_RESSUBNORM_H
 
#include "BelosStatusTestResNorm.hpp"
#include "BelosLinearProblem.hpp"
#include "BelosMultiVecTraits.hpp"
#include "BelosOperatorTraits.hpp"
 
#ifdef HAVE_BELOS_THYRA
#include <Thyra_MultiVectorBase.hpp>
#include <Thyra_MultiVectorStdOps.hpp>
#include <Thyra_ProductMultiVectorBase.hpp>
#endif
 
namespace Belos {
 
template <class ScalarType, class MV, class OP>
class StatusTestGenResSubNorm: public StatusTestResNorm<ScalarType,MV,OP> {
 
 public:
  // Convenience typedefs
  typedef Teuchos::ScalarTraits<ScalarType> SCT;
  typedef typename SCT::magnitudeType MagnitudeType;
  typedef MultiVecTraits<ScalarType,MV>  MVT;
 
 
 
  StatusTestGenResSubNorm( MagnitudeType /* Tolerance */, size_t /* subIdx */, int /* quorum */ = -1, bool /* showMaxResNormOnly */ = false ) {
    TEUCHOS_TEST_FOR_EXCEPTION(true,StatusTestError,
          "StatusTestGenResSubNorm::StatusTestGenResSubNorm(): StatusTestGenResSubNorm only available for blocked operators (e.g., Thyra).");
  }
 
  virtual ~StatusTestGenResSubNorm() { };
 
 
 
 
  int defineResForm(  NormType /* TypeOfNorm */) {
    TEUCHOS_TEST_FOR_EXCEPTION(true,StatusTestError,
          "StatusTestGenResSubNorm::defineResForm(): StatusTestGenResSubNorm only available for blocked operators (e.g., Thyra).");
    TEUCHOS_UNREACHABLE_RETURN(0);
  }
 
 
  int defineScaleForm( ScaleType /* TypeOfScaling */, NormType /* TypeOfNorm */, MagnitudeType /* ScaleValue */ = Teuchos::ScalarTraits<MagnitudeType>::one()) {
    TEUCHOS_TEST_FOR_EXCEPTION(true,StatusTestError,
          "StatusTestGenResSubNorm::defineScaleForm(): StatusTestGenResSubNorm only available for blocked operators (e.g., Thyra).");
    TEUCHOS_UNREACHABLE_RETURN(0);
  }
 
 
  int setTolerance(MagnitudeType /* tolerance */) { return 0; }
 
 
  int setSubIdx ( size_t subIdx ) { return 0;}
 
  int setQuorum(int /* quorum */) { return 0; }
 
  int setShowMaxResNormOnly(bool /* showMaxResNormOnly */) { return 0; }
 
 
 
 
  StatusType checkStatus(Iteration<ScalarType,MV,OP>* /* iSolver */) { return Undefined; }
 
  StatusType getStatus() const {return Undefined;}
 
 
 
  void reset() { }
 
 
 
 
  void print(std::ostream& /* os */, int /* indent */ = 0) const { }
 
  void printStatus(std::ostream& /* os */, StatusType /* type */) const { }
 
 
 
  Teuchos::RCP<MV> getSolution() { return Teuchos::null; }
 
  int getQuorum() const { return -1; }
 
  size_t getSubIdx() const { return 0; }
 
  bool getShowMaxResNormOnly() { return false; }
 
  std::vector<int> convIndices() { return std::vector<int>(0); }
 
  MagnitudeType getTolerance() const {return SCT::magnitude(SCT::zero());};
 
  const std::vector<MagnitudeType>* getTestValue() const {return NULL;};
 
  const std::vector<MagnitudeType>* getResNormValue() const {return NULL;};
 
  const std::vector<MagnitudeType>* getScaledNormValue() const {return NULL;};
 
  bool getLOADetected() const { return false; }
 
 
 
 
  StatusType firstCallCheckStatusSetup(Iteration<ScalarType,MV,OP>* iSolver) {
    return Undefined;
  }
 
 
  std::string description() const
  { return std::string(""); }
};
 
#ifdef HAVE_BELOS_THYRA
 
// specialization for Thyra
template <class ScalarType>
class StatusTestGenResSubNorm<ScalarType,Thyra::MultiVectorBase<ScalarType>,Thyra::LinearOpBase<ScalarType> >
   : public StatusTestResNorm<ScalarType,Thyra::MultiVectorBase<ScalarType>,Thyra::LinearOpBase<ScalarType> > {
 
 public:
  // Convenience typedefs
  typedef Thyra::MultiVectorBase<ScalarType> MV;
  typedef Thyra::LinearOpBase<ScalarType>    OP;
 
  typedef Teuchos::ScalarTraits<ScalarType> SCT;
  typedef typename SCT::magnitudeType MagnitudeType;
  typedef MultiVecTraits<ScalarType,MV>  MVT;
  typedef OperatorTraits<ScalarType,MV,OP>  OT;
 
 
 
  StatusTestGenResSubNorm( MagnitudeType Tolerance, size_t subIdx, int quorum = -1, bool showMaxResNormOnly = false )
  : tolerance_(Tolerance),
    subIdx_(subIdx),
    quorum_(quorum),
    showMaxResNormOnly_(showMaxResNormOnly),
    resnormtype_(TwoNorm),
    scaletype_(NormOfInitRes),
    scalenormtype_(TwoNorm),
    scalevalue_(Teuchos::ScalarTraits<MagnitudeType>::one ()),
    status_(Undefined),
    curBlksz_(0),
    curNumRHS_(0),
    curLSNum_(0),
    numrhs_(0),
    firstcallCheckStatus_(true),
    firstcallDefineResForm_(true),
    firstcallDefineScaleForm_(true) { }
 
  virtual ~StatusTestGenResSubNorm() { };
 
 
 
 
  int defineResForm(NormType TypeOfNorm) {
    TEUCHOS_TEST_FOR_EXCEPTION(firstcallDefineResForm_==false,StatusTestError,
          "StatusTestGenResSubNorm::defineResForm(): The residual form has already been defined.");
    firstcallDefineResForm_ = false;
 
    resnormtype_ = TypeOfNorm;
 
    return(0);
  }
 
 
  int defineScaleForm( ScaleType TypeOfScaling, NormType TypeOfNorm, MagnitudeType ScaleValue = Teuchos::ScalarTraits<MagnitudeType>::one()) {
    TEUCHOS_TEST_FOR_EXCEPTION(firstcallDefineScaleForm_==false,StatusTestError,
          "StatusTestGenResSubNorm::defineScaleForm(): The scaling type has already been defined.");
    firstcallDefineScaleForm_ = false;
 
    scaletype_ = TypeOfScaling;
    scalenormtype_ = TypeOfNorm;
    scalevalue_ = ScaleValue;
 
    return(0);
  }
 
 
  int setTolerance(MagnitudeType tolerance) {tolerance_ = tolerance; return(0);}
 
 
  int setSubIdx ( size_t subIdx ) { subIdx_ = subIdx; return(0);}
 
  int setQuorum(int quorum) {quorum_ = quorum; return(0);}
 
  int setShowMaxResNormOnly(bool showMaxResNormOnly) {showMaxResNormOnly_ = showMaxResNormOnly; return(0);}
 
 
 
 
  StatusType checkStatus(Iteration<ScalarType,MV,OP>* iSolver) {
    MagnitudeType zero = Teuchos::ScalarTraits<MagnitudeType>::zero();
    const LinearProblem<ScalarType,MV,OP>& lp = iSolver->getProblem();
    // Compute scaling term (done once for each block that's being solved)
    if (firstcallCheckStatus_) {
      StatusType status = firstCallCheckStatusSetup(iSolver);
      if(status==Failed) {
        status_ = Failed;
        return(status_);
      }
    }
 
    //
    // This section computes the norm of the residual std::vector
    //
    if ( curLSNum_ != lp.getLSNumber() ) {
      //
      // We have moved on to the next rhs block
      //
      curLSNum_ = lp.getLSNumber();
      curLSIdx_ = lp.getLSIndex();
      curBlksz_ = (int)curLSIdx_.size();
      int validLS = 0;
      for (int i=0; i<curBlksz_; ++i) {
        if (curLSIdx_[i] > -1 && curLSIdx_[i] < numrhs_)
          validLS++;
      }
      curNumRHS_ = validLS;
      curSoln_ = Teuchos::null;
      //
    } else {
      //
      // We are in the same rhs block, return if we are converged
      //
      if (status_==Passed) { return status_; }
    }
 
    //
    // Request the true residual for this block of right-hand sides.
    //
    Teuchos::RCP<MV> cur_update = iSolver->getCurrentUpdate();
    curSoln_ = lp.updateSolution( cur_update );
    Teuchos::RCP<MV> cur_res = MVT::Clone( *curSoln_, MVT::GetNumberVecs( *curSoln_ ) );
    lp.computeCurrResVec( &*cur_res, &*curSoln_ );
    std::vector<MagnitudeType> tmp_resvector( MVT::GetNumberVecs( *cur_res ) );
    MvSubNorm( *cur_res, subIdx_, tmp_resvector, resnormtype_ );
 
    typename std::vector<int>::iterator pp = curLSIdx_.begin();
    for (int i=0; pp<curLSIdx_.end(); ++pp, ++i) {
      // Check if this index is valid
      if (*pp != -1)
        resvector_[*pp] = tmp_resvector[i];
    }
 
    //
    // Compute the new linear system residuals for testing.
    // (if any of them don't meet the tolerance or are NaN, then we exit with that status)
    //
    if ( scalevector_.size() > 0 ) {
      typename std::vector<int>::iterator p = curLSIdx_.begin();
      for (; p<curLSIdx_.end(); ++p) {
        // Check if this index is valid
        if (*p != -1) {
          // Scale the std::vector accordingly
          if ( scalevector_[ *p ] != zero ) {
            // Don't intentionally divide by zero.
            testvector_[ *p ] = resvector_[ *p ] / scalevector_[ *p ] / scalevalue_;
          } else {
            testvector_[ *p ] = resvector_[ *p ] / scalevalue_;
          }
        }
      }
    }
    else {
      typename std::vector<int>::iterator ppp = curLSIdx_.begin();
      for (; ppp<curLSIdx_.end(); ++ppp) {
        // Check if this index is valid
        if (*ppp != -1)
          testvector_[ *ppp ] = resvector_[ *ppp ] / scalevalue_;
      }
    }
    // Check status of new linear system residuals and see if we have the quorum.
    int have = 0;
    ind_.resize( curLSIdx_.size() );
    typename std::vector<int>::iterator p2 = curLSIdx_.begin();
    for (; p2<curLSIdx_.end(); ++p2) {
      // Check if this index is valid
      if (*p2 != -1) {
        // Check if any of the residuals are larger than the tolerance.
        if (testvector_[ *p2 ] > tolerance_) {
          // do nothing.
        } else if (testvector_[ *p2 ] <= tolerance_) {
          ind_[have] = *p2;
          have++;
        } else {
          // Throw an std::exception if a NaN is found.
          status_ = Failed;
          TEUCHOS_TEST_FOR_EXCEPTION(true,StatusTestNaNError,"StatusTestGenResSubNorm::checkStatus(): NaN has been detected.");
        }
      }
    }
    ind_.resize(have);
    int need = (quorum_ == -1) ? curNumRHS_: quorum_;
    status_ = (have >= need) ? Passed : Failed;
    // Return the current status
    return status_;
  }
 
  StatusType getStatus() const {return(status_);};
 
 
 
  void reset() {
    status_ = Undefined;
    curBlksz_ = 0;
    curLSNum_ = 0;
    curLSIdx_.resize(0);
    numrhs_ = 0;
    ind_.resize(0);
    firstcallCheckStatus_ = true;
    curSoln_ = Teuchos::null;
  }
 
 
 
 
  void print(std::ostream& os, int indent = 0) const {
    os.setf(std::ios_base::scientific);
    for (int j = 0; j < indent; j ++)
      os << ' ';
    printStatus(os, status_);
    os << resFormStr();
    if (status_==Undefined)
      os << ", tol = " << tolerance_ << std::endl;
    else {
      os << std::endl;
      if(showMaxResNormOnly_ && curBlksz_ > 1) {
        const MagnitudeType maxRelRes = *std::max_element(
          testvector_.begin()+curLSIdx_[0],testvector_.begin()+curLSIdx_[curBlksz_-1]
          );
        for (int j = 0; j < indent + 13; j ++)
          os << ' ';
        os << "max{residual["<<curLSIdx_[0]<<"..."<<curLSIdx_[curBlksz_-1]<<"]} = " << maxRelRes
           << ( maxRelRes <= tolerance_ ? " <= " : " > " ) << tolerance_ << std::endl;
      }
      else {
        for ( int i=0; i<numrhs_; i++ ) {
          for (int j = 0; j < indent + 13; j ++)
            os << ' ';
          os << "residual [ " << i << " ] = " << testvector_[ i ];
          os << ((testvector_[i]<tolerance_) ? " < " : (testvector_[i]==tolerance_) ? " == " : (testvector_[i]>tolerance_) ? " > " : " "  ) << tolerance_ << std::endl;
        }
      }
    }
    os << std::endl;
  }
 
  void printStatus(std::ostream& os, StatusType type) const {
    os << std::left << std::setw(13) << std::setfill('.');
    switch (type) {
    case  Passed:
      os << "Converged";
      break;
    case  Failed:
      os << "Unconverged";
      break;
    case  Undefined:
    default:
      os << "**";
      break;
    }
    os << std::left << std::setfill(' ');
      return;
  }
 
 
 
  Teuchos::RCP<MV> getSolution() { return curSoln_; }
 
  int getQuorum() const { return quorum_; }
 
  size_t getSubIdx() const { return subIdx_; }
 
  bool getShowMaxResNormOnly() { return showMaxResNormOnly_; }
 
  std::vector<int> convIndices() { return ind_; }
 
  MagnitudeType getTolerance() const {return(tolerance_);};
 
  const std::vector<MagnitudeType>* getTestValue() const {return(&testvector_);};
 
  const std::vector<MagnitudeType>* getResNormValue() const {return(&resvector_);};
 
  const std::vector<MagnitudeType>* getScaledNormValue() const {return(&scalevector_);};
 
  bool getLOADetected() const { return false; }
 
 
 
 
  StatusType firstCallCheckStatusSetup(Iteration<ScalarType,MV,OP>* iSolver) {
    int i;
    MagnitudeType zero = Teuchos::ScalarTraits<MagnitudeType>::zero();
    MagnitudeType one = Teuchos::ScalarTraits<MagnitudeType>::one();
    const LinearProblem<ScalarType,MV,OP>& lp = iSolver->getProblem();
    // Compute scaling term (done once for each block that's being solved)
    if (firstcallCheckStatus_) {
      //
      // Get some current solver information.
      //
      firstcallCheckStatus_ = false;
 
      if (scaletype_== NormOfRHS) {
        Teuchos::RCP<const MV> rhs = lp.getRHS();
        numrhs_ = MVT::GetNumberVecs( *rhs );
        scalevector_.resize( numrhs_ );
        MvSubNorm( *rhs, subIdx_, scalevector_, scalenormtype_ );
      }
      else if (scaletype_==NormOfInitRes) {
        Teuchos::RCP<const MV> init_res = lp.getInitResVec();
        numrhs_ = MVT::GetNumberVecs( *init_res );
        scalevector_.resize( numrhs_ );
        MvSubNorm( *init_res, subIdx_, scalevector_, scalenormtype_ );
      }
      else if (scaletype_==NormOfPrecInitRes) {
        Teuchos::RCP<const MV> init_res = lp.getInitPrecResVec();
        numrhs_ = MVT::GetNumberVecs( *init_res );
        scalevector_.resize( numrhs_ );
        MvSubNorm( *init_res, subIdx_, scalevector_, scalenormtype_ );
      }
      else if (scaletype_==NormOfFullInitRes) {
        Teuchos::RCP<const MV> init_res = lp.getInitResVec();
        numrhs_ = MVT::GetNumberVecs( *init_res );
        scalevector_.resize( numrhs_ );
        MVT::MvNorm( *init_res, scalevector_, scalenormtype_ );
        scalevalue_ = Teuchos::ScalarTraits<MagnitudeType>::one();
      }
      else if (scaletype_==NormOfFullPrecInitRes) {
        Teuchos::RCP<const MV> init_res = lp.getInitPrecResVec();
        numrhs_ = MVT::GetNumberVecs( *init_res );
        scalevector_.resize( numrhs_ );
        MVT::MvNorm( *init_res, scalevector_, scalenormtype_ );
        scalevalue_ = Teuchos::ScalarTraits<MagnitudeType>::one();
      }
      else if (scaletype_==NormOfFullScaledInitRes) {
        Teuchos::RCP<const MV> init_res = lp.getInitResVec();
        numrhs_ = MVT::GetNumberVecs( *init_res );
        scalevector_.resize( numrhs_ );
        MVT::MvNorm( *init_res, scalevector_, scalenormtype_ );
        MvScalingRatio( *init_res, subIdx_, scalevalue_ );
      }
      else if (scaletype_==NormOfFullScaledPrecInitRes) {
        Teuchos::RCP<const MV> init_res = lp.getInitPrecResVec();
        numrhs_ = MVT::GetNumberVecs( *init_res );
        scalevector_.resize( numrhs_ );
        MVT::MvNorm( *init_res, scalevector_, scalenormtype_ );
        MvScalingRatio( *init_res, subIdx_, scalevalue_ );
      }
      else {
        numrhs_ = MVT::GetNumberVecs( *(lp.getRHS()) );
      }
 
      resvector_.resize( numrhs_ );
      testvector_.resize( numrhs_ );
 
      curLSNum_ = lp.getLSNumber();
      curLSIdx_ = lp.getLSIndex();
      curBlksz_ = (int)curLSIdx_.size();
      int validLS = 0;
      for (i=0; i<curBlksz_; ++i) {
        if (curLSIdx_[i] > -1 && curLSIdx_[i] < numrhs_)
          validLS++;
      }
      curNumRHS_ = validLS;
      //
      // Initialize the testvector.
      for (i=0; i<numrhs_; i++) { testvector_[i] = one; }
 
      // Return an error if the scaling is zero.
      if (scalevalue_ == zero) {
        return Failed;
      }
    }
    return Undefined;
  }
 
 
  std::string description() const
  {
    std::ostringstream oss;
    oss << "Belos::StatusTestGenResSubNorm<>: " << resFormStr();
    oss << ", tol = " << tolerance_;
    return oss.str();
  }
 
 protected:
 
 private:
 
 
 
  std::string resFormStr() const
  {
    std::ostringstream oss;
    oss << "(";
    oss << ((resnormtype_==OneNorm) ? "1-Norm" : (resnormtype_==TwoNorm) ? "2-Norm" : "Inf-Norm");
    oss << " Exp";
    oss << " Res Vec [" << subIdx_ << "]) ";
 
    // If there is no residual scaling, return current string.
    if (scaletype_!=None)
    {
      // Insert division sign.
      oss << "/ ";
 
      // Determine output string for scaling, if there is any.
      if (scaletype_==UserProvided)
        oss << " (User Scale)";
      else {
        oss << "(";
        oss << ((scalenormtype_==OneNorm) ? "1-Norm" : (resnormtype_==TwoNorm) ? "2-Norm" : "Inf-Norm");
        if (scaletype_==NormOfInitRes)
          oss << " Res0 [" << subIdx_ << "]";
        else if (scaletype_==NormOfPrecInitRes)
          oss << " Prec Res0 [" << subIdx_ << "]";
        else if (scaletype_==NormOfFullInitRes)
          oss << " Full Res0 [" << subIdx_ << "]";
        else if (scaletype_==NormOfFullPrecInitRes)
          oss << " Full Prec Res0 [" << subIdx_ << "]";
        else if (scaletype_==NormOfFullScaledInitRes)
          oss << " scaled Full Res0 [" << subIdx_ << "]";
        else if (scaletype_==NormOfFullScaledPrecInitRes)
          oss << " scaled Full Prec Res0 [" << subIdx_ << "]";
        else
          oss << " RHS [" << subIdx_ << "]";
        oss << ")";
      }
    }
 
    // TODO add a tagging name
 
    return oss.str();
  }
 
 
 
 
  // calculate norm of partial multivector
  void MvSubNorm( const MV& mv, size_t block, std::vector<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>& normVec, NormType type = TwoNorm) {
    Teuchos::RCP<const MV> input = Teuchos::rcpFromRef(mv);
 
    typedef typename Thyra::ProductMultiVectorBase<ScalarType> TPMVB;
    Teuchos::RCP<const TPMVB> thyProdVec = Teuchos::rcp_dynamic_cast<const TPMVB>(input);
 
    TEUCHOS_TEST_FOR_EXCEPTION(thyProdVec == Teuchos::null, std::invalid_argument,
                             "Belos::StatusTestGenResSubNorm::MvSubNorm (Thyra specialization): "
                             "mv must be a Thyra::ProductMultiVector, but is of type " << thyProdVec);
 
    Teuchos::RCP<const MV> thySubVec = thyProdVec->getMultiVectorBlock(block);
 
    MVT::MvNorm(*thySubVec,normVec,type);
  }
 
  // calculate ration of sub-vector length to full vector length (for scalevalue_)
  void MvScalingRatio( const MV& mv, size_t block, MagnitudeType& lengthRatio) {
    Teuchos::RCP<const MV> input = Teuchos::rcpFromRef(mv);
 
    typedef typename Thyra::ProductMultiVectorBase<ScalarType> TPMVB;
    Teuchos::RCP<const TPMVB> thyProdVec = Teuchos::rcp_dynamic_cast<const TPMVB>(input);
 
    TEUCHOS_TEST_FOR_EXCEPTION(thyProdVec == Teuchos::null, std::invalid_argument,
                             "Belos::StatusTestGenResSubNorm::MvScalingRatio (Thyra specialization): "
                             "mv must be a Thyra::ProductMultiVector, but is of type " << thyProdVec);
 
    Teuchos::RCP<const MV> thySubVec = thyProdVec->getMultiVectorBlock(block);
 
    lengthRatio = Teuchos::as<MagnitudeType>(thySubVec->range()->dim()) / Teuchos::as<MagnitudeType>(thyProdVec->range()->dim());
  }
 
 
 
 
  MagnitudeType tolerance_;
 
  size_t subIdx_;
 
  int quorum_;
 
  bool showMaxResNormOnly_;
 
  NormType resnormtype_;
 
  ScaleType scaletype_;
 
  NormType scalenormtype_;
 
  MagnitudeType scalevalue_;
 
  std::vector<MagnitudeType> scalevector_;
 
  std::vector<MagnitudeType> resvector_;
 
  std::vector<MagnitudeType> testvector_;
 
  std::vector<int> ind_;
 
  Teuchos::RCP<MV> curSoln_;
 
  StatusType status_;
 
  int curBlksz_;
 
  int curNumRHS_;
 
  std::vector<int> curLSIdx_;
 
  int curLSNum_;
 
  int numrhs_;
 
  bool firstcallCheckStatus_;
 
  bool firstcallDefineResForm_;
 
  bool firstcallDefineScaleForm_;
 
 
};
 
#endif // HAVE_BELOS_THYRA
 
} // end namespace Belos
 
#endif /* BELOS_STATUS_TEST_RESSUBNORM_H */