Belos  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
BelosGmresPolySolMgr.hpp
Go to the documentation of this file.
1 //@HEADER
2 // ************************************************************************
3 //
4 // Belos: Block Linear Solvers Package
5 // Copyright 2004 Sandia Corporation
6 //
7 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8 // the U.S. Government retains certain rights in this software.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38 //
39 // ************************************************************************
40 //@HEADER
41 //
42 
43 #ifndef BELOS_GMRES_POLY_SOLMGR_HPP
44 #define BELOS_GMRES_POLY_SOLMGR_HPP
45 
49 
50 #include "BelosConfigDefs.hpp"
51 #include "BelosTypes.hpp"
52 
53 #include "BelosLinearProblem.hpp"
54 #include "BelosSolverManager.hpp"
55 #include "BelosGmresPolyOp.hpp"
58 #include "Teuchos_as.hpp"
59 #ifdef BELOS_TEUCHOS_TIME_MONITOR
60 #include "Teuchos_TimeMonitor.hpp"
61 #endif
62 
63 
64 namespace Belos {
65 
67 
68 
76  GmresPolySolMgrLinearProblemFailure(const std::string& what_arg) : BelosError(what_arg)
77  {}};
78 
86  GmresPolySolMgrPolynomialFailure(const std::string& what_arg) : BelosError(what_arg)
87  {}};
88 
103 //
138 //
150 
151 template<class ScalarType, class MV, class OP>
152 class GmresPolySolMgr : public SolverManager<ScalarType,MV,OP> {
153 private:
154 
155  typedef typename Teuchos::ScalarTraits<ScalarType>::magnitudeType MagnitudeType;
156 
160 
161 public:
162 
164 
165 
171  GmresPolySolMgr();
172 
193 
195  virtual ~GmresPolySolMgr() {};
196 
200  }
202 
204 
205 
208  const LinearProblem<ScalarType,MV,OP>& getProblem() const override {
209  return *problem_;
210  }
211 
215 
219 
236  MagnitudeType achievedTol() const override {
237  return achievedTol_;
238  }
239 
246  return Teuchos::tuple(timerPoly_);
247  }
248 
250  int getNumIters() const override {
251  return numIters_;
252  }
253 
257  bool isLOADetected() const override { return loaDetected_; }
258 
260 
262 
263 
265  void setProblem( const Teuchos::RCP<LinearProblem<ScalarType,MV,OP> > &problem ) override { problem_ = problem; }
266 
268  void setParameters( const Teuchos::RCP<Teuchos::ParameterList> &params ) override;
269 
271 
273 
282  void reset( const ResetType type ) override {
283  if ((type & Belos::Problem) && ! problem_.is_null ()) {
284  problem_->setProblem ();
285  poly_Op_ = Teuchos::null;
286  poly_dim_ = 0; // Rebuild the GMRES polynomial
287  }
288  }
289 
291 
293 
311  ReturnType solve() override;
312 
314 
317 
319  std::string description() const override;
320 
322 
323 private:
324 
325  // Linear problem.
327 
328  // Output manager.
329  Teuchos::RCP<std::ostream> outputStream_;
330 
331  // Current parameter list.
334 
335  // Default solver values.
336  static constexpr int maxDegree_default_ = 25;
337  static constexpr int verbosity_default_ = Belos::Errors;
338  static constexpr const char * label_default_ = "Belos";
339  static constexpr const char * outerSolverType_default_ = "";
340  static constexpr const char * polyType_default_ = "Arnoldi";
341  static constexpr const char * orthoType_default_ = "ICGS";
342  static constexpr bool addRoots_default_ = true;
343  static constexpr bool dampPoly_default_ = false;
344  static constexpr bool randomRHS_default_ = true;
345 
346  // Current solver values.
347  MagnitudeType polyTol_, achievedTol_;
348  int maxDegree_, numIters_;
349  int verbosity_;
350  bool hasOuterSolver_;
351  bool randomRHS_;
352  bool damp_;
353  bool addRoots_;
354  std::string polyType_;
355  std::string outerSolverType_;
356  std::string orthoType_;
357 
358  // Polynomial storage
359  int poly_dim_;
361 
362  // Timers.
363  std::string label_;
364  Teuchos::RCP<Teuchos::Time> timerPoly_;
365 
366  // Internal state variables.
367  bool isSet_;
368  bool loaDetected_;
369 
372 };
373 
374 
375 template<class ScalarType, class MV, class OP>
377  outputStream_ (Teuchos::rcpFromRef(std::cout)),
378  polyTol_ (DefaultSolverParameters::polyTol),
379  achievedTol_(MTS::zero()),
380  maxDegree_ (maxDegree_default_),
381  numIters_ (0),
382  verbosity_ (verbosity_default_),
383  hasOuterSolver_ (false),
384  randomRHS_ (randomRHS_default_),
385  damp_ (dampPoly_default_),
386  addRoots_ (addRoots_default_),
387  polyType_ (polyType_default_),
388  outerSolverType_ (outerSolverType_default_),
389  orthoType_ (orthoType_default_),
390  poly_dim_ (0),
391  label_ (label_default_),
392  isSet_ (false),
393  loaDetected_ (false)
394 {}
395 
396 
397 template<class ScalarType, class MV, class OP>
401  problem_ (problem),
402  outputStream_ (Teuchos::rcpFromRef(std::cout)),
403  polyTol_ (DefaultSolverParameters::polyTol),
404  maxDegree_ (maxDegree_default_),
405  numIters_ (0),
406  verbosity_ (verbosity_default_),
407  hasOuterSolver_ (false),
408  randomRHS_ (randomRHS_default_),
409  damp_ (dampPoly_default_),
410  addRoots_ (addRoots_default_),
411  polyType_ (polyType_default_),
412  outerSolverType_ (outerSolverType_default_),
413  orthoType_ (orthoType_default_),
414  poly_dim_ (0),
415  label_ (label_default_),
416  isSet_ (false),
417  loaDetected_ (false)
418 {
420  problem_.is_null (), std::invalid_argument,
421  "Belos::GmresPolySolMgr: The given linear problem is null. "
422  "Please call this constructor with a nonnull LinearProblem argument, "
423  "or call the constructor that does not take a LinearProblem.");
424 
425  // If the input parameter list is null, then the parameters take
426  // default values.
427  if (! pl.is_null ()) {
428  setParameters (pl);
429  }
430 }
431 
432 
433 template<class ScalarType, class MV, class OP>
436 {
437  if (validPL_.is_null ()) {
438  Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList ();
439 
440  // The static_cast is to resolve an issue with older clang versions which
441  // would cause the constexpr to link fail. With c++17 the problem is resolved.
442  pl->set("Polynomial Type", static_cast<const char *>(polyType_default_),
443  "The type of GMRES polynomial that is used as a preconditioner: Roots, Arnoldi, or Gmres.");
444  pl->set("Polynomial Tolerance", static_cast<MagnitudeType>(DefaultSolverParameters::polyTol),
445  "The relative residual tolerance that used to construct the GMRES polynomial.");
446  pl->set("Maximum Degree", static_cast<int>(maxDegree_default_),
447  "The maximum degree allowed for any GMRES polynomial.");
448  pl->set("Outer Solver", static_cast<const char *>(outerSolverType_default_),
449  "The outer solver that this polynomial is used to precondition.");
450  pl->set("Outer Solver Params", Teuchos::ParameterList(),
451  "Parameter list for the outer solver.");
452  pl->set("Verbosity", static_cast<int>(verbosity_default_),
453  "What type(s) of solver information should be outputted\n"
454  "to the output stream.");
455  pl->set("Output Stream", Teuchos::rcpFromRef(std::cout),
456  "A reference-counted pointer to the output stream where all\n"
457  "solver output is sent.");
458  pl->set("Timer Label", static_cast<const char *>(label_default_),
459  "The string to use as a prefix for the timer labels.");
460  pl->set("Orthogonalization", static_cast<const char *>(orthoType_default_),
461  "The type of orthogonalization to use to generate polynomial: DGKS, ICGS, or IMGS.");
462  pl->set("Random RHS", static_cast<bool>(randomRHS_default_),
463  "Add roots to polynomial for stability.");
464  pl->set("Add Roots", static_cast<bool>(addRoots_default_),
465  "Add roots to polynomial for stability.");
466  pl->set("Damp Poly", static_cast<bool>(dampPoly_default_),
467  "Damp polynomial for ill-conditioned problems.");
468  validPL_ = pl;
469  }
470  return validPL_;
471 }
472 
473 
474 template<class ScalarType, class MV, class OP>
477 {
478  // Create the internal parameter list if ones doesn't already exist.
479  if (params_.is_null ()) {
480  params_ = Teuchos::parameterList (*getValidParameters ());
481  }
482  else {
483  params->validateParameters (*getValidParameters (),0);
484  }
485 
486  // Check which Gmres polynomial to use
487  if (params->isParameter("Polynomial Type")) {
488  polyType_ = params->get("Polynomial Type", polyType_default_);
489  }
490 
491  // Update the outer solver in our list.
492  params_->set("Polynomial Type", polyType_);
493 
494  // Check if there is an outer solver for this Gmres Polynomial
495  if (params->isParameter("Outer Solver")) {
496  outerSolverType_ = params->get("Outer Solver", outerSolverType_default_);
497  }
498 
499  // Update the outer solver in our list.
500  params_->set("Outer Solver", outerSolverType_);
501 
502  // Check if there is a parameter list for the outer solver
503  if (params->isSublist("Outer Solver Params")) {
504  outerParams_ = Teuchos::parameterList( params->get<Teuchos::ParameterList>("Outer Solver Params") );
505  }
506 
507  // Check for maximum polynomial degree
508  if (params->isParameter("Maximum Degree")) {
509  maxDegree_ = params->get("Maximum Degree",maxDegree_default_);
510  }
511 
512  // Update parameter in our list.
513  params_->set("Maximum Degree", maxDegree_);
514 
515  // Check to see if the timer label changed.
516  if (params->isParameter("Timer Label")) {
517  std::string tempLabel = params->get("Timer Label", label_default_);
518 
519  // Update parameter in our list and solver timer
520  if (tempLabel != label_) {
521  label_ = tempLabel;
522 #ifdef BELOS_TEUCHOS_TIME_MONITOR
523  std::string polyLabel = label_ + ": GmresPolyOp creation time";
524  timerPoly_ = Teuchos::TimeMonitor::getNewCounter(polyLabel);
525 #endif
526  }
527  }
528 
529  // Update timer label
530  params_->set("Timer Label", label_);
531 
532  // Check if the orthogonalization changed.
533  if (params->isParameter("Orthogonalization")) {
534  std::string tempOrthoType = params->get("Orthogonalization",orthoType_default_);
536  // Ensure that the specified orthogonalization type is valid.
537  if (! factory.isValidName (tempOrthoType)) {
538  std::ostringstream os;
539  os << "Belos::GCRODRSolMgr: Invalid orthogonalization name \""
540  << tempOrthoType << "\". The following are valid options "
541  << "for the \"Orthogonalization\" name parameter: ";
542  factory.printValidNames (os);
543  throw std::invalid_argument (os.str());
544  }
545  if (tempOrthoType != orthoType_) {
546  orthoType_ = tempOrthoType;
547  }
548  }
549 
550  params_->set("Orthogonalization", orthoType_);
551 
552  // Check for a change in verbosity level
553  if (params->isParameter("Verbosity")) {
554  if (Teuchos::isParameterType<int>(*params,"Verbosity")) {
555  verbosity_ = params->get("Verbosity", verbosity_default_);
556  } else {
557  verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,"Verbosity");
558  }
559  }
560 
561  // Update parameter in our list.
562  params_->set("Verbosity", verbosity_);
563 
564  // output stream
565  if (params->isParameter("Output Stream")) {
566  outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,"Output Stream");
567  }
568 
569  // Update parameter in our list.
570  params_->set("Output Stream", outputStream_);
571 
572  // Convergence
573  // Check for polynomial convergence tolerance
574  if (params->isParameter("Polynomial Tolerance")) {
575  if (params->isType<MagnitudeType> ("Polynomial Tolerance")) {
576  polyTol_ = params->get ("Polynomial Tolerance",
577  static_cast<MagnitudeType> (DefaultSolverParameters::polyTol));
578  }
579  else {
580  polyTol_ = params->get ("Polynomial Tolerance", DefaultSolverParameters::polyTol);
581  }
582  }
583 
584  // Update parameter in our list and residual tests.
585  params_->set("Polynomial Tolerance", polyTol_);
586 
587  // Check for maximum polynomial degree
588  if (params->isParameter("Random RHS")) {
589  randomRHS_ = params->get("Random RHS",randomRHS_default_);
590  }
591 
592  // Update parameter in our list.
593  params_->set("Random RHS", randomRHS_);
594 
595 
596  // Check for polynomial damping
597  if (params->isParameter("Damped Poly")) {
598  damp_ = params->get("Damped Poly",dampPoly_default_);
599  }
600  // Update parameter in our list.
601  params_->set("Damped Poly", damp_);
602 
603  // Check: Should we add roots for stability if needed?
604  if (params->isParameter("Add Roots")) {
605  addRoots_ = params->get("Add Roots",addRoots_default_);
606  }
607 
608  // Update parameter in our list.
609  params_->set("Add Roots", addRoots_);
610 
611  // Create the timers if we need to.
612 #ifdef BELOS_TEUCHOS_TIME_MONITOR
613  if (timerPoly_ == Teuchos::null) {
614  std::string polyLabel = label_ + ": GmresPolyOp creation time";
615  timerPoly_ = Teuchos::TimeMonitor::getNewCounter(polyLabel);
616  }
617 #endif
618 
619  // Check if we are going to perform an outer solve.
620  if (outerSolverType_ != "") {
621  hasOuterSolver_ = true;
622  }
623 
624  // Inform the solver manager that the current parameters were set.
625  isSet_ = true;
626 }
627 
628 
629 template<class ScalarType, class MV, class OP>
631 {
632  using Teuchos::RCP;
633  using Teuchos::rcp;
634  using Teuchos::rcp_const_cast;
635 
636  // Assume convergence is achieved if user does not require strict convergence.
638 
639  // Set the current parameters if they were not set before. NOTE:
640  // This may occur if the user generated the solver manager with the
641  // default constructor and then didn't set any parameters using
642  // setParameters().
643  if (! isSet_) {
644  setParameters (Teuchos::parameterList (*getValidParameters ()));
645  }
646 
648  problem_.is_null (), GmresPolySolMgrLinearProblemFailure,
649  "Belos::GmresPolySolMgr::solve: The linear problem has not been set yet, "
650  "or was set to null. Please call setProblem() with a nonnull input before "
651  "calling solve().");
652 
654  ! problem_->isProblemSet (), GmresPolySolMgrLinearProblemFailure,
655  "Belos::GmresPolySolMgr::solve: The linear problem is not ready. Please "
656  "call setProblem() on the LinearProblem object before calling solve().");
657 
658  // If the GMRES polynomial has not been constructed for this
659  // (nmatrix, preconditioner) pair, generate it.
660  if (!poly_dim_ && maxDegree_) {
661 #ifdef BELOS_TEUCHOS_TIME_MONITOR
662  Teuchos::TimeMonitor slvtimer(*timerPoly_);
663 #endif
664  poly_Op_ = Teuchos::rcp( new gmres_poly_t( problem_, params_ ) );
665  poly_dim_ = poly_Op_->polyDegree();
666 
668  "Belos::GmresPolyOp: Failed to generate polynomial that satisfied requirements.");
669  }
670 
671 
672  // Solve the linear system using the polynomial
673  if (hasOuterSolver_ && maxDegree_) {
674 
675  // Then the polynomial will be used as an operator for an outer solver.
676  // Use outer solver parameter list passed in a sublist.
678  RCP<SolverManager<ScalarType, MultiVec<ScalarType>, Operator<ScalarType> > > solver = factory.create( outerSolverType_, outerParams_ );
679  TEUCHOS_TEST_FOR_EXCEPTION( solver == Teuchos::null, std::invalid_argument,
680  "Belos::GmresPolySolMgr::solve(): Selected solver is not valid.");
681 
682  // Create a copy of the linear problem that uses the polynomial as a preconditioner.
683  // The original initial solution and right-hand side are thinly wrapped in the gmres_poly_mv_t
684  RCP<gmres_poly_mv_t> new_lhs = rcp( new gmres_poly_mv_t( problem_->getLHS() ) );
685  RCP<gmres_poly_mv_t> new_rhs = rcp( new gmres_poly_mv_t( rcp_const_cast<MV>( problem_->getRHS() ) ) );
686  RCP<gmres_poly_t> A = rcp( new gmres_poly_t( problem_ ) ); // This just performs problem_->applyOp
687  RCP<LinearProblem<ScalarType,MultiVec<ScalarType>,Operator<ScalarType> > > newProblem =
688  rcp( new LinearProblem<ScalarType,MultiVec<ScalarType>,Operator<ScalarType> >( A, new_lhs, new_rhs ) );
689  std::string solverLabel = label_ + ": Hybrid Gmres";
690  newProblem->setLabel(solverLabel);
691 
692  // If the preconditioner is left preconditioner, use Gmres poly as a left preconditioner.
693  if (problem_->getLeftPrec() != Teuchos::null)
694  newProblem->setLeftPrec( poly_Op_ );
695  else
696  newProblem->setRightPrec( poly_Op_ );
697  // Set the initial residual vector, if it has already been set in the original problem.
698  // Don't set the preconditioned residual vector, because it is not the GmresPoly preconditioned residual vector.
699  if (problem_->getInitResVec() != Teuchos::null)
700  newProblem->setInitResVec( rcp( new gmres_poly_mv_t( rcp_const_cast<MV>( problem_->getInitResVec() ) ) ) );
701  newProblem->setProblem();
702 
703  solver->setProblem( newProblem );
704 
705  ret = solver->solve();
706  numIters_ = solver->getNumIters();
707  loaDetected_ = solver->isLOADetected();
708  achievedTol_ = solver->achievedTol();
709 
710  } // if (hasOuterSolver_ && maxDegree_)
711  else if (hasOuterSolver_) {
712 
713  // There is no polynomial, just create the outer solver with the outerSolverType_ and outerParams_.
715  RCP<SolverManager<ScalarType, MV, OP> > solver = factory.create( outerSolverType_, outerParams_ );
716  TEUCHOS_TEST_FOR_EXCEPTION( solver == Teuchos::null, std::invalid_argument,
717  "Belos::GmresPolySolMgr::solve(): Selected solver is not valid.");
718 
719  solver->setProblem( problem_ );
720 
721  ret = solver->solve();
722  numIters_ = solver->getNumIters();
723  loaDetected_ = solver->isLOADetected();
724  achievedTol_ = solver->achievedTol();
725 
726  }
727  else if (maxDegree_) {
728 
729  // Apply the polynomial to the current linear system
730  poly_Op_->ApplyPoly( *problem_->getRHS(), *problem_->getLHS() );
731  achievedTol_ = MTS::one();
732 
733  }
734 
735  return ret;
736 }
737 
738 
739 template<class ScalarType, class MV, class OP>
741 {
742  std::ostringstream out;
743 
744  out << "\"Belos::GmresPolySolMgr\": {"
745  << "ScalarType: " << Teuchos::TypeNameTraits<ScalarType>::name ()
746  << ", Poly Degree: " << poly_dim_
747  << ", Poly Max Degree: " << maxDegree_
748  << ", Poly Tol: " << polyTol_;
749  out << "}";
750  return out.str ();
751 }
752 
753 } // namespace Belos
754 
755 #endif // BELOS_GMRES_POLY_SOLMGR_HPP
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const override
Get a parameter list containing the current parameters for this object.
Collection of types and exceptions used within the Belos solvers.
ReturnType solve() override
This method performs possibly repeated calls to the underlying linear solver&#39;s iterate() routine unti...
virtual ~GmresPolySolMgr()
Destructor.
Defines the GMRES polynomial operator hybrid-GMRES iterative linear solver.
bool isLOADetected() const override
Return whether a loss of accuracy was detected by this solver during the most current solve...
T & get(const std::string &name, T def_value)
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
static RCP< Time > getNewCounter(const std::string &name)
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
static const double polyTol
Relative residual tolerance for matrix polynomial construction.
Definition: BelosTypes.hpp:296
bool isParameter(const std::string &name) const
ResetType
How to reset the solver.
Definition: BelosTypes.hpp:206
Alternative run-time polymorphic interface for operators.
GmresPolySolMgrLinearProblemFailure is thrown when the linear problem is not setup (i...
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Pure virtual base class which describes the basic interface for a solver manager. ...
bool isValidName(const std::string &name) const
Whether this factory recognizes the MatOrthoManager with the given name.
bool isSublist(const std::string &name) const
std::ostream & printValidNames(std::ostream &out) const
Print all recognized MatOrthoManager names to the given ostream.
const LinearProblem< ScalarType, MV, OP > & getProblem() const override
Get current linear problem being solved for in this object.
A linear system to solve, and its associated information.
Class which describes the linear problem to be solved by the iterative solver.
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem) override
Set the linear problem that needs to be solved.
The GMRES polynomial can be created in conjunction with any standard preconditioner.
int getNumIters() const override
Get the iteration count for the most recent call to solve().
ReturnType
Whether the Belos solve converged for all linear systems.
Definition: BelosTypes.hpp:155
The Belos::SolverManager is a templated virtual base class that defines the basic interface that any ...
Belos&#39;s class for applying the GMRES polynomial operator that is used by the hybrid-GMRES linear solv...
void reset(const ResetType type) override
Reset the solver.
void validateParameters(ParameterList const &validParamList, int const depth=1000, EValidateUsed const validateUsed=VALIDATE_USED_ENABLED, EValidateDefaults const validateDefaults=VALIDATE_DEFAULTS_ENABLED) const
std::string description() const override
Method to return description of the hybrid block GMRES solver manager.
GmresPolySolMgrPolynomialFailure is thrown when their is a problem generating the GMRES polynomial fo...
virtual Teuchos::RCP< solver_base_type > create(const std::string &solverName, const Teuchos::RCP< Teuchos::ParameterList > &solverParams)
Create, configure, and return the specified solver.
GmresPolySolMgrPolynomialFailure(const std::string &what_arg)
void setParameters(const Teuchos::RCP< Teuchos::ParameterList > &params) override
Set the parameters the solver manager should use to solve the linear problem.
bool isType(const std::string &name) const
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const override
Get a parameter list containing the valid parameters for this object.
Interface for multivectors used by Belos&#39; linear solvers.
Parent class to all Belos exceptions.
Definition: BelosTypes.hpp:60
Default parameters common to most Belos solvers.
Definition: BelosTypes.hpp:283
GmresPolySolMgr()
Empty constructor for GmresPolySolMgr. This constructor takes no arguments and sets the default value...
MagnitudeType achievedTol() const override
Tolerance achieved by the last solve() invocation.
Belos header file which uses auto-configuration information to include necessary C++ headers...
Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const override
clone for Inverted Injection (DII)
typename::Belos::Impl::SolverFactorySelector< SC, MV, OP >::type SolverFactory
GmresPolySolMgrLinearProblemFailure(const std::string &what_arg)
static std::string name()
bool is_null() const

Generated on Thu Mar 28 2024 09:24:29 for Belos by doxygen 1.8.5