BelosOrthoManagerFactory.hpp

Go to the documentation of this file.

//@HEADER
// ************************************************************************
//
//                 Belos: Block Linear Solvers Package
//                  Copyright 2004 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
//@HEADER

#ifndef __Belos_OrthoManagerFactory_hpp
#define __Belos_OrthoManagerFactory_hpp

#include <BelosConfigDefs.hpp>
#ifdef HAVE_BELOS_TSQR
#  include <BelosTsqrOrthoManager.hpp>
#endif // HAVE_BELOS_TSQR
#include <BelosICGSOrthoManager.hpp>
#include <BelosIMGSOrthoManager.hpp>
#include <BelosDGKSOrthoManager.hpp>
#include <BelosSimpleOrthoManager.hpp>
#include <BelosOutputManager.hpp>

#include <Teuchos_StandardCatchMacros.hpp>

#include <algorithm>
#include <sstream>
#include <stdexcept> // #include <string>
#include <vector>


namespace Belos {

  template<class Scalar, class MV, class OP>
  class OrthoManagerFactory {
  private:
    std::vector<std::string> theList_;

  public:
    static int numOrthoManagers () {
#ifdef HAVE_BELOS_TSQR
      return 5; 
#else
      return 4;
#endif // HAVE_BELOS_TSQR
    }

    static bool isRankRevealing (const std::string& name) {
#ifdef HAVE_BELOS_TSQR
      // Currently only TSQR has a full rank-revealing capability.
      return (name == "TSQR");
#else
      return false;
#endif // HAVE_BELOS_TSQR
    }

    OrthoManagerFactory () : theList_ (numOrthoManagers())
    {
      int index = 0;
      theList_[index++] = "DGKS";
      theList_[index++] = "ICGS";
      theList_[index++] = "IMGS";
#ifdef HAVE_BELOS_TSQR
      theList_[index++] = "TSQR";
#endif // HAVE_BELOS_TSQR
      theList_[index++] = "Simple";
    }

    const std::vector<std::string>& 
    validNames () const { return theList_; }

    bool
    isValidName (const std::string& name) const 
    {
      return (std::find (theList_.begin(), theList_.end(), name) != theList_.end());
    }

    std::ostream&
    printValidNames (std::ostream& out) const
    {
      const int numValid = numOrthoManagers();
      TEUCHOS_TEST_FOR_EXCEPTION(numValid <= 0, std::logic_error,
       "Invalid number " << numValid << " of valid MatOrtho"
       "Manager names.  Please report this bug to the Belos "
       "developers." );
      if (numValid > 1) {
  for (int k = 0; k < numValid - 1; ++k)
    out << "\"" << theList_[k] << "\", ";
  out << "or ";
      }
      out << "\"" << theList_[numValid-1] << "\"";
      return out;
    }

    std::string
    validNamesString () const
    {
      std::ostringstream os;
      (void) printValidNames (os);
      return os.str();
    }

    const std::string& defaultName () const { return theList_[0]; }

    Teuchos::RCP<const Teuchos::ParameterList> 
    getDefaultParameters (const std::string& name) const
    {
      if (name == "DGKS") {
  DGKSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getValidParameters ();
      }
#ifdef HAVE_BELOS_TSQR
      else if (name == "TSQR") {
  TsqrMatOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getValidParameters ();
      }
#endif // HAVE_BELOS_TSQR
      else if (name == "ICGS") {
  ICGSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getValidParameters ();
      }
      else if (name == "IMGS") {
  IMGSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getValidParameters ();
      }
      else if (name == "Simple") {
  IMGSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getValidParameters ();
      }
      else {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, 
         "Invalid orthogonalization manager name \"" << name 
         << "\": Valid names are " << validNamesString() 
         << ".  For many of the test executables, the "
         "orthogonalization manager name often corresponds "
         "to the \"ortho\" command-line argument.");
  // Placate the compiler if necessary; we should never reach
  // this point.
  return Teuchos::null; 
      }
    }

    Teuchos::RCP<const Teuchos::ParameterList> 
    getFastParameters (const std::string& name) const
    {
      if (name == "DGKS") {
  DGKSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getFastParameters ();
      }
#ifdef HAVE_BELOS_TSQR
      else if (name == "TSQR") {
  TsqrMatOrthoManager<Scalar, MV, OP> orthoMan; 
  return orthoMan.getFastParameters ();
      }
#endif // HAVE_BELOS_TSQR
      else if (name == "ICGS") {
  ICGSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getFastParameters ();
      }
      else if (name == "IMGS") {
  IMGSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getFastParameters ();
      }
      else if (name == "Simple") {
  IMGSOrthoManager<Scalar, MV, OP> orthoMan;
  return orthoMan.getFastParameters ();
      }
      else {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, 
         "Invalid orthogonalization manager name \"" << name 
         << "\": Valid names are " << validNamesString() 
         << ".  For many of the test executables, the "
         "orthogonalization manager name often corresponds "
         "to the \"ortho\" command-line argument.");
  // Placate the compiler if necessary; we should never reach
  // this point.
  return Teuchos::null; 
      }
    }

    Teuchos::RCP<Belos::MatOrthoManager<Scalar, MV, OP> >
    makeMatOrthoManager (const std::string& ortho, 
       const Teuchos::RCP<const OP>& M,
       const Teuchos::RCP<OutputManager<Scalar> >& outMan,
       const std::string& label,
       const Teuchos::RCP<Teuchos::ParameterList>& params)
    {
#ifdef HAVE_BELOS_TSQR
      using Belos::TsqrMatOrthoManager;
#endif // HAVE_BELOS_TSQR
      using Belos::ICGSOrthoManager;
      using Belos::IMGSOrthoManager;
      using Belos::DGKSOrthoManager;
      using Belos::SimpleOrthoManager;
      using Teuchos::rcp;

      if (ortho == "DGKS") {
  typedef DGKSOrthoManager<Scalar, MV, OP> dgks_type;
  return rcp (new dgks_type (params, label, M));
      }
#ifdef HAVE_BELOS_TSQR
      else if (ortho == "TSQR") {
  typedef TsqrMatOrthoManager<Scalar, MV, OP> ortho_type;
  return rcp (new ortho_type (params, label, M));
      }
#endif // HAVE_BELOS_TSQR
      else if (ortho == "ICGS") {
  typedef ICGSOrthoManager<Scalar, MV, OP> ortho_type;
  return rcp (new ortho_type (params, label, M));
      }
      else if (ortho == "IMGS") {
  typedef IMGSOrthoManager<Scalar, MV, OP> ortho_type;
  return rcp (new ortho_type (params, label, M));
      } 
      else if (ortho == "Simple") {
  TEUCHOS_TEST_FOR_EXCEPTION(ortho == "Simple", std::logic_error,
           "SimpleOrthoManager does not yet support "
           "the MatOrthoManager interface");
      } 
      TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, 
         "Invalid orthogonalization manager name: Valid names"
         " are " << validNamesString() << ".  For many of "
         "the test executables, the orthogonalization manager"
         " name often corresponds to the \"ortho\" command-"
         "line argument.");
      return Teuchos::null; // Guard to avoid compiler warnings.
    }

    Teuchos::RCP<Belos::OrthoManager<Scalar, MV> >
    makeOrthoManager (const std::string& ortho, 
          const Teuchos::RCP<const OP>& M,
          const Teuchos::RCP<OutputManager<Scalar> >& outMan,
          const std::string& label,
          const Teuchos::RCP<Teuchos::ParameterList>& params)
    {
#ifdef HAVE_BELOS_TSQR
      using Belos::TsqrOrthoManager;
#endif // HAVE_BELOS_TSQR
      using Teuchos::rcp;

      if (ortho == "Simple") {
  TEUCHOS_TEST_FOR_EXCEPTION(! M.is_null(), std::logic_error,
           "SimpleOrthoManager is not yet supported "
           "when the operator M is nontrivial (i.e., "
           "M != null).");
  return rcp (new SimpleOrthoManager<Scalar, MV> (outMan, label, params));
      }
#ifdef HAVE_BELOS_TSQR
      // TsqrMatOrthoManager has to store more things and do more work
      // than TsqrOrthoManager, in order for the former to be correct
      // for the case of a nondefault (non-Euclidean) inner product.
      // Thus, it's better to create a TsqrOrthoManager, when we know
      // the operator is the default operator (M is null).  Of course,
      // a MatOrthoManager is-an OrthoManager, so returning a
      // TsqrMatOrthoManager would still be correct; this is just an
      // optimization.
      else if (ortho == "TSQR" && M.is_null()) {
  return rcp (new TsqrOrthoManager<Scalar, MV> (params, label));
      }
#endif // HAVE_BELOS_TSQR
      else {
  // A MatOrthoManager is-an OrthoManager.
  return makeMatOrthoManager (ortho, M, outMan, label, params);
      }
    }
  };

} // namespace Belos

#endif // __Belos_OrthoManagerFactory_hpp