42#ifndef BELOS_TFQMR_SOLMGR_HPP
43#define BELOS_TFQMR_SOLMGR_HPP
61#ifdef BELOS_TEUCHOS_TIME_MONITOR
62#include "Teuchos_TimeMonitor.hpp"
93 template<
class ScalarType,
class MV,
class OP>
99 typedef Teuchos::ScalarTraits<ScalarType>
SCT;
100 typedef typename Teuchos::ScalarTraits<ScalarType>::magnitudeType
MagnitudeType;
101 typedef Teuchos::ScalarTraits<MagnitudeType>
MT;
132 const Teuchos::RCP<Teuchos::ParameterList> &pl );
138 Teuchos::RCP<SolverManager<ScalarType, MV, OP> >
clone ()
const override {
163 Teuchos::Array<Teuchos::RCP<Teuchos::Time> >
getTimers()
const {
198 void setParameters(
const Teuchos::RCP<Teuchos::ParameterList> ¶ms )
override;
247 Teuchos::RCP<LinearProblem<ScalarType,MV,OP> >
problem_;
254 Teuchos::RCP<StatusTest<ScalarType,MV,OP> >
sTest_;
291template<
class ScalarType,
class MV,
class OP>
293 outputStream_(Teuchos::rcpFromRef(std::cout)),
296 achievedTol_(Teuchos::ScalarTraits<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>::zero()),
297 maxIters_(maxIters_default_),
299 verbosity_(verbosity_default_),
300 outputStyle_(outputStyle_default_),
301 outputFreq_(outputFreq_default_),
303 expResTest_(expResTest_default_),
304 impResScale_(impResScale_default_),
305 expResScale_(expResScale_default_),
306 label_(label_default_),
313template<
class ScalarType,
class MV,
class OP>
316 const Teuchos::RCP<Teuchos::ParameterList> &pl ) :
318 outputStream_(Teuchos::rcpFromRef(std::cout)),
321 achievedTol_(Teuchos::ScalarTraits<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>::zero()),
322 maxIters_(maxIters_default_),
324 verbosity_(verbosity_default_),
325 outputStyle_(outputStyle_default_),
326 outputFreq_(outputFreq_default_),
328 expResTest_(expResTest_default_),
329 impResScale_(impResScale_default_),
330 expResScale_(expResScale_default_),
331 label_(label_default_),
335 TEUCHOS_TEST_FOR_EXCEPTION(
problem_ == Teuchos::null, std::invalid_argument,
"Problem not given to solver manager.");
338 if ( !is_null(pl) ) {
343template<
class ScalarType,
class MV,
class OP>
347 if (params_ == Teuchos::null) {
348 params_ = Teuchos::rcp(
new Teuchos::ParameterList(*getValidParameters()) );
351 params->validateParameters(*getValidParameters());
355 if (params->isParameter(
"Maximum Iterations")) {
356 maxIters_ = params->get(
"Maximum Iterations",maxIters_default_);
359 params_->set(
"Maximum Iterations", maxIters_);
360 if (maxIterTest_!=Teuchos::null)
361 maxIterTest_->setMaxIters( maxIters_ );
365 if (params->isParameter(
"Block Size")) {
366 blockSize_ = params->get(
"Block Size",1);
367 TEUCHOS_TEST_FOR_EXCEPTION(blockSize_ != 1, std::invalid_argument,
368 "Belos::TFQMRSolMgr: \"Block Size\" must be 1.");
371 params_->set(
"Block Size", blockSize_);
375 if (params->isParameter(
"Timer Label")) {
376 std::string tempLabel = params->get(
"Timer Label", label_default_);
379 if (tempLabel != label_) {
381 params_->set(
"Timer Label", label_);
382 std::string solveLabel = label_ +
": TFQMRSolMgr total solve time";
383#ifdef BELOS_TEUCHOS_TIME_MONITOR
384 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
390 if (params->isParameter(
"Verbosity")) {
391 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
392 verbosity_ = params->get(
"Verbosity", verbosity_default_);
394 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
398 params_->set(
"Verbosity", verbosity_);
399 if (printer_ != Teuchos::null)
400 printer_->setVerbosity(verbosity_);
404 if (params->isParameter(
"Output Style")) {
405 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
406 outputStyle_ = params->get(
"Output Style", outputStyle_default_);
408 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
412 params_->set(
"Output Style", outputStyle_);
417 if (params->isParameter(
"Output Stream")) {
418 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
421 params_->set(
"Output Stream", outputStream_);
422 if (printer_ != Teuchos::null)
423 printer_->setOStream( outputStream_ );
428 if (params->isParameter(
"Output Frequency")) {
429 outputFreq_ = params->get(
"Output Frequency", outputFreq_default_);
433 params_->set(
"Output Frequency", outputFreq_);
434 if (outputTest_ != Teuchos::null)
435 outputTest_->setOutputFrequency( outputFreq_ );
439 if (printer_ == Teuchos::null) {
444 if (params->isParameter(
"Convergence Tolerance")) {
445 if (params->isType<
MagnitudeType> (
"Convergence Tolerance")) {
446 convtol_ = params->get (
"Convergence Tolerance",
454 params_->set(
"Convergence Tolerance", convtol_);
459 if (params->isParameter(
"Implicit Tolerance Scale Factor")) {
460 if (params->isType<
MagnitudeType> (
"Implicit Tolerance Scale Factor")) {
461 impTolScale_ = params->get (
"Implicit Tolerance Scale Factor",
466 impTolScale_ = params->get (
"Implicit Tolerance Scale Factor",
471 params_->set(
"Implicit Tolerance Scale Factor", impTolScale_);
476 if (params->isParameter(
"Implicit Residual Scaling")) {
477 std::string tempImpResScale = Teuchos::getParameter<std::string>( *params,
"Implicit Residual Scaling" );
480 if (impResScale_ != tempImpResScale) {
481 impResScale_ = tempImpResScale;
484 params_->set(
"Implicit Residual Scaling", impResScale_);
491 if (params->isParameter(
"Explicit Residual Scaling")) {
492 std::string tempExpResScale = Teuchos::getParameter<std::string>( *params,
"Explicit Residual Scaling" );
495 if (expResScale_ != tempExpResScale) {
496 expResScale_ = tempExpResScale;
499 params_->set(
"Explicit Residual Scaling", expResScale_);
506 if (params->isParameter(
"Explicit Residual Test")) {
507 expResTest_ = Teuchos::getParameter<bool>( *params,
"Explicit Residual Test" );
510 params_->set(
"Explicit Residual Test", expResTest_);
511 if (expConvTest_ == Teuchos::null) {
517 if (timerSolve_ == Teuchos::null) {
518 std::string solveLabel = label_ +
": TFQMRSolMgr total solve time";
519#ifdef BELOS_TEUCHOS_TIME_MONITOR
520 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
530template<
class ScalarType,
class MV,
class OP>
542 Teuchos::RCP<StatusTestGenResNorm_t> tmpImpConvTest =
543 Teuchos::rcp(
new StatusTestGenResNorm_t( impTolScale_*convtol_ ) );
545 impConvTest_ = tmpImpConvTest;
548 Teuchos::RCP<StatusTestGenResNorm_t> tmpExpConvTest =
549 Teuchos::rcp(
new StatusTestGenResNorm_t( convtol_ ) );
550 tmpExpConvTest->defineResForm( StatusTestGenResNorm_t::Explicit,
Belos::TwoNorm );
552 expConvTest_ = tmpExpConvTest;
555 convTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::SEQ, impConvTest_, expConvTest_ ) );
560 Teuchos::RCP<StatusTestGenResNorm_t> tmpImpConvTest =
561 Teuchos::rcp(
new StatusTestGenResNorm_t( convtol_ ) );
563 impConvTest_ = tmpImpConvTest;
566 expConvTest_ = impConvTest_;
567 convTest_ = impConvTest_;
569 sTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
577 std::string solverDesc =
" TFQMR ";
578 outputTest_->setSolverDesc( solverDesc );
588template<
class ScalarType,
class MV,
class OP>
589Teuchos::RCP<const Teuchos::ParameterList>
592 static Teuchos::RCP<const Teuchos::ParameterList> validPL;
595 if(is_null(validPL)) {
596 Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
601 "The relative residual tolerance that needs to be achieved by the\n"
602 "iterative solver in order for the linear system to be declared converged.");
604 "The scale factor used by the implicit residual test when explicit residual\n"
605 "testing is used. May enable faster convergence when TFQMR bound is too loose.");
606 pl->set(
"Maximum Iterations",
static_cast<int>(maxIters_default_),
607 "The maximum number of block iterations allowed for each\n"
608 "set of RHS solved.");
609 pl->set(
"Verbosity",
static_cast<int>(verbosity_default_),
610 "What type(s) of solver information should be outputted\n"
611 "to the output stream.");
612 pl->set(
"Output Style",
static_cast<int>(outputStyle_default_),
613 "What style is used for the solver information outputted\n"
614 "to the output stream.");
615 pl->set(
"Output Frequency",
static_cast<int>(outputFreq_default_),
616 "How often convergence information should be outputted\n"
617 "to the output stream.");
618 pl->set(
"Output Stream", Teuchos::rcpFromRef(std::cout),
619 "A reference-counted pointer to the output stream where all\n"
620 "solver output is sent.");
621 pl->set(
"Explicit Residual Test",
static_cast<bool>(expResTest_default_),
622 "Whether the explicitly computed residual should be used in the convergence test.");
623 pl->set(
"Implicit Residual Scaling",
static_cast<const char *
>(impResScale_default_),
624 "The type of scaling used in the implicit residual convergence test.");
625 pl->set(
"Explicit Residual Scaling",
static_cast<const char *
>(expResScale_default_),
626 "The type of scaling used in the explicit residual convergence test.");
627 pl->set(
"Timer Label",
static_cast<const char *
>(label_default_),
628 "The string to use as a prefix for the timer labels.");
636template<
class ScalarType,
class MV,
class OP>
643 setParameters(Teuchos::parameterList(*getValidParameters()));
647 "Belos::TFQMRSolMgr::solve(): Linear problem is not a valid object.");
650 "Belos::TFQMRSolMgr::solve(): Linear problem is not ready, setProblem() has not been called.");
654 "Belos::TFQMRSolMgr::solve(): Linear problem and requested status tests are incompatible.");
659 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
660 int numCurrRHS = blockSize_;
662 std::vector<int> currIdx, currIdx2;
665 currIdx.resize( blockSize_ );
666 currIdx2.resize( blockSize_ );
667 for (
int i=0; i<numCurrRHS; ++i)
668 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
671 problem_->setLSIndex( currIdx );
675 Teuchos::ParameterList plist;
676 plist.set(
"Block Size",blockSize_);
679 outputTest_->reset();
682 bool isConverged =
true;
687 Teuchos::RCP<TFQMRIter<ScalarType,MV,OP> > tfqmr_iter =
692#ifdef BELOS_TEUCHOS_TIME_MONITOR
693 Teuchos::TimeMonitor slvtimer(*timerSolve_);
696 while ( numRHS2Solve > 0 ) {
699 std::vector<int> convRHSIdx;
700 std::vector<int> currRHSIdx( currIdx );
701 currRHSIdx.resize(numCurrRHS);
704 tfqmr_iter->resetNumIters();
707 outputTest_->resetNumCalls();
710 Teuchos::RCP<MV> R_0 = MVT::CloneViewNonConst( *(Teuchos::rcp_const_cast<MV>(problem_->getInitPrecResVec())), currIdx );
715 tfqmr_iter->initializeTFQMR(newstate);
721 tfqmr_iter->iterate();
728 if ( convTest_->getStatus() ==
Passed ) {
737 else if ( maxIterTest_->getStatus() ==
Passed ) {
751 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
752 "Belos::TFQMRSolMgr::solve(): Invalid return from TFQMRIter::iterate().");
755 catch (
const std::exception &e) {
756 printer_->stream(
Errors) <<
"Error! Caught std::exception in TFQMRIter::iterate() at iteration "
757 << tfqmr_iter->getNumIters() << std::endl
758 << e.what() << std::endl;
764 problem_->updateSolution( tfqmr_iter->getCurrentUpdate(),
true );
767 problem_->setCurrLS();
770 startPtr += numCurrRHS;
771 numRHS2Solve -= numCurrRHS;
772 if ( numRHS2Solve > 0 ) {
773 numCurrRHS = blockSize_;
775 currIdx.resize( blockSize_ );
776 currIdx2.resize( blockSize_ );
777 for (
int i=0; i<numCurrRHS; ++i)
778 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
780 problem_->setLSIndex( currIdx );
783 tfqmr_iter->setBlockSize( blockSize_ );
786 currIdx.resize( numRHS2Solve );
797#ifdef BELOS_TEUCHOS_TIME_MONITOR
802 Teuchos::TimeMonitor::summarize( printer_->stream(
TimingDetails) );
806 numIters_ = maxIterTest_->getNumIters();
819 const std::vector<MagnitudeType>* pTestValues = NULL;
821 pTestValues = expConvTest_->getTestValue();
822 if (pTestValues == NULL || pTestValues->size() < 1) {
823 pTestValues = impConvTest_->getTestValue();
828 pTestValues = impConvTest_->getTestValue();
830 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues == NULL, std::logic_error,
831 "Belos::TFQMRSolMgr::solve(): The implicit convergence test's "
832 "getTestValue() method returned NULL. Please report this bug to the "
833 "Belos developers.");
834 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues->size() < 1, std::logic_error,
835 "Belos::TMQMRSolMgr::solve(): The implicit convergence test's "
836 "getTestValue() method returned a vector of length zero. Please report "
837 "this bug to the Belos developers.");
842 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
852template<
class ScalarType,
class MV,
class OP>
855 std::ostringstream oss;
856 oss <<
"Belos::TFQMRSolMgr<...,"<<Teuchos::ScalarTraits<ScalarType>::name()<<
">";
Belos header file which uses auto-configuration information to include necessary C++ headers.
Class which describes the linear problem to be solved by the iterative solver.
Class which manages the output and verbosity of the Belos solvers.
Pure virtual base class which describes the basic interface for a solver manager.
Belos::StatusTest for logically combining several status tests.
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
Belos::StatusTest class for specifying a maximum number of iterations.
A factory class for generating StatusTestOutput objects.
Belos concrete class for generating iterations with the preconditioned tranpose-free QMR (TFQMR) meth...
Collection of types and exceptions used within the Belos solvers.
Parent class to all Belos exceptions.
A linear system to solve, and its associated information.
Traits class which defines basic operations on multivectors.
Class which defines basic traits for the operator type.
Belos's basic output manager for sending information of select verbosity levels to the appropriate ou...
The Belos::SolverManager is a templated virtual base class that defines the basic interface that any ...
A class for extending the status testing capabilities of Belos via logical combinations.
An implementation of StatusTestResNorm using a family of residual norms.
A Belos::StatusTest class for specifying a maximum number of iterations.
A factory class for generating StatusTestOutput objects.
Teuchos::RCP< StatusTestOutput< ScalarType, MV, OP > > create(const Teuchos::RCP< OutputManager< ScalarType > > &printer, Teuchos::RCP< StatusTest< ScalarType, MV, OP > > test, int mod, int printStates)
Create the StatusTestOutput object specified by the outputStyle.
This class implements the preconditioned transpose-free QMR algorithm for solving non-Hermitian linea...
TFQMRSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i....
TFQMRSolMgrLinearProblemFailure(const std::string &what_arg)
The Belos::TFQMRSolMgr provides a powerful and fully-featured solver manager over the TFQMR linear so...
void reset(const ResetType type) override
Performs a reset of the solver manager specified by the ResetType. This informs the solver manager th...
Teuchos::ScalarTraits< MagnitudeType > MT
virtual ~TFQMRSolMgr()
Destructor.
static constexpr const char * impResScale_default_
Teuchos::RCP< Teuchos::Time > timerSolve_
Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > problem_
static constexpr int outputFreq_default_
MagnitudeType impTolScale_
Teuchos::ScalarTraits< ScalarType >::magnitudeType MagnitudeType
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > convTest_
static constexpr int outputStyle_default_
Teuchos::RCP< Teuchos::ParameterList > params_
MagnitudeType achievedTol_
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const override
Get a parameter list containing the current parameters for this object.
Teuchos::ScalarTraits< ScalarType > SCT
Teuchos::RCP< std::ostream > outputStream_
OperatorTraits< ScalarType, MV, OP > OPT
Teuchos::RCP< StatusTestMaxIters< ScalarType, MV, OP > > maxIterTest_
static constexpr const char * label_default_
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem) override
Set the linear problem that needs to be solved.
int getNumIters() const override
Get the iteration count for the most recent call to solve().
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > sTest_
Teuchos::RCP< StatusTestOutput< ScalarType, MV, OP > > outputTest_
static constexpr const char * expResScale_default_
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const override
Get a parameter list containing the valid parameters for this object.
static constexpr int verbosity_default_
Teuchos::RCP< OutputManager< ScalarType > > printer_
MagnitudeType achievedTol() const override
Tolerance achieved by the last solve() invocation.
Teuchos::RCP< StatusTestGenResNorm< ScalarType, MV, OP > > impConvTest_
static constexpr int maxIters_default_
std::string description() const override
Method to return description of the TFQMR solver manager.
const LinearProblem< ScalarType, MV, OP > & getProblem() const override
Return a reference to the linear problem being solved by this solver manager.
static constexpr bool expResTest_default_
ReturnType solve() override
This method performs possibly repeated calls to the underlying linear solver's iterate() routine unti...
TFQMRSolMgr()
Empty constructor for TFQMRSolMgr. This constructor takes no arguments and sets the default values fo...
bool isLOADetected() const override
Whether loss of accuracy was detected during the last solve() invocation.
MultiVecTraits< ScalarType, MV > MVT
Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const override
clone for Inverted Injection (DII)
Teuchos::RCP< StatusTestGenResNorm< ScalarType, MV, OP > > expConvTest_
void setParameters(const Teuchos::RCP< Teuchos::ParameterList > ¶ms) override
Set the parameters the solver manager should use to solve the linear problem.
ScaleType convertStringToScaleType(const std::string &scaleType)
Convert the given string to its ScaleType enum value.
ReturnType
Whether the Belos solve converged for all linear systems.
ResetType
How to reset the solver.
Default parameters common to most Belos solvers.
static const double impTolScale
"Implicit Tolerance Scale Factor"
static const double convTol
Default convergence tolerance.
Structure to contain pointers to TFQMRIter state variables.
Teuchos::RCP< const MV > R
The current residual basis.