BelosStatusTestCombo.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_COMBO_H
#define BELOS_STATUS_TEST_COMBO_H

  
#include "BelosStatusTest.hpp"
#include <vector>

 
namespace Belos {
 
template <class ScalarType, class MV, class OP, class DM = DefaultDenseMatrix<int,ScalarType>>
class StatusTestCombo: public StatusTest<ScalarType,MV,OP,DM> {
  
 public:
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
  typedef std::vector< Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> > > st_vector;
  typedef typename st_vector::iterator iterator;
  typedef typename st_vector::const_iterator const_iterator;
 
#endif // DOXYGEN_SHOULD_SKIP_THIS
  


  enum ComboType {AND,  
      OR,   
      SEQ   
  };



  StatusTestCombo(ComboType t);

  StatusTestCombo(ComboType t, 
      const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& test1);

  StatusTestCombo(ComboType t, 
      const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& test1, 
      const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& test2);

  StatusTestCombo<ScalarType,MV,OP,DM>& addStatusTest(const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& add_test);

  virtual ~StatusTestCombo() {};


  
  StatusType checkStatus( Iteration<ScalarType,MV,OP,DM>* iSolver );

  StatusType getStatus() const { return(status_); };





  void reset(); 




  ComboType getComboType() const { return type_; }

  st_vector getStatusTests() { return tests_; }



  
  void print(std::ostream& os, int indent = 0) const;
  
 
protected:



  void orOp( Iteration<ScalarType,MV,OP,DM>* iSolver );

  void andOp( Iteration<ScalarType,MV,OP,DM>* iSolver );

  void seqOp( Iteration<ScalarType,MV,OP,DM>* iSolver );

  bool isSafe( const Teuchos:: RCP<StatusTest<ScalarType,MV,OP,DM> >& test1);
 
 private:



  ComboType type_;

  st_vector tests_;

  StatusType status_;
 
};
 
template <class ScalarType, class MV, class OP, class DM>
StatusTestCombo<ScalarType,MV,OP,DM>::StatusTestCombo(ComboType t)
{
  type_ = t;
  status_ = Undefined;
}
 
template <class ScalarType, class MV, class OP, class DM>
StatusTestCombo<ScalarType,MV,OP,DM>::StatusTestCombo(ComboType t, 
               const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& test1)
{
  type_ = t;
  tests_.push_back(test1);
  status_ = Undefined;
}
 
template <class ScalarType, class MV, class OP, class DM>
StatusTestCombo<ScalarType,MV,OP,DM>::StatusTestCombo(ComboType t, 
               const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& test1, 
               const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& test2)
{
  type_ = t;
  tests_.push_back(test1);
  addStatusTest(test2);
  status_ = Undefined;
}
 
template <class ScalarType, class MV, class OP, class DM>
StatusTestCombo<ScalarType,MV,OP,DM>& StatusTestCombo<ScalarType,MV,OP,DM>::addStatusTest(const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& add_test)
{
  if (isSafe(add_test))
    tests_.push_back(add_test);
  else
    {
      const int indent = 2;
      std::cout << "\n*** WARNING! ***\n";
      std::cout << "This combo test currently consists of the following:\n";
      this->print(std::cout, indent);
      std::cout << "Unable to add the following test:\n";
      add_test->print(std::cout, indent);
      std::cout << "\n";
    }
  return *this;
}
 
template <class ScalarType, class MV, class OP, class DM>
bool StatusTestCombo<ScalarType,MV,OP,DM>::isSafe( const Teuchos::RCP<StatusTest<ScalarType,MV,OP,DM> >& test1)
{
  // Are we trying to add "this" to "this"? This would result in an infinite recursion.
  if (test1.get() == this)
    return false;
  
  // Recursively test that we're not adding something that's already
  // in the list because that can also lead to infinite recursions.
  for (iterator i = tests_.begin(); i != tests_.end(); ++i) {
    
    StatusTestCombo<ScalarType,MV,OP,DM>* ptr = dynamic_cast<StatusTestCombo<ScalarType,MV,OP,DM> *>(i->get());
    if (ptr != NULL)
      if (!ptr->isSafe(test1))
        return false;
  }
  return true;
}
 
template <class ScalarType, class MV, class OP, class DM>
StatusType StatusTestCombo<ScalarType,MV,OP,DM>::checkStatus( Iteration<ScalarType,MV,OP,DM>* iSolver )
{
  status_ = Failed;
 
  if (type_ == OR)
    orOp( iSolver );
  else if (type_ == AND)
    andOp( iSolver );
  else
    seqOp( iSolver );
 
  return status_;
}
 
template <class ScalarType, class MV, class OP, class DM>
void StatusTestCombo<ScalarType,MV,OP,DM>::reset( )
{
  // Resets all status tests in my list.
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) 
    {
      (*i)->reset();
    }
  // Reset my status.
  status_ = Undefined;
  //
  return;
}
 
template <class ScalarType, class MV, class OP, class DM>
void StatusTestCombo<ScalarType,MV,OP,DM>::orOp( Iteration<ScalarType,MV,OP,DM>* iSolver )
{
  status_ = Failed;
 
  // Checks the status of each test. The first test it encounters, if
  // any, that is unconverged is the status that it sets itself too.
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) 
    {
      StatusType s = (*i)->checkStatus( iSolver );
 
      // Check for failure.
      if (s==Passed) status_ = Passed;
    }
}
 
template <class ScalarType, class MV, class OP, class DM>
void StatusTestCombo<ScalarType,MV,OP,DM>::andOp( Iteration<ScalarType,MV,OP,DM>* iSolver )
{
  bool isFailed = false;
  
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) {
    
    StatusType s = (*i)->checkStatus( iSolver );
 
    // Check for failure.
    if (s==Failed) isFailed = true;
 
    // If any of the tests are failed, then the AND test is failed.
    if (s == Failed) {
      status_ = Failed;
    }
 
    // If this is the first test and it's failed, copy its
    // status to the combo status.
    if ((!isFailed) && (status_ == Failed)) {
      status_ = s;
    }
  }
  
  // Any failure is a complete failure
  if (isFailed) status_ = Failed;
  
  return;
}
 
template <class ScalarType, class MV, class OP, class DM>
void StatusTestCombo<ScalarType,MV,OP,DM>::seqOp( Iteration<ScalarType,MV,OP,DM>* iSolver ) 
{
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) {
 
    StatusType s = (*i)->checkStatus( iSolver );
 
    // Check for failure.
    if (s==Failed) {
      status_ = Failed;
      return;
    }
    else if (s==Undefined) {
      status_ = s;
      return;
    }
  }
  // If we make it here, we have converged
  status_ = Passed;
 
  return;
}
 
template <class ScalarType, class MV, class OP, class DM>
void StatusTestCombo<ScalarType,MV,OP,DM>::print(std::ostream& os, int indent) const {
  for (int j = 0; j < indent; j ++)
    os << ' ';
  this->printStatus(os, status_);
  os << ((type_ == OR) ? "OR" : (type_ == AND) ? "AND" :"SEQ");
  os << " Combination";
  os << " -> " << std::endl;
 
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i)
    (*i)->print(os, indent+2);
}
 
} // end namespace Belos
 
#endif /* BELOS_STATUS_TEST_COMBO_H */