42 #ifndef BELOS_FIXEDPOINT_SOLMGR_HPP 43 #define BELOS_FIXEDPOINT_SOLMGR_HPP 62 #ifdef BELOS_TEUCHOS_TIME_MONITOR 63 # include "Teuchos_TimeMonitor.hpp" 90 template<
class ScalarType,
class MV,
class OP>
96 typedef Teuchos::ScalarTraits<ScalarType>
SCT;
97 typedef typename Teuchos::ScalarTraits<ScalarType>::magnitudeType
MagnitudeType;
98 typedef Teuchos::ScalarTraits<MagnitudeType>
MT;
130 const Teuchos::RCP<Teuchos::ParameterList> &pl );
136 Teuchos::RCP<SolverManager<ScalarType, MV, OP> >
clone ()
const override {
161 Teuchos::Array<Teuchos::RCP<Teuchos::Time> >
getTimers()
const {
191 void setParameters(
const Teuchos::RCP<Teuchos::ParameterList> ¶ms )
override;
205 std::string solverDesc =
" Fixed Point ";
253 Teuchos::RCP<LinearProblem<ScalarType,MV,OP> >
problem_;
264 Teuchos::RCP<StatusTest<ScalarType,MV,OP> >
sTest_;
270 Teuchos::RCP<StatusTestResNorm<ScalarType,MV,OP> >
convTest_;
289 #if defined(_WIN32) && defined(__clang__) 291 __builtin_constant_p(reinterpret_cast<const std::ostream*>(&std::cout));
331 template<
class ScalarType,
class MV,
class OP>
333 outputStream_(
Teuchos::rcp(outputStream_default_,false)),
336 maxIters_(maxIters_default_),
338 blockSize_(blockSize_default_),
339 verbosity_(verbosity_default_),
340 outputStyle_(outputStyle_default_),
341 outputFreq_(outputFreq_default_),
342 showMaxResNormOnly_(showMaxResNormOnly_default_),
343 label_(label_default_),
349 template<
class ScalarType,
class MV,
class OP>
352 const Teuchos::RCP<Teuchos::ParameterList> &pl) :
354 outputStream_(
Teuchos::rcp(outputStream_default_,false)),
357 maxIters_(maxIters_default_),
359 blockSize_(blockSize_default_),
360 verbosity_(verbosity_default_),
361 outputStyle_(outputStyle_default_),
362 outputFreq_(outputFreq_default_),
363 showMaxResNormOnly_(showMaxResNormOnly_default_),
364 label_(label_default_),
367 TEUCHOS_TEST_FOR_EXCEPTION(
problem_.is_null(), std::invalid_argument,
368 "FixedPointSolMgr's constructor requires a nonnull LinearProblem instance.");
373 if (! pl.is_null()) {
378 template<
class ScalarType,
class MV,
class OP>
384 if (params_ == Teuchos::null) {
385 params_ = Teuchos::rcp(
new Teuchos::ParameterList(*getValidParameters()) );
388 params->validateParameters(*getValidParameters());
392 if (params->isParameter(
"Maximum Iterations")) {
393 maxIters_ = params->get(
"Maximum Iterations",maxIters_default_);
396 params_->set(
"Maximum Iterations", maxIters_);
397 if (maxIterTest_!=Teuchos::null)
398 maxIterTest_->setMaxIters( maxIters_ );
402 if (params->isParameter(
"Block Size")) {
403 blockSize_ = params->get(
"Block Size",blockSize_default_);
404 TEUCHOS_TEST_FOR_EXCEPTION(blockSize_ <= 0, std::invalid_argument,
405 "Belos::FixedPointSolMgr: \"Block Size\" must be strictly positive.");
408 params_->set(
"Block Size", blockSize_);
412 if (params->isParameter(
"Timer Label")) {
413 std::string tempLabel = params->get(
"Timer Label", label_default_);
416 if (tempLabel != label_) {
418 params_->set(
"Timer Label", label_);
419 std::string solveLabel = label_ +
": FixedPointSolMgr total solve time";
420 #ifdef BELOS_TEUCHOS_TIME_MONITOR 421 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
427 if (params->isParameter(
"Verbosity")) {
428 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
429 verbosity_ = params->get(
"Verbosity", verbosity_default_);
431 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
435 params_->set(
"Verbosity", verbosity_);
436 if (printer_ != Teuchos::null)
437 printer_->setVerbosity(verbosity_);
441 if (params->isParameter(
"Output Style")) {
442 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
443 outputStyle_ = params->get(
"Output Style", outputStyle_default_);
445 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
449 params_->set(
"Output Style", outputStyle_);
450 outputTest_ = Teuchos::null;
454 if (params->isParameter(
"Output Stream")) {
455 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
458 params_->set(
"Output Stream", outputStream_);
459 if (printer_ != Teuchos::null)
460 printer_->setOStream( outputStream_ );
465 if (params->isParameter(
"Output Frequency")) {
466 outputFreq_ = params->get(
"Output Frequency", outputFreq_default_);
470 params_->set(
"Output Frequency", outputFreq_);
471 if (outputTest_ != Teuchos::null)
472 outputTest_->setOutputFrequency( outputFreq_ );
476 if (printer_ == Teuchos::null) {
485 if (params->isParameter(
"Convergence Tolerance")) {
486 if (params->isType<
MagnitudeType> (
"Convergence Tolerance")) {
487 convtol_ = params->get (
"Convergence Tolerance",
495 params_->set(
"Convergence Tolerance", convtol_);
496 if (convTest_ != Teuchos::null)
500 if (params->isParameter(
"Show Maximum Residual Norm Only")) {
501 showMaxResNormOnly_ = Teuchos::getParameter<bool>(*params,
"Show Maximum Residual Norm Only");
504 params_->set(
"Show Maximum Residual Norm Only", showMaxResNormOnly_);
505 if (convTest_ != Teuchos::null)
506 convTest_->setShowMaxResNormOnly( showMaxResNormOnly_ );
512 if (maxIterTest_ == Teuchos::null)
516 if (convTest_ == Teuchos::null)
517 convTest_ = Teuchos::rcp(
new StatusTestResNorm_t( convtol_, 1 ) );
519 if (sTest_ == Teuchos::null)
520 sTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
522 if (outputTest_ == Teuchos::null) {
530 std::string solverDesc =
" Fixed Point ";
531 outputTest_->setSolverDesc( solverDesc );
536 if (timerSolve_ == Teuchos::null) {
537 std::string solveLabel = label_ +
": FixedPointSolMgr total solve time";
538 #ifdef BELOS_TEUCHOS_TIME_MONITOR 539 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
548 template<
class ScalarType,
class MV,
class OP>
549 Teuchos::RCP<const Teuchos::ParameterList>
552 static Teuchos::RCP<const Teuchos::ParameterList> validPL;
555 if(is_null(validPL)) {
556 Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
561 "The relative residual tolerance that needs to be achieved by the\n" 562 "iterative solver in order for the linear system to be declared converged.");
563 pl->set(
"Maximum Iterations", static_cast<int>(maxIters_default_),
564 "The maximum number of block iterations allowed for each\n" 565 "set of RHS solved.");
566 pl->set(
"Block Size", static_cast<int>(blockSize_default_),
567 "The number of vectors in each block.");
568 pl->set(
"Verbosity", static_cast<int>(verbosity_default_),
569 "What type(s) of solver information should be outputted\n" 570 "to the output stream.");
571 pl->set(
"Output Style", static_cast<int>(outputStyle_default_),
572 "What style is used for the solver information outputted\n" 573 "to the output stream.");
574 pl->set(
"Output Frequency", static_cast<int>(outputFreq_default_),
575 "How often convergence information should be outputted\n" 576 "to the output stream.");
577 pl->set(
"Output Stream", Teuchos::rcp(outputStream_default_,
false),
578 "A reference-counted pointer to the output stream where all\n" 579 "solver output is sent.");
580 pl->set(
"Show Maximum Residual Norm Only", static_cast<bool>(showMaxResNormOnly_default_),
581 "When convergence information is printed, only show the maximum\n" 582 "relative residual norm when the block size is greater than one.");
583 pl->set(
"Timer Label", static_cast<const char *>(label_default_),
584 "The string to use as a prefix for the timer labels.");
592 template<
class ScalarType,
class MV,
class OP>
596 using Teuchos::rcp_const_cast;
597 using Teuchos::rcp_dynamic_cast;
604 setParameters(Teuchos::parameterList(*getValidParameters()));
607 TEUCHOS_TEST_FOR_EXCEPTION( !problem_->isProblemSet(),
609 "Belos::FixedPointSolMgr::solve(): Linear problem is not ready, setProblem() " 610 "has not been called.");
614 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
615 int numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
617 std::vector<int> currIdx, currIdx2;
618 currIdx.resize( blockSize_ );
619 currIdx2.resize( blockSize_ );
620 for (
int i=0; i<numCurrRHS; ++i)
621 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
622 for (
int i=numCurrRHS; i<blockSize_; ++i)
623 { currIdx[i] = -1; currIdx2[i] = i; }
626 problem_->setLSIndex( currIdx );
630 Teuchos::ParameterList plist;
631 plist.set(
"Block Size",blockSize_);
634 outputTest_->reset();
638 bool isConverged =
true;
643 RCP<FixedPointIteration<ScalarType,MV,OP> > block_fp_iter;
648 #ifdef BELOS_TEUCHOS_TIME_MONITOR 649 Teuchos::TimeMonitor slvtimer(*timerSolve_);
652 while ( numRHS2Solve > 0 ) {
655 std::vector<int> convRHSIdx;
656 std::vector<int> currRHSIdx( currIdx );
657 currRHSIdx.resize(numCurrRHS);
660 block_fp_iter->resetNumIters();
663 outputTest_->resetNumCalls();
666 RCP<MV> R_0 = MVT::CloneViewNonConst( *(rcp_const_cast<MV>(problem_->getInitResVec())), currIdx );
671 block_fp_iter->initializeFixedPoint(newstate);
677 block_fp_iter->iterate();
681 if (convTest_->getStatus() ==
Passed) {
685 std::vector<int> convIdx = convTest_->convIndices();
690 if (convIdx.size() == currRHSIdx.size())
695 problem_->setCurrLS();
700 std::vector<int> unconvIdx(currRHSIdx.size());
701 for (
unsigned int i=0; i<currRHSIdx.size(); ++i) {
703 for (
unsigned int j=0; j<convIdx.size(); ++j) {
704 if (currRHSIdx[i] == convIdx[j]) {
710 currIdx2[have] = currIdx2[i];
711 currRHSIdx[have++] = currRHSIdx[i];
716 currRHSIdx.resize(have);
717 currIdx2.resize(have);
720 problem_->setLSIndex( currRHSIdx );
723 std::vector<MagnitudeType> norms;
724 R_0 = MVT::CloneCopy( *(block_fp_iter->getNativeResiduals(&norms)),currIdx2 );
725 for (
int i=0; i<have; ++i) { currIdx2[i] = i; }
728 block_fp_iter->setBlockSize( have );
733 block_fp_iter->initializeFixedPoint(defstate);
739 else if (maxIterTest_->getStatus() ==
Passed) {
748 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
749 "Belos::FixedPointSolMgr::solve(): Neither the convergence test nor " 750 "the maximum iteration count test passed. Please report this bug " 751 "to the Belos developers.");
754 catch (
const std::exception &e) {
755 std::ostream& err = printer_->stream (
Errors);
756 err <<
"Error! Caught std::exception in FixedPointIteration::iterate() at " 757 <<
"iteration " << block_fp_iter->getNumIters() << std::endl
758 << e.what() << std::endl;
765 problem_->setCurrLS();
768 startPtr += numCurrRHS;
769 numRHS2Solve -= numCurrRHS;
770 if ( numRHS2Solve > 0 ) {
771 numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
774 currIdx.resize( blockSize_ );
775 currIdx2.resize( blockSize_ );
776 for (
int i=0; i<numCurrRHS; ++i)
777 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
778 for (
int i=numCurrRHS; i<blockSize_; ++i)
779 { currIdx[i] = -1; currIdx2[i] = i; }
782 problem_->setLSIndex( currIdx );
785 block_fp_iter->setBlockSize( blockSize_ );
788 currIdx.resize( numRHS2Solve );
799 #ifdef BELOS_TEUCHOS_TIME_MONITOR 805 Teuchos::TimeMonitor::summarize( printer_->stream(
TimingDetails) );
810 numIters_ = maxIterTest_->getNumIters();
815 const std::vector<MagnitudeType>* pTestValues = convTest_->getTestValue();
817 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues == NULL, std::logic_error,
818 "Belos::FixedPointSolMgr::solve(): The convergence test's getTestValue() " 819 "method returned NULL. Please report this bug to the Belos developers.");
821 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues->size() < 1, std::logic_error,
822 "Belos::FixedPointSolMgr::solve(): The convergence test's getTestValue() " 823 "method returned a vector of length zero. Please report this bug to the " 824 "Belos developers.");
829 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
839 template<
class ScalarType,
class MV,
class OP>
842 std::ostringstream oss;
843 oss <<
"Belos::FixedPointSolMgr<...,"<<Teuchos::ScalarTraits<ScalarType>::name()<<
">";
Collection of types and exceptions used within the Belos solvers.
Belos's basic output manager for sending information of select verbosity levels to the appropriate ou...
The Belos::FixedPointSolMgr provides a powerful and fully-featured solver manager over the FixedPoint...
Class which manages the output and verbosity of the Belos solvers.
Teuchos::ScalarTraits< ScalarType >::magnitudeType MagnitudeType
Teuchos::RCP< Teuchos::ParameterList > params_
Current parameter list.
Belos concrete class for performing fixed point iteration iteration.
OperatorTraits< ScalarType, MV, OP > OPT
FixedPointSolMgr()
Empty constructor for FixedPointSolMgr. This constructor takes no arguments and sets the default valu...
static constexpr int outputStyle_default_
static constexpr int maxIters_default_
Belos concrete class for performing the conjugate-gradient (CG) iteration.
static constexpr std::ostream * outputStream_default_
Teuchos::ScalarTraits< MagnitudeType > MT
A factory class for generating StatusTestOutput objects.
static constexpr int outputFreq_default_
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const override
Get a parameter list containing the current parameters for this object.
An abstract class of StatusTest for stopping criteria using residual norms.
static constexpr int verbosity_default_
An implementation of StatusTestResNorm using a family of residual norms.
static constexpr bool showMaxResNormOnly_default_
static const double convTol
Default convergence tolerance.
Belos::StatusTest class for specifying a maximum number of iterations.
MultiVecTraits< ScalarType, MV > MVT
static constexpr int blockSize_default_
A factory class for generating StatusTestOutput objects.
Traits class which defines basic operations on multivectors.
Belos::StatusTest for logically combining several status tests.
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
void setParameters(const Teuchos::RCP< Teuchos::ParameterList > ¶ms) override
Set the parameters the solver manager should use to solve the linear problem.
Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const override
clone for Inverted Injection (DII)
Teuchos::RCP< std::ostream > outputStream_
Output stream to which the output manager prints.
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. ...
bool isLOADetected() const override
Return whether a loss of accuracy was detected by this solver during the most current solve...
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const override
Get a parameter list containing the valid parameters for this object.
virtual ~FixedPointSolMgr()
Destructor.
A linear system to solve, and its associated information.
Class which describes the linear problem to be solved by the iterative solver.
int numIters_
Number of iterations taken by the last solve() invocation.
std::string description() const override
Method to return description of the block CG solver manager.
ReturnType solve() override
This method performs possibly repeated calls to the underlying linear solver's iterate() routine unti...
bool isSet_
Whether or not the parameters have been set (via setParameters()).
int maxIters_
Maximum iteration count (read from parameter list).
Teuchos::RCP< StatusTestMaxIters< ScalarType, MV, OP > > maxIterTest_
Maximum iteration count stopping criterion.
ReturnType
Whether the Belos solve converged for all linear systems.
Teuchos::RCP< Teuchos::Time > timerSolve_
Solve timer.
void replaceUserConvStatusTest(const Teuchos::RCP< StatusTestResNorm< ScalarType, MV, OP > > &userConvStatusTest)
Set user-defined convergence status test.
The Belos::SolverManager is a templated virtual base class that defines the basic interface that any ...
Teuchos::RCP< OutputManager< ScalarType > > printer_
Output manager, that handles printing of different kinds of messages.
Teuchos::RCP< const MV > R
The current residual.
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.
FixedPointSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i...
int setTolerance(MagnitudeType tolerance)
Set the value of the tolerance.
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.
Structure to contain pointers to FixedPointIteration state variables.
FixedPointSolMgrLinearProblemFailure(const std::string &what_arg)
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
Teuchos::RCP< StatusTestOutput< ScalarType, MV, OP > > outputTest_
Output "status test" that controls all the other status tests.
void reset(const ResetType type) override
Performs a reset of the solver manager specified by the ResetType. This informs the solver manager th...
A class for extending the status testing capabilities of Belos via logical combinations.
int getNumIters() const override
Get the iteration count for the most recent call to solve().
Teuchos::RCP< StatusTestResNorm< ScalarType, MV, OP > > convTest_
Convergence stopping criterion.
Class which defines basic traits for the operator type.
MagnitudeType achievedTol_
Tolerance achieved by the last solve() invocation.
Parent class to all Belos exceptions.
Default parameters common to most Belos solvers.
Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > problem_
The linear problem to solve.
MagnitudeType achievedTol() const override
Tolerance achieved by the last solve() invocation.
Teuchos::ScalarTraits< ScalarType > SCT
Belos header file which uses auto-configuration information to include necessary C++ headers...
This class implements the preconditioned fixed point iteration.
std::string label_
Prefix label for all the timers.
const LinearProblem< ScalarType, MV, OP > & getProblem() const override
Return a reference to the linear problem being solved by this solver manager.
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > sTest_
Aggregate stopping criterion.
MagnitudeType convtol_
Convergence tolerance (read from parameter list).