42#ifndef BELOS_BLOCK_CG_SOLMGR_HPP
43#define BELOS_BLOCK_CG_SOLMGR_HPP
64#include "Teuchos_LAPACK.hpp"
65#ifdef BELOS_TEUCHOS_TIME_MONITOR
66# include "Teuchos_TimeMonitor.hpp"
68#if defined(HAVE_TEUCHOSCORE_CXX11)
69# include <type_traits>
104 template<
class ScalarType,
class MV,
class OP,
105 const bool lapackSupportsScalarType =
110 static const bool requiresLapack =
120 const Teuchos::RCP<Teuchos::ParameterList>& pl) :
130 template<
class ScalarType,
class MV,
class OP>
157 typedef Teuchos::ScalarTraits<ScalarType> SCT;
158 typedef typename Teuchos::ScalarTraits<ScalarType>::magnitudeType MagnitudeType;
159 typedef Teuchos::ScalarTraits<MagnitudeType> MT;
210 const Teuchos::RCP<Teuchos::ParameterList> &pl );
216 Teuchos::RCP<SolverManager<ScalarType, MV, OP> >
clone ()
const override {
230 Teuchos::RCP<const Teuchos::ParameterList> getValidParameters()
const override;
241 Teuchos::Array<Teuchos::RCP<Teuchos::Time> >
getTimers()
const {
242 return Teuchos::tuple(timerSolve_);
272 void setParameters(
const Teuchos::RCP<Teuchos::ParameterList> ¶ms )
override;
313 std::string description()
const override;
320 Teuchos::RCP<LinearProblem<ScalarType,MV,OP> > problem_;
323 Teuchos::RCP<OutputManager<ScalarType> > printer_;
325 Teuchos::RCP<std::ostream> outputStream_;
331 Teuchos::RCP<StatusTest<ScalarType,MV,OP> > sTest_;
334 Teuchos::RCP<StatusTestMaxIters<ScalarType,MV,OP> > maxIterTest_;
337 Teuchos::RCP<StatusTestGenResNorm<ScalarType,MV,OP> > convTest_;
340 Teuchos::RCP<StatusTestOutput<ScalarType,MV,OP> > outputTest_;
343 Teuchos::RCP<MatOrthoManager<ScalarType,MV,OP> > ortho_;
346 Teuchos::RCP<Teuchos::ParameterList> params_;
351 static constexpr int maxIters_default_ = 1000;
352 static constexpr bool adaptiveBlockSize_default_ =
true;
353 static constexpr bool showMaxResNormOnly_default_ =
false;
354 static constexpr bool useSingleReduction_default_ =
false;
355 static constexpr int blockSize_default_ = 1;
358 static constexpr int outputFreq_default_ = -1;
359 static constexpr const char * resNorm_default_ =
"TwoNorm";
360 static constexpr bool foldConvergenceDetectionIntoAllreduce_default_ =
false;
361 static constexpr const char * resScale_default_ =
"Norm of Initial Residual";
362 static constexpr const char * label_default_ =
"Belos";
363 static constexpr const char * orthoType_default_ =
"ICGS";
364 static constexpr bool assertPositiveDefiniteness_default_ =
true;
371 MagnitudeType convtol_;
374 MagnitudeType orthoKappa_;
381 MagnitudeType achievedTol_;
390 int blockSize_, verbosity_, outputStyle_, outputFreq_;
391 bool adaptiveBlockSize_, showMaxResNormOnly_, useSingleReduction_;
392 std::string orthoType_, resScale_;
393 bool assertPositiveDefiniteness_;
394 bool foldConvergenceDetectionIntoAllreduce_;
400 Teuchos::RCP<Teuchos::Time> timerSolve_;
408template<
class ScalarType,
class MV,
class OP>
410 outputStream_(Teuchos::rcpFromRef(std::cout)),
413 achievedTol_(Teuchos::ScalarTraits<MagnitudeType>::zero()),
414 maxIters_(maxIters_default_),
416 blockSize_(blockSize_default_),
417 verbosity_(verbosity_default_),
418 outputStyle_(outputStyle_default_),
419 outputFreq_(outputFreq_default_),
420 adaptiveBlockSize_(adaptiveBlockSize_default_),
421 showMaxResNormOnly_(showMaxResNormOnly_default_),
422 useSingleReduction_(useSingleReduction_default_),
423 orthoType_(orthoType_default_),
424 resScale_(resScale_default_),
425 assertPositiveDefiniteness_(assertPositiveDefiniteness_default_),
426 foldConvergenceDetectionIntoAllreduce_(foldConvergenceDetectionIntoAllreduce_default_),
427 label_(label_default_),
433template<
class ScalarType,
class MV,
class OP>
436 const Teuchos::RCP<Teuchos::ParameterList> &pl) :
438 outputStream_(Teuchos::rcpFromRef(std::cout)),
441 achievedTol_(Teuchos::ScalarTraits<MagnitudeType>::zero()),
442 maxIters_(maxIters_default_),
444 blockSize_(blockSize_default_),
445 verbosity_(verbosity_default_),
446 outputStyle_(outputStyle_default_),
447 outputFreq_(outputFreq_default_),
448 adaptiveBlockSize_(adaptiveBlockSize_default_),
449 showMaxResNormOnly_(showMaxResNormOnly_default_),
450 useSingleReduction_(useSingleReduction_default_),
451 orthoType_(orthoType_default_),
452 resScale_(resScale_default_),
453 assertPositiveDefiniteness_(assertPositiveDefiniteness_default_),
454 foldConvergenceDetectionIntoAllreduce_(foldConvergenceDetectionIntoAllreduce_default_),
455 label_(label_default_),
458 TEUCHOS_TEST_FOR_EXCEPTION(problem_.is_null(), std::invalid_argument,
459 "BlockCGSolMgr's constructor requires a nonnull LinearProblem instance.");
464 if (! pl.is_null()) {
469template<
class ScalarType,
class MV,
class OP>
472setParameters (
const Teuchos::RCP<Teuchos::ParameterList> ¶ms)
475 if (params_ == Teuchos::null) {
476 params_ = Teuchos::rcp(
new Teuchos::ParameterList(*getValidParameters()) );
479 params->validateParameters(*getValidParameters());
483 if (params->isParameter(
"Maximum Iterations")) {
484 maxIters_ = params->get(
"Maximum Iterations",maxIters_default_);
487 params_->set(
"Maximum Iterations", maxIters_);
488 if (maxIterTest_!=Teuchos::null)
489 maxIterTest_->setMaxIters( maxIters_ );
493 if (params->isParameter(
"Block Size")) {
494 blockSize_ = params->get(
"Block Size",blockSize_default_);
495 TEUCHOS_TEST_FOR_EXCEPTION(blockSize_ <= 0, std::invalid_argument,
496 "Belos::BlockCGSolMgr: \"Block Size\" must be strictly positive.");
499 params_->set(
"Block Size", blockSize_);
503 if (params->isParameter(
"Adaptive Block Size")) {
504 adaptiveBlockSize_ = params->get(
"Adaptive Block Size",adaptiveBlockSize_default_);
507 params_->set(
"Adaptive Block Size", adaptiveBlockSize_);
511 if (params->isParameter(
"Use Single Reduction")) {
512 useSingleReduction_ = params->get(
"Use Single Reduction", useSingleReduction_default_);
515 if (params->isParameter(
"Fold Convergence Detection Into Allreduce")) {
516 foldConvergenceDetectionIntoAllreduce_ = params->get(
"Fold Convergence Detection Into Allreduce",
517 foldConvergenceDetectionIntoAllreduce_default_);
521 if (params->isParameter(
"Timer Label")) {
522 std::string tempLabel = params->get(
"Timer Label", label_default_);
525 if (tempLabel != label_) {
527 params_->set(
"Timer Label", label_);
528 std::string solveLabel = label_ +
": BlockCGSolMgr total solve time";
529#ifdef BELOS_TEUCHOS_TIME_MONITOR
530 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
532 if (ortho_ != Teuchos::null) {
533 ortho_->setLabel( label_ );
539 if (params->isParameter(
"Verbosity")) {
540 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
541 verbosity_ = params->get(
"Verbosity", verbosity_default_);
543 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
547 params_->set(
"Verbosity", verbosity_);
548 if (printer_ != Teuchos::null)
549 printer_->setVerbosity(verbosity_);
553 if (params->isParameter(
"Output Style")) {
554 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
555 outputStyle_ = params->get(
"Output Style", outputStyle_default_);
557 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
561 params_->set(
"Output Style", outputStyle_);
562 outputTest_ = Teuchos::null;
566 if (params->isParameter(
"Output Stream")) {
567 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
570 params_->set(
"Output Stream", outputStream_);
571 if (printer_ != Teuchos::null)
572 printer_->setOStream( outputStream_ );
577 if (params->isParameter(
"Output Frequency")) {
578 outputFreq_ = params->get(
"Output Frequency", outputFreq_default_);
582 params_->set(
"Output Frequency", outputFreq_);
583 if (outputTest_ != Teuchos::null)
584 outputTest_->setOutputFrequency( outputFreq_ );
588 if (printer_ == Teuchos::null) {
593 bool changedOrthoType =
false;
594 if (params->isParameter(
"Orthogonalization")) {
595 std::string tempOrthoType = params->get(
"Orthogonalization",orthoType_default_);
596 if (tempOrthoType != orthoType_) {
597 orthoType_ = tempOrthoType;
598 changedOrthoType =
true;
601 params_->set(
"Orthogonalization", orthoType_);
604 if (params->isParameter(
"Orthogonalization Constant")) {
605 if (params->isType<MagnitudeType> (
"Orthogonalization Constant")) {
606 orthoKappa_ = params->get (
"Orthogonalization Constant",
610 orthoKappa_ = params->get (
"Orthogonalization Constant",
615 params_->set(
"Orthogonalization Constant",orthoKappa_);
616 if (orthoType_==
"DGKS") {
617 if (orthoKappa_ > 0 && ortho_ != Teuchos::null && !changedOrthoType) {
618 Teuchos::rcp_dynamic_cast<DGKSOrthoManager<ScalarType,MV,OP> >(ortho_)->setDepTol( orthoKappa_ );
624 if (ortho_ == Teuchos::null || changedOrthoType) {
626 Teuchos::RCP<Teuchos::ParameterList> paramsOrtho;
627 if (orthoType_==
"DGKS" && orthoKappa_ > 0) {
628 paramsOrtho->set (
"depTol", orthoKappa_ );
631 ortho_ = factory.
makeMatOrthoManager (orthoType_, Teuchos::null, printer_, label_, paramsOrtho);
639 if (params->isParameter(
"Convergence Tolerance")) {
640 if (params->isType<MagnitudeType> (
"Convergence Tolerance")) {
641 convtol_ = params->get (
"Convergence Tolerance",
649 params_->set(
"Convergence Tolerance", convtol_);
650 if (convTest_ != Teuchos::null)
654 if (params->isParameter(
"Show Maximum Residual Norm Only")) {
655 showMaxResNormOnly_ = Teuchos::getParameter<bool>(*params,
"Show Maximum Residual Norm Only");
658 params_->set(
"Show Maximum Residual Norm Only", showMaxResNormOnly_);
659 if (convTest_ != Teuchos::null)
660 convTest_->setShowMaxResNormOnly( showMaxResNormOnly_ );
664 bool newResTest =
false;
666 std::string tempResScale = resScale_;
667 if (params->isParameter (
"Implicit Residual Scaling")) {
668 tempResScale = params->get<std::string> (
"Implicit Residual Scaling");
672 if (resScale_ != tempResScale) {
675 resScale_ = tempResScale;
678 params_->set (
"Implicit Residual Scaling", resScale_);
680 if (! convTest_.is_null ()) {
683 if (params->isParameter(
"Residual Norm")) {
684 if (params->isType<std::string> (
"Residual Norm")) {
688 convTest_->defineResForm(StatusTestResNorm_t::Implicit, normType);
691 catch (std::exception& e) {
702 if (maxIterTest_ == Teuchos::null)
706 if (convTest_.is_null () || newResTest) {
709 if (params->isParameter(
"Residual Norm")) {
710 if (params->isType<std::string> (
"Residual Norm")) {
715 convTest_ = rcp (
new StatusTestResNorm_t (convtol_, 1, showMaxResNormOnly_));
716 convTest_->defineResForm(StatusTestResNorm_t::Implicit, normType);
720 if (sTest_.is_null () || newResTest)
721 sTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
723 if (outputTest_.is_null () || newResTest) {
731 std::string solverDesc =
" Block CG ";
732 outputTest_->setSolverDesc( solverDesc );
737 if (params->isParameter(
"Assert Positive Definiteness")) {
738 assertPositiveDefiniteness_ = Teuchos::getParameter<bool>(*params,
"Assert Positive Definiteness");
739 params_->set(
"Assert Positive Definiteness", assertPositiveDefiniteness_);
743 if (timerSolve_ == Teuchos::null) {
744 std::string solveLabel = label_ +
": BlockCGSolMgr total solve time";
745#ifdef BELOS_TEUCHOS_TIME_MONITOR
746 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
755template<
class ScalarType,
class MV,
class OP>
756Teuchos::RCP<const Teuchos::ParameterList>
759 static Teuchos::RCP<const Teuchos::ParameterList> validPL;
762 if(is_null(validPL)) {
763 Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
765 "The relative residual tolerance that needs to be achieved by the\n"
766 "iterative solver in order for the linear system to be declared converged.");
767 pl->set(
"Maximum Iterations",
static_cast<int>(maxIters_default_),
768 "The maximum number of block iterations allowed for each\n"
769 "set of RHS solved.");
770 pl->set(
"Block Size",
static_cast<int>(blockSize_default_),
771 "The number of vectors in each block.");
772 pl->set(
"Adaptive Block Size",
static_cast<bool>(adaptiveBlockSize_default_),
773 "Whether the solver manager should adapt to the block size\n"
774 "based on the number of RHS to solve.");
775 pl->set(
"Verbosity",
static_cast<int>(verbosity_default_),
776 "What type(s) of solver information should be outputted\n"
777 "to the output stream.");
778 pl->set(
"Output Style",
static_cast<int>(outputStyle_default_),
779 "What style is used for the solver information outputted\n"
780 "to the output stream.");
781 pl->set(
"Output Frequency",
static_cast<int>(outputFreq_default_),
782 "How often convergence information should be outputted\n"
783 "to the output stream.");
784 pl->set(
"Output Stream", Teuchos::rcpFromRef(std::cout),
785 "A reference-counted pointer to the output stream where all\n"
786 "solver output is sent.");
787 pl->set(
"Show Maximum Residual Norm Only",
static_cast<bool>(showMaxResNormOnly_default_),
788 "When convergence information is printed, only show the maximum\n"
789 "relative residual norm when the block size is greater than one.");
790 pl->set(
"Use Single Reduction",
static_cast<bool>(useSingleReduction_default_),
791 "Use single reduction iteration when the block size is one.");
792 pl->set(
"Implicit Residual Scaling", resScale_default_,
793 "The type of scaling used in the residual convergence test.");
794 pl->set(
"Timer Label",
static_cast<const char *
>(label_default_),
795 "The string to use as a prefix for the timer labels.");
796 pl->set(
"Orthogonalization",
static_cast<const char *
>(orthoType_default_),
797 "The type of orthogonalization to use: DGKS, ICGS, or IMGS.");
798 pl->set(
"Assert Positive Definiteness",
static_cast<bool>(assertPositiveDefiniteness_default_),
799 "Assert for positivity of p^H*A*p in CG iteration.");
801 "The constant used by DGKS orthogonalization to determine\n"
802 "whether another step of classical Gram-Schmidt is necessary.");
803 pl->set(
"Residual Norm",
static_cast<const char *
>(resNorm_default_),
804 "Norm used for the convergence check on the residual.");
805 pl->set(
"Fold Convergence Detection Into Allreduce",
static_cast<bool>(foldConvergenceDetectionIntoAllreduce_default_),
806 "Merge the allreduce for convergence detection with the one for CG.\n"
807 "This saves one all-reduce, but incurs more computation.");
815template<
class ScalarType,
class MV,
class OP>
819 using Teuchos::rcp_const_cast;
820 using Teuchos::rcp_dynamic_cast;
827 setParameters(Teuchos::parameterList(*getValidParameters()));
830 Teuchos::LAPACK<int,ScalarType> lapack;
832 TEUCHOS_TEST_FOR_EXCEPTION( !problem_->isProblemSet(),
834 "Belos::BlockCGSolMgr::solve(): Linear problem is not ready, setProblem() "
835 "has not been called.");
839 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
840 int numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
842 std::vector<int> currIdx, currIdx2;
847 if ( adaptiveBlockSize_ ) {
848 blockSize_ = numCurrRHS;
849 currIdx.resize( numCurrRHS );
850 currIdx2.resize( numCurrRHS );
851 for (
int i=0; i<numCurrRHS; ++i)
852 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
856 currIdx.resize( blockSize_ );
857 currIdx2.resize( blockSize_ );
858 for (
int i=0; i<numCurrRHS; ++i)
859 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
860 for (
int i=numCurrRHS; i<blockSize_; ++i)
861 { currIdx[i] = -1; currIdx2[i] = i; }
865 problem_->setLSIndex( currIdx );
869 Teuchos::ParameterList plist;
870 plist.set(
"Block Size",blockSize_);
873 outputTest_->reset();
877 bool isConverged =
true;
882 plist.set(
"Assert Positive Definiteness", assertPositiveDefiniteness_);
884 RCP<CGIteration<ScalarType,MV,OP> > block_cg_iter;
885 if (blockSize_ == 1) {
889 plist.set(
"Fold Convergence Detection Into Allreduce",
890 foldConvergenceDetectionIntoAllreduce_);
891 if (useSingleReduction_) {
894 outputTest_, convTest_, plist));
899 outputTest_, convTest_, plist));
910#ifdef BELOS_TEUCHOS_TIME_MONITOR
911 Teuchos::TimeMonitor slvtimer(*timerSolve_);
914 while ( numRHS2Solve > 0 ) {
917 std::vector<int> convRHSIdx;
918 std::vector<int> currRHSIdx( currIdx );
919 currRHSIdx.resize(numCurrRHS);
922 block_cg_iter->resetNumIters();
925 outputTest_->resetNumCalls();
928 RCP<MV> R_0 = MVT::CloneViewNonConst( *(rcp_const_cast<MV>(problem_->getInitResVec())), currIdx );
933 block_cg_iter->initializeCG(newstate);
939 block_cg_iter->iterate();
943 if (convTest_->getStatus() ==
Passed) {
948 std::vector<int> convIdx =
949 rcp_dynamic_cast<conv_test_type>(convTest_)->
convIndices();
954 if (convIdx.size() == currRHSIdx.size())
959 problem_->setCurrLS();
964 std::vector<int> unconvIdx(currRHSIdx.size());
965 for (
unsigned int i=0; i<currRHSIdx.size(); ++i) {
967 for (
unsigned int j=0; j<convIdx.size(); ++j) {
968 if (currRHSIdx[i] == convIdx[j]) {
974 currIdx2[have] = currIdx2[i];
975 currRHSIdx[have++] = currRHSIdx[i];
980 currRHSIdx.resize(have);
981 currIdx2.resize(have);
984 problem_->setLSIndex( currRHSIdx );
987 std::vector<MagnitudeType> norms;
988 R_0 = MVT::CloneCopy( *(block_cg_iter->getNativeResiduals(&norms)),currIdx2 );
989 for (
int i=0; i<have; ++i) { currIdx2[i] = i; }
992 block_cg_iter->setBlockSize( have );
997 block_cg_iter->initializeCG(defstate);
1003 else if (maxIterTest_->getStatus() ==
Passed) {
1004 isConverged =
false;
1012 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
1013 "Belos::BlockCGSolMgr::solve(): Neither the convergence test nor "
1014 "the maximum iteration count test passed. Please report this bug "
1015 "to the Belos developers.");
1018 catch (
const std::exception &e) {
1019 std::ostream& err = printer_->stream (
Errors);
1020 err <<
"Error! Caught std::exception in CGIteration::iterate() at "
1021 <<
"iteration " << block_cg_iter->getNumIters() << std::endl
1022 << e.what() << std::endl;
1029 problem_->setCurrLS();
1032 startPtr += numCurrRHS;
1033 numRHS2Solve -= numCurrRHS;
1034 if ( numRHS2Solve > 0 ) {
1035 numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
1037 if ( adaptiveBlockSize_ ) {
1038 blockSize_ = numCurrRHS;
1039 currIdx.resize( numCurrRHS );
1040 currIdx2.resize( numCurrRHS );
1041 for (
int i=0; i<numCurrRHS; ++i)
1042 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
1045 currIdx.resize( blockSize_ );
1046 currIdx2.resize( blockSize_ );
1047 for (
int i=0; i<numCurrRHS; ++i)
1048 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
1049 for (
int i=numCurrRHS; i<blockSize_; ++i)
1050 { currIdx[i] = -1; currIdx2[i] = i; }
1053 problem_->setLSIndex( currIdx );
1056 block_cg_iter->setBlockSize( blockSize_ );
1059 currIdx.resize( numRHS2Solve );
1070#ifdef BELOS_TEUCHOS_TIME_MONITOR
1076 Teuchos::TimeMonitor::summarize( printer_->stream(
TimingDetails) );
1081 numIters_ = maxIterTest_->getNumIters();
1087 const std::vector<MagnitudeType>* pTestValues =
1088 rcp_dynamic_cast<conv_test_type>(convTest_)->
getTestValue();
1090 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues == NULL, std::logic_error,
1091 "Belos::BlockCGSolMgr::solve(): The convergence test's getTestValue() "
1092 "method returned NULL. Please report this bug to the Belos developers.");
1094 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues->size() < 1, std::logic_error,
1095 "Belos::BlockCGSolMgr::solve(): The convergence test's getTestValue() "
1096 "method returned a vector of length zero. Please report this bug to the "
1097 "Belos developers.");
1102 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
1112template<
class ScalarType,
class MV,
class OP>
1115 std::ostringstream oss;
1116 oss <<
"Belos::BlockCGSolMgr<...,"<<Teuchos::ScalarTraits<ScalarType>::name()<<
">";
1118 oss <<
"Ortho Type='"<<orthoType_<<
"\', Block Size=" << blockSize_;
Belos concrete class for performing the block conjugate-gradient (CG) iteration.
Belos concrete class for performing the conjugate-gradient (CG) iteration.
Belos concrete class for performing a single-reduction conjugate-gradient (CG) iteration.
Belos header file which uses auto-configuration information to include necessary C++ headers.
Class which describes the linear problem to be solved by the iterative solver.
Class which manages the output and verbosity of the Belos solvers.
Pure virtual base class which describes the basic interface for a solver manager.
Belos::StatusTest for logically combining several status tests.
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
Belos::StatusTest class for specifying a maximum number of iterations.
A factory class for generating StatusTestOutput objects.
Collection of types and exceptions used within the Belos solvers.
Parent class to all Belos exceptions.
Stub implementation of BlockCGIter, for ScalarType types for which Teuchos::LAPACK does NOT have a va...
BlockCGSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i....
BlockCGSolMgrLinearProblemFailure(const std::string &what_arg)
const LinearProblem< ScalarType, MV, OP > & getProblem() const override
Return a reference to the linear problem being solved by this solver manager.
Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const override
clone for Inverted Injection (DII)
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const override
Get a parameter list containing the current parameters for this object.
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem) override
Set the linear problem that needs to be solved.
virtual ~BlockCGSolMgr()
Destructor.
void reset(const ResetType type) override
Performs a reset of the solver manager specified by the ResetType. This informs the solver manager th...
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
int getNumIters() const override
Get the iteration count for the most recent call to solve().
bool isLOADetected() const override
Return whether a loss of accuracy was detected by this solver during the most current solve.
MagnitudeType achievedTol() const override
Tolerance achieved by the last solve() invocation.
The Belos::BlockCGSolMgr provides a powerful and fully-featured solver manager over the CG and BlockC...
BlockCGSolMgr(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem, const Teuchos::RCP< Teuchos::ParameterList > &pl)
This class implements the preconditioned Conjugate Gradient (CG) iteration.
This class implements the preconditioned single-reduction Conjugate Gradient (CG) iteration.
Type traits class that says whether Teuchos::LAPACK has a valid implementation for the given ScalarTy...
Base class for Belos::SolverManager subclasses which normally can only compile with ScalarType types ...
A linear system to solve, and its associated information.
Traits class which defines basic operations on multivectors.
Class which defines basic traits for the operator type.
Enumeration of all valid Belos (Mat)OrthoManager classes.
Teuchos::RCP< Belos::MatOrthoManager< Scalar, MV, OP > > makeMatOrthoManager(const std::string &ortho, const Teuchos::RCP< const OP > &M, const Teuchos::RCP< OutputManager< Scalar > > &, const std::string &label, const Teuchos::RCP< Teuchos::ParameterList > ¶ms)
Return an instance of the specified MatOrthoManager subclass.
Belos's basic output manager for sending information of select verbosity levels to the appropriate ou...
A class for extending the status testing capabilities of Belos via logical combinations.
An implementation of StatusTestResNorm using a family of residual norms.
std::vector< int > convIndices()
Returns the std::vector containing the indices of the residuals that passed the test.
const std::vector< MagnitudeType > * getTestValue() const
Returns the test value, , computed in most recent call to CheckStatus.
int setTolerance(MagnitudeType tolerance)
Set the value of the tolerance.
A Belos::StatusTest class for specifying a maximum number of iterations.
A factory class for generating StatusTestOutput objects.
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.
ScaleType convertStringToScaleType(const std::string &scaleType)
Convert the given string to its ScaleType enum value.
NormType
The type of vector norm to compute.
NormType convertStringToNormType(const std::string &normType)
Convert the given string to its NormType enum value.
ReturnType
Whether the Belos solve converged for all linear systems.
ScaleType
The type of scaling to use on the residual norm value.
ResetType
How to reset the solver.
Structure to contain pointers to CGIteration state variables.
Teuchos::RCP< const MV > R
The current residual.
Default parameters common to most Belos solvers.
static const double convTol
Default convergence tolerance.
static const double orthoKappa
DGKS orthogonalization constant.