42 #ifndef BELOS_FIXEDPOINT_SOLMGR_HPP
43 #define BELOS_FIXEDPOINT_SOLMGR_HPP
62 #ifdef BELOS_TEUCHOS_TIME_MONITOR
90 template<
class ScalarType,
class MV,
class OP>
205 std::string solverDesc =
" Fixed Point ";
324 template<
class ScalarType,
class MV,
class OP>
326 outputStream_(Teuchos::rcpFromRef(std::cout)),
329 maxIters_(maxIters_default_),
331 blockSize_(blockSize_default_),
332 verbosity_(verbosity_default_),
333 outputStyle_(outputStyle_default_),
334 outputFreq_(outputFreq_default_),
335 showMaxResNormOnly_(showMaxResNormOnly_default_),
336 label_(label_default_),
342 template<
class ScalarType,
class MV,
class OP>
347 outputStream_(Teuchos::rcpFromRef(std::cout)),
350 maxIters_(maxIters_default_),
352 blockSize_(blockSize_default_),
353 verbosity_(verbosity_default_),
354 outputStyle_(outputStyle_default_),
355 outputFreq_(outputFreq_default_),
356 showMaxResNormOnly_(showMaxResNormOnly_default_),
357 label_(label_default_),
361 "FixedPointSolMgr's constructor requires a nonnull LinearProblem instance.");
371 template<
class ScalarType,
class MV,
class OP>
386 maxIters_ = params->
get(
"Maximum Iterations",maxIters_default_);
389 params_->set(
"Maximum Iterations", maxIters_);
391 maxIterTest_->setMaxIters( maxIters_ );
396 blockSize_ = params->
get(
"Block Size",blockSize_default_);
398 "Belos::FixedPointSolMgr: \"Block Size\" must be strictly positive.");
401 params_->set(
"Block Size", blockSize_);
406 std::string tempLabel = params->
get(
"Timer Label", label_default_);
409 if (tempLabel != label_) {
411 params_->set(
"Timer Label", label_);
412 std::string solveLabel = label_ +
": FixedPointSolMgr total solve time";
413 #ifdef BELOS_TEUCHOS_TIME_MONITOR
421 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
422 verbosity_ = params->
get(
"Verbosity", verbosity_default_);
424 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
428 params_->set(
"Verbosity", verbosity_);
430 printer_->setVerbosity(verbosity_);
435 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
436 outputStyle_ = params->
get(
"Output Style", outputStyle_default_);
438 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
442 params_->set(
"Output Style", outputStyle_);
448 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
451 params_->set(
"Output Stream", outputStream_);
453 printer_->setOStream( outputStream_ );
459 outputFreq_ = params->
get(
"Output Frequency", outputFreq_default_);
463 params_->set(
"Output Frequency", outputFreq_);
465 outputTest_->setOutputFrequency( outputFreq_ );
478 if (params->
isParameter(
"Convergence Tolerance")) {
480 convtol_ = params->
get (
"Convergence Tolerance",
488 params_->set(
"Convergence Tolerance", convtol_);
490 convTest_->setTolerance( convtol_ );
493 if (params->
isParameter(
"Show Maximum Residual Norm Only")) {
494 showMaxResNormOnly_ = Teuchos::getParameter<bool>(*params,
"Show Maximum Residual Norm Only");
497 params_->set(
"Show Maximum Residual Norm Only", showMaxResNormOnly_);
499 convTest_->setShowMaxResNormOnly( showMaxResNormOnly_ );
510 convTest_ =
Teuchos::rcp(
new StatusTestResNorm_t( convtol_, 1 ) );
513 sTest_ =
Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
523 std::string solverDesc =
" Fixed Point ";
524 outputTest_->setSolverDesc( solverDesc );
530 std::string solveLabel = label_ +
": FixedPointSolMgr total solve time";
531 #ifdef BELOS_TEUCHOS_TIME_MONITOR
541 template<
class ScalarType,
class MV,
class OP>
554 "The relative residual tolerance that needs to be achieved by the\n"
555 "iterative solver in order for the linear system to be declared converged.");
556 pl->
set(
"Maximum Iterations", static_cast<int>(maxIters_default_),
557 "The maximum number of block iterations allowed for each\n"
558 "set of RHS solved.");
559 pl->
set(
"Block Size", static_cast<int>(blockSize_default_),
560 "The number of vectors in each block.");
561 pl->
set(
"Verbosity", static_cast<int>(verbosity_default_),
562 "What type(s) of solver information should be outputted\n"
563 "to the output stream.");
564 pl->
set(
"Output Style", static_cast<int>(outputStyle_default_),
565 "What style is used for the solver information outputted\n"
566 "to the output stream.");
567 pl->
set(
"Output Frequency", static_cast<int>(outputFreq_default_),
568 "How often convergence information should be outputted\n"
569 "to the output stream.");
570 pl->
set(
"Output Stream", Teuchos::rcpFromRef(std::cout),
571 "A reference-counted pointer to the output stream where all\n"
572 "solver output is sent.");
573 pl->
set(
"Show Maximum Residual Norm Only", static_cast<bool>(showMaxResNormOnly_default_),
574 "When convergence information is printed, only show the maximum\n"
575 "relative residual norm when the block size is greater than one.");
576 pl->
set(
"Timer Label", static_cast<const char *>(label_default_),
577 "The string to use as a prefix for the timer labels.");
585 template<
class ScalarType,
class MV,
class OP>
589 using Teuchos::rcp_const_cast;
590 using Teuchos::rcp_dynamic_cast;
597 setParameters(Teuchos::parameterList(*getValidParameters()));
602 "Belos::FixedPointSolMgr::solve(): Linear problem is not ready, setProblem() "
603 "has not been called.");
607 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
608 int numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
610 std::vector<int> currIdx, currIdx2;
611 currIdx.resize( blockSize_ );
612 currIdx2.resize( blockSize_ );
613 for (
int i=0; i<numCurrRHS; ++i)
614 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
615 for (
int i=numCurrRHS; i<blockSize_; ++i)
616 { currIdx[i] = -1; currIdx2[i] = i; }
619 problem_->setLSIndex( currIdx );
624 plist.
set(
"Block Size",blockSize_);
627 outputTest_->reset();
631 bool isConverged =
true;
636 RCP<FixedPointIteration<ScalarType,MV,OP> > block_fp_iter;
641 #ifdef BELOS_TEUCHOS_TIME_MONITOR
645 while ( numRHS2Solve > 0 ) {
648 std::vector<int> convRHSIdx;
649 std::vector<int> currRHSIdx( currIdx );
650 currRHSIdx.resize(numCurrRHS);
653 block_fp_iter->resetNumIters();
656 outputTest_->resetNumCalls();
659 RCP<MV> R_0 = MVT::CloneViewNonConst( *(rcp_const_cast<MV>(problem_->getInitResVec())), currIdx );
664 block_fp_iter->initializeFixedPoint(newstate);
670 block_fp_iter->iterate();
674 if (convTest_->getStatus() ==
Passed) {
678 std::vector<int> convIdx = convTest_->convIndices();
683 if (convIdx.size() == currRHSIdx.size())
688 problem_->setCurrLS();
693 std::vector<int> unconvIdx(currRHSIdx.size());
694 for (
unsigned int i=0; i<currRHSIdx.size(); ++i) {
696 for (
unsigned int j=0; j<convIdx.size(); ++j) {
697 if (currRHSIdx[i] == convIdx[j]) {
703 currIdx2[have] = currIdx2[i];
704 currRHSIdx[have++] = currRHSIdx[i];
709 currRHSIdx.resize(have);
710 currIdx2.resize(have);
713 problem_->setLSIndex( currRHSIdx );
716 std::vector<MagnitudeType> norms;
717 R_0 = MVT::CloneCopy( *(block_fp_iter->getNativeResiduals(&norms)),currIdx2 );
718 for (
int i=0; i<have; ++i) { currIdx2[i] = i; }
721 block_fp_iter->setBlockSize( have );
726 block_fp_iter->initializeFixedPoint(defstate);
732 else if (maxIterTest_->getStatus() ==
Passed) {
742 "Belos::FixedPointSolMgr::solve(): Neither the convergence test nor "
743 "the maximum iteration count test passed. Please report this bug "
744 "to the Belos developers.");
749 achievedTol_ = MT::one();
751 MVT::MvInit( *X, SCT::zero() );
752 printer_->stream(
Warnings) <<
"Belos::FixedPointSolMgr::solve(): Warning! NaN has been detected!"
756 catch (
const std::exception &e) {
757 std::ostream& err = printer_->stream (
Errors);
758 err <<
"Error! Caught std::exception in FixedPointIteration::iterate() at "
759 <<
"iteration " << block_fp_iter->getNumIters() << std::endl
760 << e.what() << std::endl;
767 problem_->setCurrLS();
770 startPtr += numCurrRHS;
771 numRHS2Solve -= numCurrRHS;
772 if ( numRHS2Solve > 0 ) {
773 numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
776 currIdx.resize( blockSize_ );
777 currIdx2.resize( blockSize_ );
778 for (
int i=0; i<numCurrRHS; ++i)
779 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
780 for (
int i=numCurrRHS; i<blockSize_; ++i)
781 { currIdx[i] = -1; currIdx2[i] = i; }
784 problem_->setLSIndex( currIdx );
787 block_fp_iter->setBlockSize( blockSize_ );
790 currIdx.resize( numRHS2Solve );
801 #ifdef BELOS_TEUCHOS_TIME_MONITOR
812 numIters_ = maxIterTest_->getNumIters();
817 const std::vector<MagnitudeType>* pTestValues = convTest_->getTestValue();
820 "Belos::FixedPointSolMgr::solve(): The convergence test's getTestValue() "
821 "method returned NULL. Please report this bug to the Belos developers.");
824 "Belos::FixedPointSolMgr::solve(): The convergence test's getTestValue() "
825 "method returned a vector of length zero. Please report this bug to the "
826 "Belos developers.");
831 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
841 template<
class ScalarType,
class MV,
class OP>
844 std::ostringstream oss;
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
bool is_null(const boost::shared_ptr< T > &p)
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_
T & get(ParameterList &l, const std::string &name)
static constexpr int maxIters_default_
Belos concrete class for performing the conjugate-gradient (CG) iteration.
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
bool is_null(const std::shared_ptr< T > &p)
Teuchos::ScalarTraits< MagnitudeType > MT
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
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 std::string name()
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.
void setParameters(const Teuchos::RCP< Teuchos::ParameterList > ¶ms) override
Set the parameters the solver manager should use to solve the linear problem.
bool isParameter(const std::string &name) const
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.
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. ...
static void summarize(Ptr< const Comm< int > > comm, std::ostream &out=std::cout, const bool alwaysWriteLocal=false, const bool writeGlobalStats=true, const bool writeZeroTimers=true, const ECounterSetOp setOp=Intersection, const std::string &filter="", const bool ignoreZeroTimers=false)
bool is_null(const RCP< T > &p)
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.
void validateParameters(ParameterList const &validParamList, int const depth=1000, EValidateUsed const validateUsed=VALIDATE_USED_ENABLED, EValidateDefaults const validateDefaults=VALIDATE_DEFAULTS_ENABLED) const
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...
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
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...
bool isType(const std::string &name) const
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).