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 {
162 return Teuchos::tuple(timerSolve_);
191 void setParameters(
const Teuchos::RCP<Teuchos::ParameterList> ¶ms )
override;
197 convTest_ = userConvStatusTest;
200 sTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
205 std::string solverDesc =
" Fixed Point ";
206 outputTest_->setSolverDesc( solverDesc );
253 Teuchos::RCP<LinearProblem<ScalarType,MV,OP> > problem_;
256 Teuchos::RCP<OutputManager<ScalarType> > printer_;
258 Teuchos::RCP<std::ostream> outputStream_;
264 Teuchos::RCP<StatusTest<ScalarType,MV,OP> > sTest_;
267 Teuchos::RCP<StatusTestMaxIters<ScalarType,MV,OP> > maxIterTest_;
270 Teuchos::RCP<StatusTestResNorm<ScalarType,MV,OP> > convTest_;
273 Teuchos::RCP<StatusTestOutput<ScalarType,MV,OP> > outputTest_;
276 Teuchos::RCP<Teuchos::ParameterList> params_;
281 static constexpr
int maxIters_default_ = 1000;
282 static constexpr
bool showMaxResNormOnly_default_ =
false;
283 static constexpr
int blockSize_default_ = 1;
286 static constexpr
int outputFreq_default_ = -1;
287 static constexpr
const char * label_default_ =
"Belos";
289 #if defined(_WIN32) && defined(__clang__) 290 static constexpr std::ostream * outputStream_default_ =
291 __builtin_constant_p(reinterpret_cast<const std::ostream*>(&std::cout));
293 static constexpr std::ostream * outputStream_default_ = &std::cout;
301 MagnitudeType convtol_;
308 MagnitudeType achievedTol_;
316 int blockSize_, verbosity_, outputStyle_, outputFreq_;
317 bool showMaxResNormOnly_;
323 Teuchos::RCP<Teuchos::Time> timerSolve_;
331 template<
class ScalarType,
class MV,
class OP>
333 outputStream_(Teuchos::rcp(outputStream_default_,false)),
335 achievedTol_(Teuchos::ScalarTraits<MagnitudeType>::zero()),
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)),
356 achievedTol_(Teuchos::ScalarTraits<MagnitudeType>::zero()),
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.
Belos concrete class for performing fixed point iteration iteration.
FixedPointSolMgr()
Empty constructor for FixedPointSolMgr. This constructor takes no arguments and sets the default valu...
Belos concrete class for performing the conjugate-gradient (CG) iteration.
A factory class for generating StatusTestOutput objects.
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.
An implementation of StatusTestResNorm using a family of residual norms.
static const double convTol
Default convergence tolerance.
Belos::StatusTest class for specifying a maximum number of iterations.
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)
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.
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...
ReturnType
Whether the Belos solve converged for all linear systems.
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< const MV > R
The current residual.
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.
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().
Class which defines basic traits for the operator type.
Parent class to all Belos exceptions.
Default parameters common to most Belos solvers.
MagnitudeType achievedTol() const override
Tolerance achieved by the last solve() invocation.
Belos header file which uses auto-configuration information to include necessary C++ headers...
This class implements the preconditioned fixed point iteration.
const LinearProblem< ScalarType, MV, OP > & getProblem() const override
Return a reference to the linear problem being solved by this solver manager.