AnasaziStatusTestOutput.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                 Anasazi: Block Eigensolvers Package
//
// Copyright 2004 NTESS and the Anasazi contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
//
 
#ifndef ANASAZI_STATUS_TEST_OUTPUT_HPP
#define ANASAZI_STATUS_TEST_OUTPUT_HPP
 
#include "AnasaziConfigDefs.hpp"
#include "AnasaziTypes.hpp"
#include "AnasaziEigensolver.hpp"
 
#include "AnasaziStatusTest.hpp"
 
 
 
namespace Anasazi {
 
template <class ScalarType, class MV, class OP>
class StatusTestOutput : public StatusTest<ScalarType,MV,OP> {
 
 public:
 
 
  StatusTestOutput(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 ~StatusTestOutput() {};
 
 
 
  TestStatus checkStatus( Eigensolver<ScalarType,MV,OP>* solver ) {
    TEUCHOS_TEST_FOR_EXCEPTION(test_ == Teuchos::null,StatusTestError,"StatusTestOutput::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_;
  }
 
  TestStatus getStatus() const {
    return state_;
  }
 
  std::vector<int> whichVecs() const {
    return std::vector<int>(0);
  }
 
  int howMany() const {
    return 0;
  }
 
 
 
 
 
  void setChild(Teuchos::RCP<StatusTest<ScalarType,MV,OP> > test) {
    test_ = test;
    state_ = Undefined;
  }
 
  Teuchos::RCP<StatusTest<ScalarType,MV,OP> > getChild() const {
    return test_;
  }
 
 
 
 
 
  void reset() { 
    state_ = Undefined;
    if (test_ != Teuchos::null) {
      test_->reset();
    }
    numCalls_ = 0;
  }
 
  void clearStatus() {
    state_ = Undefined;
    if (test_ != Teuchos::null) {
      test_->clearStatus();
    }
  }
 
 
 
  
  std::ostream& print(std::ostream& os, int indent = 0) const {
    std::string ind(indent,' ');
    os << ind << "- StatusTestOutput: ";
    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) == Passed ) os << " Passed";
      if ( (stateTest_ & Failed) == Failed ) os << " Failed";
      if ( (stateTest_ & Undefined) == Undefined ) os << " Undefined";
      os << " )" << std::endl;
    }
    // print child, with extra indention
    test_->print(os,indent+3);
    return os;
  }
 
 
  private:
    Teuchos::RCP<OutputManager<ScalarType> > printer_;
    Teuchos::RCP<StatusTest<ScalarType,MV,OP> > test_;
    TestStatus state_;
    int stateTest_;
    int modTest_;
    int numCalls_;
};
 
} // end of Anasazi namespace
 
#endif /* ANASAZI_STATUS_TEST_OUTPUT_HPP */