42 #ifndef BELOS_PSEUDO_BLOCK_STOCHASTIC_CG_SOLMGR_HPP
43 #define BELOS_PSEUDO_BLOCK_STOCHASTIC_CG_SOLMGR_HPP
61 #ifdef BELOS_TEUCHOS_TIME_MONITOR
89 template<
class ScalarType,
class MV,
class OP>
280 template<
class ScalarType,
class MV,
class OP>
282 outputStream_(Teuchos::rcpFromRef(std::cout)),
284 maxIters_(maxIters_default_),
286 verbosity_(verbosity_default_),
287 outputStyle_(outputStyle_default_),
288 outputFreq_(outputFreq_default_),
289 defQuorum_(defQuorum_default_),
290 assertPositiveDefiniteness_(assertPositiveDefiniteness_default_),
291 showMaxResNormOnly_(showMaxResNormOnly_default_),
292 resScale_(resScale_default_),
293 label_(label_default_),
298 template<
class ScalarType,
class MV,
class OP>
303 outputStream_(Teuchos::rcpFromRef(std::cout)),
305 maxIters_(maxIters_default_),
307 verbosity_(verbosity_default_),
308 outputStyle_(outputStyle_default_),
309 outputFreq_(outputFreq_default_),
310 defQuorum_(defQuorum_default_),
311 assertPositiveDefiniteness_(assertPositiveDefiniteness_default_),
312 showMaxResNormOnly_(showMaxResNormOnly_default_),
313 resScale_(resScale_default_),
314 label_(label_default_),
318 problem_.is_null (), std::invalid_argument,
319 "Belos::PseudoBlockStochasticCGSolMgr two-argument constructor: "
320 "'problem' is null. You must supply a non-null Belos::LinearProblem "
321 "instance when calling this constructor.");
329 template<
class ScalarType,
class MV,
class OP>
333 using Teuchos::parameterList;
336 RCP<const ParameterList> defaultParams = getValidParameters();
339 if (params_.is_null()) {
340 params_ = parameterList (*defaultParams);
347 maxIters_ = params->
get(
"Maximum Iterations",maxIters_default_);
350 params_->set(
"Maximum Iterations", maxIters_);
352 maxIterTest_->setMaxIters( maxIters_ );
356 if (params->
isParameter(
"Assert Positive Definiteness")) {
357 assertPositiveDefiniteness_ = params->
get(
"Assert Positive Definiteness",assertPositiveDefiniteness_default_);
360 params_->set(
"Assert Positive Definiteness", assertPositiveDefiniteness_);
365 std::string tempLabel = params->
get(
"Timer Label", label_default_);
368 if (tempLabel != label_) {
370 params_->set(
"Timer Label", label_);
371 std::string solveLabel = label_ +
": PseudoBlockStochasticCGSolMgr total solve time";
372 #ifdef BELOS_TEUCHOS_TIME_MONITOR
380 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
381 verbosity_ = params->
get(
"Verbosity", verbosity_default_);
383 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
387 params_->set(
"Verbosity", verbosity_);
389 printer_->setVerbosity(verbosity_);
394 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
395 outputStyle_ = params->
get(
"Output Style", outputStyle_default_);
397 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
401 params_->set(
"Output Style", outputStyle_);
407 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
410 params_->set(
"Output Stream", outputStream_);
412 printer_->setOStream( outputStream_ );
418 outputFreq_ = params->
get(
"Output Frequency", outputFreq_default_);
422 params_->set(
"Output Frequency", outputFreq_);
424 outputTest_->setOutputFrequency( outputFreq_ );
437 if (params->
isParameter(
"Convergence Tolerance")) {
439 convtol_ = params->
get (
"Convergence Tolerance",
447 params_->set(
"Convergence Tolerance", convtol_);
449 convTest_->setTolerance( convtol_ );
452 if (params->
isParameter(
"Show Maximum Residual Norm Only")) {
453 showMaxResNormOnly_ = Teuchos::getParameter<bool>(*params,
"Show Maximum Residual Norm Only");
456 params_->set(
"Show Maximum Residual Norm Only", showMaxResNormOnly_);
458 convTest_->setShowMaxResNormOnly( showMaxResNormOnly_ );
462 bool newResTest =
false;
467 std::string tempResScale = resScale_;
468 bool implicitResidualScalingName =
false;
470 tempResScale = params->
get<std::string> (
"Residual Scaling");
472 else if (params->
isParameter (
"Implicit Residual Scaling")) {
473 tempResScale = params->
get<std::string> (
"Implicit Residual Scaling");
474 implicitResidualScalingName =
true;
478 if (resScale_ != tempResScale) {
480 resScale_ = tempResScale;
484 if (implicitResidualScalingName) {
485 params_->set (
"Implicit Residual Scaling", resScale_);
488 params_->set (
"Residual Scaling", resScale_);
491 if (! convTest_.is_null()) {
495 catch (std::exception& e) {
505 defQuorum_ = params->
get(
"Deflation Quorum", defQuorum_);
506 params_->set(
"Deflation Quorum", defQuorum_);
508 convTest_->setQuorum( defQuorum_ );
519 convTest_ =
Teuchos::rcp(
new StatusTestResNorm_t( convtol_, defQuorum_, showMaxResNormOnly_ ) );
524 sTest_ =
Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
534 std::string solverDesc =
" Pseudo Block CG ";
535 outputTest_->setSolverDesc( solverDesc );
541 std::string solveLabel = label_ +
": PseudoBlockStochasticCGSolMgr total solve time";
542 #ifdef BELOS_TEUCHOS_TIME_MONITOR
552 template<
class ScalarType,
class MV,
class OP>
557 using Teuchos::parameterList;
560 if (validParams_.is_null()) {
565 RCP<ParameterList> pl = parameterList ();
567 "The relative residual tolerance that needs to be achieved by the\n"
568 "iterative solver in order for the linera system to be declared converged.");
569 pl->set(
"Maximum Iterations", static_cast<int>(maxIters_default_),
570 "The maximum number of block iterations allowed for each\n"
571 "set of RHS solved.");
572 pl->set(
"Assert Positive Definiteness", static_cast<bool>(assertPositiveDefiniteness_default_),
573 "Whether or not to assert that the linear operator\n"
574 "and the preconditioner are indeed positive definite.");
575 pl->set(
"Verbosity", static_cast<int>(verbosity_default_),
576 "What type(s) of solver information should be outputted\n"
577 "to the output stream.");
578 pl->set(
"Output Style", static_cast<int>(outputStyle_default_),
579 "What style is used for the solver information outputted\n"
580 "to the output stream.");
581 pl->set(
"Output Frequency", static_cast<int>(outputFreq_default_),
582 "How often convergence information should be outputted\n"
583 "to the output stream.");
584 pl->set(
"Deflation Quorum", static_cast<int>(defQuorum_default_),
585 "The number of linear systems that need to converge before\n"
586 "they are deflated. This number should be <= block size.");
587 pl->set(
"Output Stream", Teuchos::rcpFromRef(std::cout),
588 "A reference-counted pointer to the output stream where all\n"
589 "solver output is sent.");
590 pl->set(
"Show Maximum Residual Norm Only", static_cast<bool>(showMaxResNormOnly_default_),
591 "When convergence information is printed, only show the maximum\n"
592 "relative residual norm when the block size is greater than one.");
593 pl->set(
"Implicit Residual Scaling", resScale_default_,
594 "The type of scaling used in the residual convergence test.");
600 pl->set(
"Residual Scaling", resScale_default_,
601 "The type of scaling used in the residual convergence test. This "
602 "name is deprecated; the new name is \"Implicit Residual Scaling\".");
603 pl->set(
"Timer Label", static_cast<const char *>(label_default_),
604 "The string to use as a prefix for the timer labels.");
612 template<
class ScalarType,
class MV,
class OP>
618 if (!isSet_) { setParameters( params_ ); }
621 "Belos::PseudoBlockStochasticCGSolMgr::solve(): Linear problem is not ready, setProblem() has not been called.");
625 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
626 int numCurrRHS = numRHS2Solve;
628 std::vector<int> currIdx( numRHS2Solve ), currIdx2( numRHS2Solve );
629 for (
int i=0; i<numRHS2Solve; ++i) {
630 currIdx[i] = startPtr+i;
635 problem_->setLSIndex( currIdx );
641 plist.
set(
"Assert Positive Definiteness",assertPositiveDefiniteness_);
644 outputTest_->reset();
647 bool isConverged =
true;
657 #ifdef BELOS_TEUCHOS_TIME_MONITOR
661 while ( numRHS2Solve > 0 ) {
664 std::vector<int> convRHSIdx;
665 std::vector<int> currRHSIdx( currIdx );
666 currRHSIdx.resize(numCurrRHS);
669 block_cg_iter->resetNumIters();
672 outputTest_->resetNumCalls();
675 Teuchos::RCP<MV> R_0 = MVT::CloneViewNonConst( *(Teuchos::rcp_const_cast<MV>(problem_->getInitResVec())), currIdx );
680 block_cg_iter->initializeCG(newState);
686 block_cg_iter->iterate();
693 if ( convTest_->getStatus() ==
Passed ) {
700 if (convIdx.size() == currRHSIdx.size())
704 problem_->setCurrLS();
708 std::vector<int> unconvIdx(currRHSIdx.size());
709 for (
unsigned int i=0; i<currRHSIdx.size(); ++i) {
711 for (
unsigned int j=0; j<convIdx.size(); ++j) {
712 if (currRHSIdx[i] == convIdx[j]) {
718 currIdx2[have] = currIdx2[i];
719 currRHSIdx[have++] = currRHSIdx[i];
722 currRHSIdx.resize(have);
723 currIdx2.resize(have);
726 problem_->setLSIndex( currRHSIdx );
729 std::vector<MagnitudeType> norms;
730 R_0 = MVT::CloneCopy( *(block_cg_iter->getNativeResiduals(&norms)),currIdx2 );
731 for (
int i=0; i<have; ++i) { currIdx2[i] = i; }
736 block_cg_iter->initializeCG(defstate);
744 else if ( maxIterTest_->getStatus() ==
Passed ) {
759 "Belos::PseudoBlockStochasticCGSolMgr::solve(): Invalid return from PseudoBlockStochasticCGIter::iterate().");
762 catch (
const std::exception &e) {
763 printer_->stream(
Errors) <<
"Error! Caught std::exception in PseudoBlockStochasticCGIter::iterate() at iteration "
764 << block_cg_iter->getNumIters() << std::endl
765 << e.what() << std::endl;
771 problem_->setCurrLS();
774 startPtr += numCurrRHS;
775 numRHS2Solve -= numCurrRHS;
777 if ( numRHS2Solve > 0 ) {
779 numCurrRHS = numRHS2Solve;
780 currIdx.resize( numCurrRHS );
781 currIdx2.resize( numCurrRHS );
782 for (
int i=0; i<numCurrRHS; ++i)
783 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
786 problem_->setLSIndex( currIdx );
789 currIdx.resize( numRHS2Solve );
797 Y_=block_cg_iter->getStochasticVector();
804 #ifdef BELOS_TEUCHOS_TIME_MONITOR
813 numIters_ = maxIterTest_->getNumIters();
822 template<
class ScalarType,
class MV,
class OP>
825 std::ostringstream oss;
ScaleType convertStringToScaleType(const std::string &scaleType)
Convert the given string to its ScaleType enum value.
static constexpr int verbosity_default_
Collection of types and exceptions used within the Belos solvers.
bool isLOADetected() const override
Return whether a loss of accuracy was detected by this solver during the most current solve...
Belos's basic output manager for sending information of select verbosity levels to the appropriate ou...
Teuchos::RCP< OutputManager< ScalarType > > printer_
Class which manages the output and verbosity of the Belos solvers.
Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > problem_
OperatorTraits< ScalarType, MV, OP > OPT
ScaleType
The type of scaling to use on the residual norm value.
Teuchos::RCP< const Teuchos::ParameterList > validParams_
List of valid parameters and their default values.
T & get(ParameterList &l, const std::string &name)
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)
static constexpr const char * label_default_
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
A factory class for generating StatusTestOutput objects.
Teuchos::RCP< StatusTestGenResNorm< ScalarType, MV, OP > > convTest_
static constexpr int outputFreq_default_
int getNumIters() const override
Get the iteration count for the most recent call to solve().
std::string description() const override
Method to return description of the block CG solver manager.
static constexpr bool assertPositiveDefiniteness_default_
An implementation of StatusTestResNorm using a family of residual norms.
Teuchos::ScalarTraits< ScalarType >::magnitudeType MagnitudeType
Teuchos::ScalarTraits< ScalarType > SCT
static const double convTol
Default convergence tolerance.
Belos::StatusTest class for specifying a maximum number of iterations.
static std::string name()
static constexpr int outputStyle_default_
A factory class for generating StatusTestOutput objects.
static constexpr const char * resScale_default_
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const override
Get a parameter list containing the current parameters for this object.
const LinearProblem< ScalarType, MV, OP > & getProblem() const override
Return a reference to the linear problem being solved by this solver manager.
Traits class which defines basic operations on multivectors.
Teuchos::RCP< Teuchos::Time > timerSolve_
Belos::StatusTest for logically combining several status tests.
bool isParameter(const std::string &name) const
static constexpr bool showMaxResNormOnly_default_
A Belos::StatusTest class for specifying a maximum number of iterations.
Belos concrete class for performing the stochastic pseudo-block CG iteration.
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)
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const override
Get a parameter list containing the valid parameters 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::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
A linear system to solve, and its associated information.
Class which describes the linear problem to be solved by the iterative solver.
Teuchos::RCP< const MV > R
The current residual.
static constexpr int defQuorum_default_
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 ...
bool assertPositiveDefiniteness_
Teuchos::RCP< StatusTestOutput< ScalarType, MV, OP > > outputTest_
void validateParameters(ParameterList const &validParamList, int const depth=1000, EValidateUsed const validateUsed=VALIDATE_USED_ENABLED, EValidateDefaults const validateDefaults=VALIDATE_DEFAULTS_ENABLED) const
Teuchos::RCP< Teuchos::ParameterList > params_
virtual ~PseudoBlockStochasticCGSolMgr()
Destructor.
Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const override
clone for Inverted Injection (DII)
MultiVecTraits< ScalarType, MV > MVT
PseudoBlockStochasticCGSolMgr()
Empty constructor for BlockStochasticCGSolMgr. This constructor takes no arguments and sets the defau...
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.
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem) override
Set the linear problem that needs to be solved.
ReturnType solve() override
This method performs possibly repeated calls to the underlying linear solver's iterate() routine unti...
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
This class implements the stochastic pseudo-block CG iteration, where the basic stochastic CG algorit...
The Belos::PseudoBlockStochasticCGSolMgr provides a powerful and fully-featured solver manager over t...
bool isType(const std::string &name) const
Teuchos::RCP< MV > getStochasticVector()
Get a copy of the final stochastic vector.
A class for extending the status testing capabilities of Belos via logical combinations.
PseudoBlockStochasticCGSolMgrLinearProblemFailure(const std::string &what_arg)
void reset(const ResetType type) override
Performs a reset of the solver manager specified by the ResetType. This informs the solver manager th...
Class which defines basic traits for the operator type.
Parent class to all Belos exceptions.
Default parameters common to most Belos solvers.
Teuchos::RCP< std::ostream > outputStream_
Belos header file which uses auto-configuration information to include necessary C++ headers...
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > sTest_
PseudoBlockStochasticCGSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i...
static constexpr int maxIters_default_
Teuchos::RCP< StatusTestMaxIters< ScalarType, MV, OP > > maxIterTest_
Structure to contain pointers to CGIteration state variables.
Teuchos::ScalarTraits< MagnitudeType > MT