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

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

namespace Belos {

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

#ifndef DOXYGEN_SHOULD_SKIP_THIS

  typedef std::vector< StatusTest<ScalarType,MV,OP>* > 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, StatusTest<ScalarType,MV,OP>& test1);

  StatusTestCombo(ComboType t, StatusTest<ScalarType,MV,OP>& test1, StatusTest<ScalarType,MV,OP>& test2);

  StatusTestCombo<ScalarType,MV,OP>& AddStatusTest(StatusTest<ScalarType,MV,OP>& add_test);

  virtual ~StatusTestCombo() {};


  

  StatusType CheckStatus( IterativeSolver<ScalarType,MV,OP>* iSolver );

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





  void Reset(); 




  ComboType GetComboType() const {return(type_);};





  bool ResidualVectorRequired() const;



  
  ostream& Print(ostream& os, int indent = 0) const;
  

protected:



  void OrOp( IterativeSolver<ScalarType,MV,OP>* iSolver );

  void AndOp( IterativeSolver<ScalarType,MV,OP>* iSolver );

  void SeqOp( IterativeSolver<ScalarType,MV,OP>* iSolver );

  bool IsSafe(StatusTest<ScalarType,MV,OP>& test1);

 private:



  ComboType type_;

  st_vector tests_;

   StatusType status_;

};

template <class ScalarType, class MV, class OP>
StatusTestCombo<ScalarType,MV,OP>::StatusTestCombo(ComboType t)
{
  type_ = t;
  status_ = Unchecked;
}

template <class ScalarType, class MV, class OP>
StatusTestCombo<ScalarType,MV,OP>::StatusTestCombo(ComboType t, StatusTest<ScalarType,MV,OP>& test1)
{
  type_ = t;
  tests_.push_back(&test1);
  status_ = Unchecked;
}

template <class ScalarType, class MV, class OP>
StatusTestCombo<ScalarType,MV,OP>::StatusTestCombo(ComboType t, StatusTest<ScalarType,MV,OP>& test1, StatusTest<ScalarType,MV,OP>& test2)
{
  type_ = t;
  tests_.push_back(&test1);
  AddStatusTest(test2);
  status_ = Unchecked;
}

template <class ScalarType, class MV, class OP>
StatusTestCombo<ScalarType,MV,OP>& StatusTestCombo<ScalarType,MV,OP>::AddStatusTest(StatusTest<ScalarType,MV,OP>& add_test)
{
  if (IsSafe(add_test))
    tests_.push_back(&add_test);
  else
    {
      const int indent = 2;
      cout << "\n*** WARNING! ***\n";
      cout << "This combo test currently consists of the following:\n";
      this->Print(cout, indent);
      cout << "Unable to add the following test:\n";
      add_test.Print(cout, indent);
      cout << "\n";
    }
  return *this;
}

template <class ScalarType, class MV, class OP>
bool StatusTestCombo<ScalarType,MV,OP>::IsSafe(StatusTest<ScalarType,MV,OP>& test1)
{
  // Are we trying to add "this" to "this"? This would result in an infinite recursion.
  if (&test1 == 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>* ptr = dynamic_cast< StatusTestCombo<ScalarType,MV,OP> *>(*i);
    if (ptr != NULL)
      if (!ptr->IsSafe(test1))
        return false;
  }
  return true;
}

template <class ScalarType, class MV, class OP>
bool StatusTestCombo<ScalarType,MV,OP>::ResidualVectorRequired() const
{
  // If any of the StatusTest object require the residual vector, then return true.
  
  // Recursively test this property.
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) {
    
    StatusTest<ScalarType,MV,OP>* ptr = dynamic_cast< StatusTest<ScalarType,MV,OP> *>(*i);
    if (ptr != NULL)
      if (ptr->ResidualVectorRequired())
        return true;
  }
  
  // Otherwise we don't need residual vector.
  return false;
}

template <class ScalarType, class MV, class OP>
StatusType StatusTestCombo<ScalarType,MV,OP>::CheckStatus( IterativeSolver<ScalarType,MV,OP>* iSolver )
{
  status_ = Unconverged;

  if (type_ == OR)
    OrOp( iSolver );
  else if (type_ == AND)
    AndOp( iSolver );
  else
    SeqOp( iSolver );

  return status_;
}

template <class ScalarType, class MV, class OP>
void StatusTestCombo<ScalarType,MV,OP>::Reset( )
{
  // Resets all status tests in my list.
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) 
    {
      (*i)->Reset();
    }
  // Reset my status.
  status_ = Unchecked;
  //
  return;
}

template <class ScalarType, class MV, class OP>
void StatusTestCombo<ScalarType,MV,OP>::OrOp( IterativeSolver<ScalarType,MV,OP>* iSolver )
{
  bool isFailed = false;

  // 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 and NaN.  Combo treats NaNs as Fails
      if (s==Failed || s==NaN) isFailed = true;
      
      if ((status_ == Unconverged) && (s != Unconverged)) {
  status_ = s;
      }      
    }
  
  // Any failure is a complete failure
  if (isFailed) status_ = Failed;
  
  return;
}

template <class ScalarType, class MV, class OP>
void StatusTestCombo<ScalarType,MV,OP>::AndOp( IterativeSolver<ScalarType,MV,OP>* iSolver )
{
  bool isUnconverged = false;
  bool isFailed = false;
  
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) {
    
    StatusType s = (*i)->CheckStatus( iSolver );

    // Check for failure and NaN.  Combo treats NaNs as Fails
    if (s==Failed || s==NaN) isFailed = true;

    // If any of the tests are unconverged, then the AND test is
    // unconverged.
    if (s == Unconverged) {
      isUnconverged = true;
      status_ = Unconverged;
    }

    // If this is the first test and it's converged/failed, copy its
    // status to the combo status.
    if ((!isUnconverged) && (status_ == Unconverged)) {
      status_ = s;
    }
  }
  
  // Any failure is a complete failure
  if (isFailed) status_ = Failed;
  
  return;
}

template <class ScalarType, class MV, class OP>
void StatusTestCombo<ScalarType,MV,OP>::SeqOp( IterativeSolver<ScalarType,MV,OP>* iSolver ) 
{
  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i) {

    StatusType s = (*i)->CheckStatus( iSolver );

    // Check for failure and NaN.  Combo treats NaNs as Fails
    if (s==Failed || s==NaN) {
      status_ = Failed;
      return;
    }
    else if (s==Unconverged) {
      status_ = s;
      return;
    }
  }
  // If we make it here, we have converged
  status_ = Converged;

  return;
}

template <class ScalarType, class MV, class OP>
ostream& StatusTestCombo<ScalarType,MV,OP>::Print(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 << " -> " << endl;

  for (const_iterator i = tests_.begin(); i != tests_.end(); ++i)
    (*i)->Print(os, indent+2);

  return os;
}

} // end namespace Belos

#endif /* BELOS_STATUS_TEST_COMBO_H */

---