BelosStatusTestGeneralOutput.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_GENERAL_OUTPUT_HPP
#define BELOS_STATUS_TEST_GENERAL_OUTPUT_HPP
 
#include "BelosConfigDefs.hpp"
#include "BelosTypes.hpp"
#include "BelosIteration.hpp"
 
#include "BelosStatusTest.hpp"
#include "BelosStatusTestOutput.hpp"
#include "BelosOutputManager.hpp"
 
namespace Belos {
 
template <class ScalarType, class MV, class OP>
class StatusTestGeneralOutput : public StatusTestOutput<ScalarType,MV,OP> {
 
 public:
 
 
  StatusTestGeneralOutput(const Teuchos::RCP<OutputManager<ScalarType> > &printer, 
        Teuchos::RCP<StatusTest<ScalarType,MV,OP> > test,
        int mod = 1,
        int printStates = Passed)
    : printer_(printer), 
      test_(test), 
      state_(Undefined), 
      stateTest_(printStates), 
      modTest_(mod), 
      numCalls_(0) 
  {}
 
  virtual ~StatusTestGeneralOutput() {};
 
 
 
  StatusType checkStatus( Iteration<ScalarType,MV,OP>* solver ) {
    TEUCHOS_TEST_FOR_EXCEPTION(test_ == Teuchos::null,StatusTestError,"StatusTestGeneralOutput::checkStatus(): child pointer is null.");
    state_ = test_->checkStatus(solver);
 
    if (numCalls_++ % modTest_ == 0) {
      if ( (state_ & stateTest_) == state_) {
        if ( printer_->isVerbosity(StatusTestDetails) ) {
          print( printer_->stream(StatusTestDetails) );
        }
        else if ( printer_->isVerbosity(Debug) ) {
          print( printer_->stream(Debug) );
        }
      }
    }
 
    return state_;
  }
 
  StatusType getStatus() const {
    return state_;
  }
 
 
 
 
  void setOutputManager(const Teuchos::RCP<OutputManager<ScalarType> > &printer) { printer_ = printer; }
 
  void setOutputFrequency(int mod) { modTest_ = mod; }
 
  void setChild(Teuchos::RCP<StatusTest<ScalarType,MV,OP> > test) {
    test_ = test;
    state_ = Undefined;
  }
 
  Teuchos::RCP<StatusTest<ScalarType,MV,OP> > getChild() const {
    return test_;
  }
 
  void setSolverDesc(const std::string& solverDesc) { solverDesc_ = solverDesc; }
 
  void setPrecondDesc(const std::string& precondDesc) { precondDesc_ = precondDesc; }
 
 
 
 
 
  void reset() { 
    state_ = Undefined;
    test_->reset();
    numCalls_ = 0;
  }
 
  void resetNumCalls() { numCalls_ = 0; }
 
 
 
  
  void print(std::ostream& os, int indent = 0) const {
    std::string ind(indent,' ');
    os << std::endl << ind << "Belos::StatusTestGeneralOutput: ";
    switch (state_) {
    case Passed:
      os << "Passed" << std::endl;
      break;
    case Failed:
      os << "Failed" << std::endl;
      break;
    case Undefined:
      os << "Undefined" << std::endl;
      break;
    }
    os << ind << "  (Num calls,Mod test,State test): " << "(" << numCalls_ << ", " << modTest_ << ",";
    if (stateTest_ == 0) {
      os << " none)" << std::endl;
    }
    else {
      if ( stateTest_ & Passed ) os << " Passed";
      if ( stateTest_ & Failed ) os << " Failed";
      if ( stateTest_ & Undefined ) os << " Undefined";
      os << ")" << std::endl;
    }
    // print child, with extra indention
    test_->print(os,indent+3);
  }
 
 
  private:
    Teuchos::RCP<OutputManager<ScalarType> > printer_;
    Teuchos::RCP<StatusTest<ScalarType,MV,OP> > test_;
    std::string solverDesc_;
    std::string precondDesc_;
    StatusType state_;
    int stateTest_;
    int modTest_;
    int numCalls_;
};
 
} // end of Belos namespace
 
#endif /* BELOS_STATUS_TEST_OUTPUT_HPP */