42 #ifndef BELOS_TFQMR_SOLMGR_HPP 43 #define BELOS_TFQMR_SOLMGR_HPP 61 #ifdef BELOS_TEUCHOS_TIME_MONITOR 62 #include "Teuchos_TimeMonitor.hpp" 103 template<
class ScalarType,
class MV,
class OP>
109 typedef Teuchos::ScalarTraits<ScalarType> SCT;
110 typedef typename Teuchos::ScalarTraits<ScalarType>::magnitudeType MagnitudeType;
111 typedef Teuchos::ScalarTraits<MagnitudeType> MT;
142 const Teuchos::RCP<Teuchos::ParameterList> &pl );
168 Teuchos::Array<Teuchos::RCP<Teuchos::Time> >
getTimers()
const {
169 return Teuchos::tuple(timerSolve_);
204 void setParameters(
const Teuchos::RCP<Teuchos::ParameterList> ¶ms );
252 bool checkStatusTest();
255 Teuchos::RCP<LinearProblem<ScalarType,MV,OP> > problem_;
258 Teuchos::RCP<OutputManager<ScalarType> > printer_;
259 Teuchos::RCP<std::ostream> outputStream_;
262 Teuchos::RCP<StatusTest<ScalarType,MV,OP> > sTest_;
263 Teuchos::RCP<StatusTestMaxIters<ScalarType,MV,OP> > maxIterTest_;
264 Teuchos::RCP<StatusTest<ScalarType,MV,OP> > convTest_;
265 Teuchos::RCP<StatusTestGenResNorm<ScalarType,MV,OP> > expConvTest_, impConvTest_;
266 Teuchos::RCP<StatusTestOutput<ScalarType,MV,OP> > outputTest_;
269 Teuchos::RCP<Teuchos::ParameterList> params_;
272 static const MagnitudeType convtol_default_;
273 static const MagnitudeType impTolScale_default_;
274 static const int maxIters_default_;
275 static const bool expResTest_default_;
276 static const int verbosity_default_;
277 static const int outputStyle_default_;
278 static const int outputFreq_default_;
279 static const std::string impResScale_default_;
280 static const std::string expResScale_default_;
281 static const std::string label_default_;
282 static const Teuchos::RCP<std::ostream> outputStream_default_;
285 MagnitudeType convtol_, impTolScale_, achievedTol_;
286 int maxIters_, numIters_;
287 int verbosity_, outputStyle_, outputFreq_;
290 std::string impResScale_, expResScale_;
294 Teuchos::RCP<Teuchos::Time> timerSolve_;
297 bool isSet_, isSTSet_;
302 template<
class ScalarType,
class MV,
class OP>
303 const typename TFQMRSolMgr<ScalarType,MV,OP>::MagnitudeType TFQMRSolMgr<ScalarType,MV,OP>::convtol_default_ = 1e-8;
305 template<
class ScalarType,
class MV,
class OP>
306 const typename TFQMRSolMgr<ScalarType,MV,OP>::MagnitudeType TFQMRSolMgr<ScalarType,MV,OP>::impTolScale_default_ = 10.0;
308 template<
class ScalarType,
class MV,
class OP>
309 const int TFQMRSolMgr<ScalarType,MV,OP>::maxIters_default_ = 1000;
311 template<
class ScalarType,
class MV,
class OP>
312 const bool TFQMRSolMgr<ScalarType,MV,OP>::expResTest_default_ =
false;
314 template<
class ScalarType,
class MV,
class OP>
315 const int TFQMRSolMgr<ScalarType,MV,OP>::verbosity_default_ =
Belos::Errors;
317 template<
class ScalarType,
class MV,
class OP>
318 const int TFQMRSolMgr<ScalarType,MV,OP>::outputStyle_default_ =
Belos::General;
320 template<
class ScalarType,
class MV,
class OP>
321 const int TFQMRSolMgr<ScalarType,MV,OP>::outputFreq_default_ = -1;
323 template<
class ScalarType,
class MV,
class OP>
324 const std::string TFQMRSolMgr<ScalarType,MV,OP>::impResScale_default_ =
"Norm of Preconditioned Initial Residual";
326 template<
class ScalarType,
class MV,
class OP>
327 const std::string TFQMRSolMgr<ScalarType,MV,OP>::expResScale_default_ =
"Norm of Initial Residual";
329 template<
class ScalarType,
class MV,
class OP>
330 const std::string TFQMRSolMgr<ScalarType,MV,OP>::label_default_ =
"Belos";
332 template<
class ScalarType,
class MV,
class OP>
333 const Teuchos::RCP<std::ostream> TFQMRSolMgr<ScalarType,MV,OP>::outputStream_default_ = Teuchos::rcp(&std::cout,
false);
337 template<
class ScalarType,
class MV,
class OP>
339 outputStream_(outputStream_default_),
340 convtol_(convtol_default_),
341 impTolScale_(impTolScale_default_),
342 achievedTol_(Teuchos::ScalarTraits<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>::zero()),
343 maxIters_(maxIters_default_),
345 verbosity_(verbosity_default_),
346 outputStyle_(outputStyle_default_),
347 outputFreq_(outputFreq_default_),
349 expResTest_(expResTest_default_),
350 impResScale_(impResScale_default_),
351 expResScale_(expResScale_default_),
352 label_(label_default_),
359 template<
class ScalarType,
class MV,
class OP>
362 const Teuchos::RCP<Teuchos::ParameterList> &pl ) :
364 outputStream_(outputStream_default_),
365 convtol_(convtol_default_),
366 impTolScale_(impTolScale_default_),
367 achievedTol_(Teuchos::ScalarTraits<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>::zero()),
368 maxIters_(maxIters_default_),
370 verbosity_(verbosity_default_),
371 outputStyle_(outputStyle_default_),
372 outputFreq_(outputFreq_default_),
374 expResTest_(expResTest_default_),
375 impResScale_(impResScale_default_),
376 expResScale_(expResScale_default_),
377 label_(label_default_),
381 TEUCHOS_TEST_FOR_EXCEPTION(problem_ == Teuchos::null, std::invalid_argument,
"Problem not given to solver manager.");
384 if ( !is_null(pl) ) {
389 template<
class ScalarType,
class MV,
class OP>
393 if (params_ == Teuchos::null) {
394 params_ = Teuchos::rcp(
new Teuchos::ParameterList(*getValidParameters()) );
397 params->validateParameters(*getValidParameters());
401 if (params->isParameter(
"Maximum Iterations")) {
402 maxIters_ = params->get(
"Maximum Iterations",maxIters_default_);
405 params_->set(
"Maximum Iterations", maxIters_);
406 if (maxIterTest_!=Teuchos::null)
407 maxIterTest_->setMaxIters( maxIters_ );
411 if (params->isParameter(
"Block Size")) {
412 blockSize_ = params->get(
"Block Size",1);
413 TEUCHOS_TEST_FOR_EXCEPTION(blockSize_ != 1, std::invalid_argument,
414 "Belos::TFQMRSolMgr: \"Block Size\" must be 1.");
417 params_->set(
"Block Size", blockSize_);
421 if (params->isParameter(
"Timer Label")) {
422 std::string tempLabel = params->get(
"Timer Label", label_default_);
425 if (tempLabel != label_) {
427 params_->set(
"Timer Label", label_);
428 std::string solveLabel = label_ +
": TFQMRSolMgr total solve time";
429 #ifdef BELOS_TEUCHOS_TIME_MONITOR 430 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
436 if (params->isParameter(
"Verbosity")) {
437 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
438 verbosity_ = params->get(
"Verbosity", verbosity_default_);
440 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
444 params_->set(
"Verbosity", verbosity_);
445 if (printer_ != Teuchos::null)
446 printer_->setVerbosity(verbosity_);
450 if (params->isParameter(
"Output Style")) {
451 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
452 outputStyle_ = params->get(
"Output Style", outputStyle_default_);
454 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
458 params_->set(
"Output Style", outputStyle_);
463 if (params->isParameter(
"Output Stream")) {
464 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
467 params_->set(
"Output Stream", outputStream_);
468 if (printer_ != Teuchos::null)
469 printer_->setOStream( outputStream_ );
474 if (params->isParameter(
"Output Frequency")) {
475 outputFreq_ = params->get(
"Output Frequency", outputFreq_default_);
479 params_->set(
"Output Frequency", outputFreq_);
480 if (outputTest_ != Teuchos::null)
481 outputTest_->setOutputFrequency( outputFreq_ );
485 if (printer_ == Teuchos::null) {
490 if (params->isParameter(
"Convergence Tolerance")) {
491 convtol_ = params->get(
"Convergence Tolerance",convtol_default_);
494 params_->set(
"Convergence Tolerance", convtol_);
499 if (params->isParameter(
"Implicit Tolerance Scale Factor")) {
500 impTolScale_ = params->get(
"Implicit Tolerance Scale Factor",impTolScale_default_);
503 params_->set(
"Implicit Tolerance Scale Factor", impTolScale_);
508 if (params->isParameter(
"Implicit Residual Scaling")) {
509 std::string tempImpResScale = Teuchos::getParameter<std::string>( *params,
"Implicit Residual Scaling" );
512 if (impResScale_ != tempImpResScale) {
513 impResScale_ = tempImpResScale;
516 params_->set(
"Implicit Residual Scaling", impResScale_);
523 if (params->isParameter(
"Explicit Residual Scaling")) {
524 std::string tempExpResScale = Teuchos::getParameter<std::string>( *params,
"Explicit Residual Scaling" );
527 if (expResScale_ != tempExpResScale) {
528 expResScale_ = tempExpResScale;
531 params_->set(
"Explicit Residual Scaling", expResScale_);
538 if (params->isParameter(
"Explicit Residual Test")) {
539 expResTest_ = Teuchos::getParameter<bool>( *params,
"Explicit Residual Test" );
542 params_->set(
"Explicit Residual Test", expResTest_);
543 if (expConvTest_ == Teuchos::null) {
549 if (timerSolve_ == Teuchos::null) {
550 std::string solveLabel = label_ +
": TFQMRSolMgr total solve time";
551 #ifdef BELOS_TEUCHOS_TIME_MONITOR 552 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
562 template<
class ScalarType,
class MV,
class OP>
574 Teuchos::RCP<StatusTestGenResNorm_t> tmpImpConvTest =
575 Teuchos::rcp(
new StatusTestGenResNorm_t( impTolScale_*convtol_ ) );
577 impConvTest_ = tmpImpConvTest;
580 Teuchos::RCP<StatusTestGenResNorm_t> tmpExpConvTest =
581 Teuchos::rcp(
new StatusTestGenResNorm_t( convtol_ ) );
582 tmpExpConvTest->defineResForm( StatusTestGenResNorm_t::Explicit,
Belos::TwoNorm );
584 expConvTest_ = tmpExpConvTest;
587 convTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::SEQ, impConvTest_, expConvTest_ ) );
592 Teuchos::RCP<StatusTestGenResNorm_t> tmpImpConvTest =
593 Teuchos::rcp(
new StatusTestGenResNorm_t( convtol_ ) );
595 impConvTest_ = tmpImpConvTest;
598 expConvTest_ = impConvTest_;
599 convTest_ = impConvTest_;
601 sTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
605 StatusTestOutputFactory<ScalarType,MV,OP> stoFactory( outputStyle_ );
609 std::string solverDesc =
" TFQMR ";
610 outputTest_->setSolverDesc( solverDesc );
620 template<
class ScalarType,
class MV,
class OP>
621 Teuchos::RCP<const Teuchos::ParameterList>
624 static Teuchos::RCP<const Teuchos::ParameterList> validPL;
627 if(is_null(validPL)) {
628 Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
629 pl->set(
"Convergence Tolerance", convtol_default_,
630 "The relative residual tolerance that needs to be achieved by the\n" 631 "iterative solver in order for the linear system to be declared converged.");
632 pl->set(
"Implicit Tolerance Scale Factor", impTolScale_default_,
633 "The scale factor used by the implicit residual test when explicit residual\n" 634 "testing is used. May enable faster convergence when TFQMR bound is too loose.");
635 pl->set(
"Maximum Iterations", maxIters_default_,
636 "The maximum number of block iterations allowed for each\n" 637 "set of RHS solved.");
638 pl->set(
"Verbosity", verbosity_default_,
639 "What type(s) of solver information should be outputted\n" 640 "to the output stream.");
641 pl->set(
"Output Style", outputStyle_default_,
642 "What style is used for the solver information outputted\n" 643 "to the output stream.");
644 pl->set(
"Output Frequency", outputFreq_default_,
645 "How often convergence information should be outputted\n" 646 "to the output stream.");
647 pl->set(
"Output Stream", outputStream_default_,
648 "A reference-counted pointer to the output stream where all\n" 649 "solver output is sent.");
650 pl->set(
"Explicit Residual Test", expResTest_default_,
651 "Whether the explicitly computed residual should be used in the convergence test.");
652 pl->set(
"Implicit Residual Scaling", impResScale_default_,
653 "The type of scaling used in the implicit residual convergence test.");
654 pl->set(
"Explicit Residual Scaling", expResScale_default_,
655 "The type of scaling used in the explicit residual convergence test.");
656 pl->set(
"Timer Label", label_default_,
657 "The string to use as a prefix for the timer labels.");
666 template<
class ScalarType,
class MV,
class OP>
673 setParameters(Teuchos::parameterList(*getValidParameters()));
677 "Belos::TFQMRSolMgr::solve(): Linear problem is not a valid object.");
680 "Belos::TFQMRSolMgr::solve(): Linear problem is not ready, setProblem() has not been called.");
684 "Belos::TFQMRSolMgr::solve(): Linear problem and requested status tests are incompatible.");
689 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
690 int numCurrRHS = blockSize_;
692 std::vector<int> currIdx, currIdx2;
695 currIdx.resize( blockSize_ );
696 currIdx2.resize( blockSize_ );
697 for (
int i=0; i<numCurrRHS; ++i)
698 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
701 problem_->setLSIndex( currIdx );
705 Teuchos::ParameterList plist;
706 plist.set(
"Block Size",blockSize_);
709 outputTest_->reset();
712 bool isConverged =
true;
717 Teuchos::RCP<TFQMRIter<ScalarType,MV,OP> > tfqmr_iter =
722 #ifdef BELOS_TEUCHOS_TIME_MONITOR 723 Teuchos::TimeMonitor slvtimer(*timerSolve_);
726 while ( numRHS2Solve > 0 ) {
729 std::vector<int> convRHSIdx;
730 std::vector<int> currRHSIdx( currIdx );
731 currRHSIdx.resize(numCurrRHS);
734 tfqmr_iter->resetNumIters();
737 outputTest_->resetNumCalls();
740 Teuchos::RCP<MV> R_0 = MVT::CloneViewNonConst( *(Teuchos::rcp_const_cast<MV>(problem_->getInitPrecResVec())), currIdx );
745 tfqmr_iter->initializeTFQMR(newstate);
751 tfqmr_iter->iterate();
758 if ( convTest_->getStatus() ==
Passed ) {
767 else if ( maxIterTest_->getStatus() ==
Passed ) {
781 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
782 "Belos::TFQMRSolMgr::solve(): Invalid return from TFQMRIter::iterate().");
785 catch (
const std::exception &e) {
786 printer_->stream(
Errors) <<
"Error! Caught std::exception in TFQMRIter::iterate() at iteration " 787 << tfqmr_iter->getNumIters() << std::endl
788 << e.what() << std::endl;
794 problem_->updateSolution( tfqmr_iter->getCurrentUpdate(), true );
797 problem_->setCurrLS();
800 startPtr += numCurrRHS;
801 numRHS2Solve -= numCurrRHS;
802 if ( numRHS2Solve > 0 ) {
803 numCurrRHS = blockSize_;
805 currIdx.resize( blockSize_ );
806 currIdx2.resize( blockSize_ );
807 for (
int i=0; i<numCurrRHS; ++i)
808 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
810 problem_->setLSIndex( currIdx );
813 tfqmr_iter->setBlockSize( blockSize_ );
816 currIdx.resize( numRHS2Solve );
827 #ifdef BELOS_TEUCHOS_TIME_MONITOR 832 Teuchos::TimeMonitor::summarize( printer_->stream(
TimingDetails) );
836 numIters_ = maxIterTest_->getNumIters();
849 const std::vector<MagnitudeType>* pTestValues = NULL;
851 pTestValues = expConvTest_->getTestValue();
852 if (pTestValues == NULL || pTestValues->size() < 1) {
853 pTestValues = impConvTest_->getTestValue();
858 pTestValues = impConvTest_->getTestValue();
860 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues == NULL, std::logic_error,
861 "Belos::TFQMRSolMgr::solve(): The implicit convergence test's " 862 "getTestValue() method returned NULL. Please report this bug to the " 863 "Belos developers.");
864 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues->size() < 1, std::logic_error,
865 "Belos::TMQMRSolMgr::solve(): The implicit convergence test's " 866 "getTestValue() method returned a vector of length zero. Please report " 867 "this bug to the Belos developers.");
872 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
882 template<
class ScalarType,
class MV,
class OP>
885 std::ostringstream oss;
886 oss <<
"Belos::TFQMRSolMgr<...,"<<Teuchos::ScalarTraits<ScalarType>::name()<<
">";
ScaleType convertStringToScaleType(const std::string &scaleType)
Convert the given string to its ScaleType enum value.
Collection of types and exceptions used within the Belos solvers.
This class implements the preconditioned transpose-free QMR algorithm for solving non-Hermitian linea...
Belos's basic output manager for sending information of select verbosity levels to the appropriate ou...
void setParameters(const Teuchos::RCP< Teuchos::ParameterList > ¶ms)
Set the parameters the solver manager should use to solve the linear problem.
Class which manages the output and verbosity of the Belos solvers.
void reset(const ResetType type)
Performs a reset of the solver manager specified by the ResetType. This informs the solver manager th...
An implementation of StatusTestResNorm using a family of residual norms.
Belos concrete class for generating iterations with the preconditioned tranpose-free QMR (TFQMR) meth...
Teuchos::RCP< const MV > R
The current residual basis.
Belos::StatusTest class for specifying a maximum number of iterations.
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem)
Set the linear problem that needs to be solved.
A factory class for generating StatusTestOutput objects.
TFQMRSolMgrOrthoFailure(const std::string &what_arg)
std::string description() const
Method to return description of the TFQMR solver manager.
Traits class which defines basic operations on multivectors.
Belos::StatusTest for logically combining several status tests.
A Belos::StatusTest class for specifying a maximum number of iterations.
ResetType
How to reset the solver.
Pure virtual base class which describes the basic interface for a solver manager. ...
A linear system to solve, and its associated information.
Structure to contain pointers to TFQMRIter state variables.
Class which describes the linear problem to be solved by the iterative solver.
bool isLOADetected() const
Whether loss of accuracy was detected during the last solve() invocation.
TFQMRSolMgr()
Empty constructor for TFQMRSolMgr. This constructor takes no arguments and sets the default values fo...
virtual ~TFQMRSolMgr()
Destructor.
ReturnType
Whether the Belos solve converged for all linear systems.
The Belos::SolverManager is a templated virtual base class that defines the basic interface that any ...
The Belos::TFQMRSolMgr provides a powerful and fully-featured solver manager over the TFQMR linear so...
const LinearProblem< ScalarType, MV, OP > & getProblem() const
Return a reference to the linear problem being solved by this solver manager.
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const
Get a parameter list containing the current parameters for this object.
ReturnType solve()
This method performs possibly repeated calls to the underlying linear solver's iterate() routine unti...
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
int getNumIters() const
Get the iteration count for the most recent call to solve().
A class for extending the status testing capabilities of Belos via logical combinations.
TFQMRSolMgrLinearProblemFailure(const std::string &what_arg)
Class which defines basic traits for the operator type.
TFQMRSolMgrOrthoFailure is thrown when the orthogonalization manager is unable to generate orthonorma...
MagnitudeType achievedTol() const
Tolerance achieved by the last solve() invocation.
Parent class to all Belos exceptions.
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
TFQMRSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i.e.
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
Get a parameter list containing the valid parameters for this object.
Belos header file which uses auto-configuration information to include necessary C++ headers...