BelosStatusTestOutputter.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                 Belos: Block Linear Solvers Package
//                 Copyright (2004) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @HEADER

#ifndef BELOS_STATUS_TEST_OUTPUTTER_HPP
#define BELOS_STATUS_TEST_OUTPUTTER_HPP

#include "BelosStatusTestResNorm.hpp"
#include "BelosLinearProblem.hpp"
#include "BelosMultiVecTraits.hpp"
#include "BelosOutputManager.hpp"
#include "Teuchos_VerboseObject.hpp"
#include "Teuchos_StandardCompositionMacros.hpp"
#include "Teuchos_StandardMemberCompositionMacros.hpp"

namespace Belos {

template <class ScalarType, class MV, class OP>
class StatusTestOutputter: public StatusTest<ScalarType,MV,OP> {
public:

  
  typedef Teuchos::ScalarTraits<ScalarType> ST;
  typedef typename ST::magnitudeType MagnitudeType;
  typedef StatusTestResNorm<ScalarType,MV,OP> StatusTestResNorm_t;
  
  
  STANDARD_MEMBER_COMPOSITION_MEMBERS( int, outputFrequency )
    
  
  STANDARD_MEMBER_COMPOSITION_MEMBERS( bool, outputMaxResOnly )
    
  STANDARD_MEMBER_COMPOSITION_MEMBERS( std::string, resString )
    
  STANDARD_COMPOSITION_MEMBERS( StatusTestResNorm_t, resNormStatusTest )
  // Note: Above the typedef is needed for this macro to work
    
  STANDARD_COMPOSITION_MEMBERS( OutputManager<ScalarType>, outputManager )
    
  StatusTestOutputter(
    const int                        outputFrequency    = -1
    ,const bool                      outputMaxResOnly   = true
    ,const std::string               &resString         = "||A*x-b||/||b||"
    );
  


  StatusType CheckStatus(IterativeSolver<ScalarType,MV,OP>* iSolver);
  StatusType GetStatus() const;
  void Reset();
  bool ResidualVectorRequired() const;
  ostream& Print(ostream& os, int indent) const;


private:

  int  callsSinceLastOutput_;
  bool iterZeroWasOutput_;
  int  lastRestart_;
  
};

// /////////////////////////
// Implementation

// Constructors/initializers/accessors

template <class ScalarType, class MV, class OP>
StatusTestOutputter<ScalarType,MV,OP>::StatusTestOutputter(
  const int                        outputFrequency
  ,const bool                      outputMaxResOnly
  ,const std::string               &resString
  )
  :outputFrequency_(outputFrequency)
  ,outputMaxResOnly_(outputMaxResOnly)
  ,resString_(resString)
  ,callsSinceLastOutput_(10000)
  ,iterZeroWasOutput_(false)
{}

// Overridden from StatusTests

template <class ScalarType, class MV, class OP>
StatusType StatusTestOutputter<ScalarType,MV,OP>::CheckStatus(IterativeSolver<ScalarType,MV,OP>* iSolver)
{
  typedef MultiVecTraits<ScalarType,MV>  MVT;
  StatusType status = resNormStatusTest_->CheckStatus(iSolver);
  RefCountPtr<LinearProblem<ScalarType,MV,OP> > lp = iSolver->GetLinearProblem();
  const int currIter = iSolver->GetNumIters();
  const int currRestart = iSolver->GetNumRestarts();
  if(currIter==0 && !iterZeroWasOutput_)
    lastRestart_ = -1;
  ++callsSinceLastOutput_;
  if(
    ( outputFrequency() > 0 )
    &&
    (
      status==Converged
      ||
      callsSinceLastOutput_>=outputFrequency()
      ||
      currRestart > lastRestart_
      ||
      ( currIter==0 && !iterZeroWasOutput_ )
      )
    )
  {
    const int currRhsOffset = lp->GetRHSIndex();
    const int currNumRhs = lp->GetNumToSolve();
    TEST_FOR_EXCEPT(resNormStatusTest_->GetTestValue()==NULL);
    const std::vector<MagnitudeType> &resTestValuesVector = *resNormStatusTest_->GetTestValue();
    std::ostream &out = *outputManager_->GetOStream();
    if(status==Converged)
      out << "[Converged]";
    out << "iter="<<currIter<<", restart="<<currRestart;
    const MagnitudeType maxRelRes = *std::max_element(
      resTestValuesVector.begin()+currRhsOffset,resTestValuesVector.begin()+currRhsOffset+currNumRhs
      );
    if(currNumRhs==1) {
      out << ", "<<resString()<<"="<<maxRelRes<<"\n";
    }
    else {
      if(outputMaxResOnly()) {
        out << ", max{"<<resString()<<",i="<<currRhsOffset<<"..."<<currRhsOffset+currNumRhs-1<<"}=" << maxRelRes << "\n";
      }
      else {
        out << ", "<<resString()<<":\n";
        for(int i=0; i<currNumRhs; ++i) {
          out <<"  "<<(i+currRhsOffset)<<": "<<resTestValuesVector[i+currRhsOffset]<<"\n"; 
        }
      }
    }
    if(currIter==0) {
      iterZeroWasOutput_ = true;
    }
    else {
      iterZeroWasOutput_ = false;
    }
    lastRestart_ = currRestart;
    callsSinceLastOutput_ = 0;
  }
  return status;
}

template <class ScalarType, class MV, class OP>
StatusType StatusTestOutputter<ScalarType,MV,OP>::GetStatus() const
{
  return resNormStatusTest_->GetStatus();
}

template <class ScalarType, class MV, class OP>
void StatusTestOutputter<ScalarType,MV,OP>::Reset()
{
  return resNormStatusTest_->Reset();
  callsSinceLastOutput_ = 10000;
  iterZeroWasOutput_ = false;
}

template <class ScalarType, class MV, class OP>
bool StatusTestOutputter<ScalarType,MV,OP>::ResidualVectorRequired() const
{
  return resNormStatusTest_->ResidualVectorRequired();
}

template <class ScalarType, class MV, class OP>
ostream& StatusTestOutputter<ScalarType,MV,OP>::Print(ostream& os, int indent) const
{
  return resNormStatusTest_->Print(os,indent);
}

} // end namespace Belos

#endif // BELOS_STATUS_TEST_OUTPUTTER_HPP

---