AnasaziStatusTestCombo.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                 Anasazi: Block Eigensolvers 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 ANASAZI_STATUS_TEST_COMBO_HPP
#define ANASAZI_STATUS_TEST_COMBO_HPP

#include "AnasaziTypes.hpp"
#include "AnasaziStatusTest.hpp"
#include "Teuchos_Array.hpp"

namespace Anasazi {


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

 private:
   typedef Teuchos::Array< Teuchos::RefCountPtr< StatusTest<ScalarType,MV,OP> > > STPArray;

 public:

 enum ComboType
   {
     OR,           
     AND,          
     SEQOR,        
     SEQAND        
   };


#ifndef DOXYGEN_SHOULD_SKIP_THIS

  typedef Teuchos::Array< Teuchos::RefCountPtr< StatusTest<ScalarType,MV,OP> > > t_arr;
  typedef std::vector< Teuchos::RefCountPtr< 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



  StatusTestCombo() : state_(Undefined) {}

  StatusTestCombo(ComboType type, Teuchos::Array< Teuchos::RefCountPtr< StatusTest<ScalarType,MV,OP> > > tests) :
    state_(Undefined), 
    type_(type)
  {
    setTests(tests);
  };

  virtual ~StatusTestCombo() {};



  TestStatus checkStatus( Eigensolver<ScalarType,MV,OP>* solver );

  TestStatus getStatus() const {
    return state_;
  }



  void setComboType(ComboType type) {
    type_ = type;
    state_ = Undefined;
  }

  ComboType getComboType() const {return type_;}

  void setTests(Teuchos::Array<Teuchos::RefCountPtr<StatusTest<ScalarType,MV,OP> > > tests) {
    tests_ = tests;
    state_ = Undefined;
  }

  Teuchos::Array<Teuchos::RefCountPtr<StatusTest<ScalarType,MV,OP> > > getTests() const {return tests_;}

  void addTest(Teuchos::RefCountPtr<StatusTest<ScalarType,MV,OP> > test) {
    tests_.push_back(test);
    state_ = Undefined;
  }

  void removeTest(const Teuchos::RefCountPtr<StatusTest<ScalarType,MV,OP> > &test);





  void reset();


  void clearStatus();



  
  ostream& print(ostream& os, int indent = 0) const;
 
  private:

  TestStatus evalOR(Eigensolver<ScalarType,MV,OP>* solver);
  TestStatus evalAND(Eigensolver<ScalarType,MV,OP>* solver);
  TestStatus evalSEQOR(Eigensolver<ScalarType,MV,OP>* solver);
  TestStatus evalSEQAND(Eigensolver<ScalarType,MV,OP>* solver);

  TestStatus state_;
  ComboType type_;
  STPArray tests_;

};


template <class ScalarType, class MV, class OP>
void StatusTestCombo<ScalarType,MV,OP>::removeTest(const Teuchos::RefCountPtr<StatusTest<ScalarType,MV,OP> > &test) 
{
  typename STPArray::iterator iter1;
  iter1 = find(tests_.begin(),tests_.end(),test);
  if (iter1 != tests_.end()) {
    tests_.erase(iter1);
    state_ = Undefined;
  }
}


template <class ScalarType, class MV, class OP>
TestStatus StatusTestCombo<ScalarType,MV,OP>::checkStatus( Eigensolver<ScalarType,MV,OP>* solver ) {
  clearStatus();
  switch (type_) {
    case OR:
      state_ = evalOR(solver);
      break;
    case AND:
      state_ = evalAND(solver);
      break;
    case SEQOR:
      state_ = evalSEQOR(solver);
      break;
    case SEQAND:
      state_ = evalSEQAND(solver);
      break;
  }
  return state_;
}


template <class ScalarType, class MV, class OP>
void StatusTestCombo<ScalarType,MV,OP>::reset() {
  state_ = Undefined;
  for (iterator i=tests_.begin(); i != tests_.end(); i++) {
    (*i)->reset();
  }
}

template <class ScalarType, class MV, class OP>
void StatusTestCombo<ScalarType,MV,OP>::clearStatus() {
  state_ = Undefined;
  for (iterator i=tests_.begin(); i != tests_.end(); i++) {
    (*i)->clearStatus();
  }
}

template <class ScalarType, class MV, class OP>
ostream& StatusTestCombo<ScalarType,MV,OP>::print(ostream& os, int indent) const {
  string ind(indent,' ');
  os << ind << "- StatusTestCombo: ";
  switch (state_) {
  case Passed:
    os << "Passed" << endl;
    break;
  case Failed:
    os << "Failed" << endl;
    break;
  case Undefined:
    os << "Undefined" << endl;
    break;
  }
  // print children, with extra indention
  for (const_iterator i=tests_.begin(); i != tests_.end(); i++) {
    (*i)->print(os,indent+2);
  }
  return os;
}

template <class ScalarType, class MV, class OP>
TestStatus StatusTestCombo<ScalarType,MV,OP>::evalOR( Eigensolver<ScalarType,MV,OP>* solver ) {
  state_ = Failed;
  for (iterator i=tests_.begin(); i != tests_.end(); i++) {
    TestStatus r = (*i)->checkStatus(solver);
    if (r == Passed) {
      state_ = Passed;
    }
    else {
      TEST_FOR_EXCEPTION(r != Failed,StatusTestError,
                         "Anasazi::StatusTestCombo::evalOR(): child test gave invalid return");
    }
  }
  return state_;
}

template <class ScalarType, class MV, class OP>
TestStatus StatusTestCombo<ScalarType,MV,OP>::evalSEQOR( Eigensolver<ScalarType,MV,OP>* solver ) {
  state_ = Failed;
  for (iterator i=tests_.begin(); i != tests_.end(); i++) {
    TestStatus r = (*i)->checkStatus(solver);
    if (r == Passed) {
      state_ = Passed;
      break;
    }
    else {
      TEST_FOR_EXCEPTION(r != Failed,StatusTestError,
                         "Anasazi::StatusTestCombo::evalSEQOR(): child test gave invalid return");
    }
  }
  return state_;
}

template <class ScalarType, class MV, class OP>
TestStatus StatusTestCombo<ScalarType,MV,OP>::evalAND( Eigensolver<ScalarType,MV,OP>* solver ) {
  state_ = Passed;
  for (iterator i=tests_.begin(); i != tests_.end(); i++) {
    TestStatus r = (*i)->checkStatus(solver);
    if (r == Failed) {
      state_ = Failed;
    }
    else {
      TEST_FOR_EXCEPTION(r != Passed,StatusTestError,
                         "Anasazi::StatusTestCombo::evalAND(): child test gave invalid return");
    }
  }
  return state_;
}

template <class ScalarType, class MV, class OP>
TestStatus StatusTestCombo<ScalarType,MV,OP>::evalSEQAND( Eigensolver<ScalarType,MV,OP>* solver ) {
  state_ = Passed;
  for (iterator i=tests_.begin(); i != tests_.end(); i++) {
    TestStatus r = (*i)->checkStatus(solver);
    if (r == Failed) {
      state_ = Failed;
      break;
    }
    else {
      TEST_FOR_EXCEPTION(r != Passed,StatusTestError,
                         "Anasazi::StatusTestCombo::evalAND(): child test gave invalid return");
    }
  }
  return state_;
}



} // end of Anasazi namespace

#endif /* ANASAZI_STATUS_TEST_COMBO_HPP */

---