42 #ifndef BELOS_BLOCK_CG_SOLMGR_HPP 43 #define BELOS_BLOCK_CG_SOLMGR_HPP 65 #include "Teuchos_BLAS.hpp" 66 #include "Teuchos_LAPACK.hpp" 67 #ifdef BELOS_TEUCHOS_TIME_MONITOR 68 # include "Teuchos_TimeMonitor.hpp" 70 #if defined(HAVE_TEUCHOSCORE_CXX11) 71 # include <type_traits> 72 #endif // defined(HAVE_TEUCHOSCORE_CXX11) 117 template<
class ScalarType,
class MV,
class OP,
118 const bool lapackSupportsScalarType =
133 const Teuchos::RCP<Teuchos::ParameterList>& pl) :
143 template<
class ScalarType,
class MV,
class OP>
170 typedef Teuchos::ScalarTraits<ScalarType>
SCT;
171 typedef typename Teuchos::ScalarTraits<ScalarType>::magnitudeType
MagnitudeType;
172 typedef Teuchos::ScalarTraits<MagnitudeType>
MT;
221 const Teuchos::RCP<Teuchos::ParameterList> &pl );
236 Teuchos::RCP<const Teuchos::ParameterList> getValidParameters()
const;
247 Teuchos::Array<Teuchos::RCP<Teuchos::Time> >
getTimers()
const {
248 return Teuchos::tuple(timerSolve_);
278 void setParameters(
const Teuchos::RCP<Teuchos::ParameterList> ¶ms );
319 std::string description()
const;
326 Teuchos::RCP<LinearProblem<ScalarType,MV,OP> >
problem_;
337 Teuchos::RCP<StatusTest<ScalarType,MV,OP> >
sTest_;
343 Teuchos::RCP<StatusTestGenResNorm<ScalarType,MV,OP> >
convTest_;
349 Teuchos::RCP<MatOrthoManager<ScalarType,MV,OP> >
ortho_;
409 template<
class ScalarType,
class MV,
class OP>
412 template<
class ScalarType,
class MV,
class OP>
415 template<
class ScalarType,
class MV,
class OP>
418 template<
class ScalarType,
class MV,
class OP>
421 template<
class ScalarType,
class MV,
class OP>
424 template<
class ScalarType,
class MV,
class OP>
427 template<
class ScalarType,
class MV,
class OP>
430 template<
class ScalarType,
class MV,
class OP>
433 template<
class ScalarType,
class MV,
class OP>
436 template<
class ScalarType,
class MV,
class OP>
439 template<
class ScalarType,
class MV,
class OP>
442 template<
class ScalarType,
class MV,
class OP>
447 template<
class ScalarType,
class MV,
class OP>
449 outputStream_(outputStream_default_),
450 convtol_(convtol_default_),
451 orthoKappa_(orthoKappa_default_),
453 maxIters_(maxIters_default_),
455 blockSize_(blockSize_default_),
456 verbosity_(verbosity_default_),
457 outputStyle_(outputStyle_default_),
458 outputFreq_(outputFreq_default_),
459 adaptiveBlockSize_(adaptiveBlockSize_default_),
460 showMaxResNormOnly_(showMaxResNormOnly_default_),
461 orthoType_(orthoType_default_),
462 label_(label_default_),
468 template<
class ScalarType,
class MV,
class OP>
471 const Teuchos::RCP<Teuchos::ParameterList> &pl) :
473 outputStream_(outputStream_default_),
474 convtol_(convtol_default_),
475 orthoKappa_(orthoKappa_default_),
477 maxIters_(maxIters_default_),
479 blockSize_(blockSize_default_),
480 verbosity_(verbosity_default_),
481 outputStyle_(outputStyle_default_),
482 outputFreq_(outputFreq_default_),
483 adaptiveBlockSize_(adaptiveBlockSize_default_),
484 showMaxResNormOnly_(showMaxResNormOnly_default_),
485 orthoType_(orthoType_default_),
486 label_(label_default_),
489 TEUCHOS_TEST_FOR_EXCEPTION(problem_.is_null(), std::invalid_argument,
490 "BlockCGSolMgr's constructor requires a nonnull LinearProblem instance.");
495 if (! pl.is_null()) {
500 template<
class ScalarType,
class MV,
class OP>
506 if (params_ == Teuchos::null) {
507 params_ = Teuchos::rcp(
new Teuchos::ParameterList(*getValidParameters()) );
510 params->validateParameters(*getValidParameters());
514 if (params->isParameter(
"Maximum Iterations")) {
515 maxIters_ = params->get(
"Maximum Iterations",maxIters_default_);
518 params_->set(
"Maximum Iterations", maxIters_);
519 if (maxIterTest_!=Teuchos::null)
520 maxIterTest_->setMaxIters( maxIters_ );
524 if (params->isParameter(
"Block Size")) {
525 blockSize_ = params->get(
"Block Size",blockSize_default_);
526 TEUCHOS_TEST_FOR_EXCEPTION(blockSize_ <= 0, std::invalid_argument,
527 "Belos::BlockCGSolMgr: \"Block Size\" must be strictly positive.");
530 params_->set(
"Block Size", blockSize_);
534 if (params->isParameter(
"Adaptive Block Size")) {
535 adaptiveBlockSize_ = params->get(
"Adaptive Block Size",adaptiveBlockSize_default_);
538 params_->set(
"Adaptive Block Size", adaptiveBlockSize_);
542 if (params->isParameter(
"Timer Label")) {
543 std::string tempLabel = params->get(
"Timer Label", label_default_);
546 if (tempLabel != label_) {
548 params_->set(
"Timer Label", label_);
549 std::string solveLabel = label_ +
": BlockCGSolMgr total solve time";
550 #ifdef BELOS_TEUCHOS_TIME_MONITOR 551 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
553 if (ortho_ != Teuchos::null) {
554 ortho_->setLabel( label_ );
560 if (params->isParameter(
"Orthogonalization")) {
561 std::string tempOrthoType = params->get(
"Orthogonalization",orthoType_default_);
562 TEUCHOS_TEST_FOR_EXCEPTION( tempOrthoType !=
"DGKS" && tempOrthoType !=
"ICGS" && tempOrthoType !=
"IMGS",
563 std::invalid_argument,
564 "Belos::BlockCGSolMgr: \"Orthogonalization\" must be either \"DGKS\", \"ICGS\", or \"IMGS\".");
565 if (tempOrthoType != orthoType_) {
566 orthoType_ = tempOrthoType;
568 if (orthoType_==
"DGKS") {
569 if (orthoKappa_ <= 0) {
577 else if (orthoType_==
"ICGS") {
580 else if (orthoType_==
"IMGS") {
587 if (params->isParameter(
"Orthogonalization Constant")) {
588 orthoKappa_ = params->get(
"Orthogonalization Constant",orthoKappa_default_);
591 params_->set(
"Orthogonalization Constant",orthoKappa_);
592 if (orthoType_==
"DGKS") {
593 if (orthoKappa_ > 0 && ortho_ != Teuchos::null) {
600 if (params->isParameter(
"Verbosity")) {
601 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
602 verbosity_ = params->get(
"Verbosity", verbosity_default_);
604 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
608 params_->set(
"Verbosity", verbosity_);
609 if (printer_ != Teuchos::null)
610 printer_->setVerbosity(verbosity_);
614 if (params->isParameter(
"Output Style")) {
615 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
616 outputStyle_ = params->get(
"Output Style", outputStyle_default_);
618 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
622 params_->set(
"Output Style", outputStyle_);
623 outputTest_ = Teuchos::null;
627 if (params->isParameter(
"Output Stream")) {
628 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
631 params_->set(
"Output Stream", outputStream_);
632 if (printer_ != Teuchos::null)
633 printer_->setOStream( outputStream_ );
638 if (params->isParameter(
"Output Frequency")) {
639 outputFreq_ = params->get(
"Output Frequency", outputFreq_default_);
643 params_->set(
"Output Frequency", outputFreq_);
644 if (outputTest_ != Teuchos::null)
645 outputTest_->setOutputFrequency( outputFreq_ );
649 if (printer_ == Teuchos::null) {
658 if (params->isParameter(
"Convergence Tolerance")) {
659 convtol_ = params->get(
"Convergence Tolerance",convtol_default_);
662 params_->set(
"Convergence Tolerance", convtol_);
663 if (convTest_ != Teuchos::null)
667 if (params->isParameter(
"Show Maximum Residual Norm Only")) {
668 showMaxResNormOnly_ = Teuchos::getParameter<bool>(*params,
"Show Maximum Residual Norm Only");
671 params_->set(
"Show Maximum Residual Norm Only", showMaxResNormOnly_);
672 if (convTest_ != Teuchos::null)
673 convTest_->setShowMaxResNormOnly( showMaxResNormOnly_ );
679 if (maxIterTest_ == Teuchos::null)
683 if (convTest_ == Teuchos::null)
684 convTest_ = Teuchos::rcp(
new StatusTestResNorm_t( convtol_, 1 ) );
686 if (sTest_ == Teuchos::null)
687 sTest_ = Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
689 if (outputTest_ == Teuchos::null) {
697 std::string solverDesc =
" Block CG ";
698 outputTest_->setSolverDesc( solverDesc );
703 if (ortho_ == Teuchos::null) {
704 if (orthoType_==
"DGKS") {
705 if (orthoKappa_ <= 0) {
713 else if (orthoType_==
"ICGS") {
716 else if (orthoType_==
"IMGS") {
720 TEUCHOS_TEST_FOR_EXCEPTION(orthoType_!=
"ICGS"&&orthoType_!=
"DGKS"&&orthoType_!=
"IMGS",std::logic_error,
721 "Belos::BlockCGSolMgr(): Invalid orthogonalization type.");
726 if (timerSolve_ == Teuchos::null) {
727 std::string solveLabel = label_ +
": BlockCGSolMgr total solve time";
728 #ifdef BELOS_TEUCHOS_TIME_MONITOR 729 timerSolve_ = Teuchos::TimeMonitor::getNewCounter(solveLabel);
738 template<
class ScalarType,
class MV,
class OP>
739 Teuchos::RCP<const Teuchos::ParameterList>
742 static Teuchos::RCP<const Teuchos::ParameterList> validPL;
745 if(is_null(validPL)) {
746 Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
747 pl->set(
"Convergence Tolerance", convtol_default_,
748 "The relative residual tolerance that needs to be achieved by the\n" 749 "iterative solver in order for the linear system to be declared converged.");
750 pl->set(
"Maximum Iterations", maxIters_default_,
751 "The maximum number of block iterations allowed for each\n" 752 "set of RHS solved.");
753 pl->set(
"Block Size", blockSize_default_,
754 "The number of vectors in each block.");
755 pl->set(
"Adaptive Block Size", adaptiveBlockSize_default_,
756 "Whether the solver manager should adapt to the block size\n" 757 "based on the number of RHS to solve.");
758 pl->set(
"Verbosity", verbosity_default_,
759 "What type(s) of solver information should be outputted\n" 760 "to the output stream.");
761 pl->set(
"Output Style", outputStyle_default_,
762 "What style is used for the solver information outputted\n" 763 "to the output stream.");
764 pl->set(
"Output Frequency", outputFreq_default_,
765 "How often convergence information should be outputted\n" 766 "to the output stream.");
767 pl->set(
"Output Stream", outputStream_default_,
768 "A reference-counted pointer to the output stream where all\n" 769 "solver output is sent.");
770 pl->set(
"Show Maximum Residual Norm Only", showMaxResNormOnly_default_,
771 "When convergence information is printed, only show the maximum\n" 772 "relative residual norm when the block size is greater than one.");
773 pl->set(
"Timer Label", label_default_,
774 "The string to use as a prefix for the timer labels.");
776 pl->set(
"Orthogonalization", orthoType_default_,
777 "The type of orthogonalization to use: DGKS, ICGS, or IMGS.");
778 pl->set(
"Orthogonalization Constant",orthoKappa_default_,
779 "The constant used by DGKS orthogonalization to determine\n" 780 "whether another step of classical Gram-Schmidt is necessary.");
788 template<
class ScalarType,
class MV,
class OP>
792 using Teuchos::rcp_const_cast;
793 using Teuchos::rcp_dynamic_cast;
800 setParameters(Teuchos::parameterList(*getValidParameters()));
803 Teuchos::BLAS<int,ScalarType> blas;
804 Teuchos::LAPACK<int,ScalarType> lapack;
806 TEUCHOS_TEST_FOR_EXCEPTION( !problem_->isProblemSet(),
808 "Belos::BlockCGSolMgr::solve(): Linear problem is not ready, setProblem() " 809 "has not been called.");
813 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
814 int numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
816 std::vector<int> currIdx, currIdx2;
821 if ( adaptiveBlockSize_ ) {
822 blockSize_ = numCurrRHS;
823 currIdx.resize( numCurrRHS );
824 currIdx2.resize( numCurrRHS );
825 for (
int i=0; i<numCurrRHS; ++i)
826 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
830 currIdx.resize( blockSize_ );
831 currIdx2.resize( blockSize_ );
832 for (
int i=0; i<numCurrRHS; ++i)
833 { currIdx[i] = startPtr+i; currIdx2[i]=i; }
834 for (
int i=numCurrRHS; i<blockSize_; ++i)
835 { currIdx[i] = -1; currIdx2[i] = i; }
839 problem_->setLSIndex( currIdx );
843 Teuchos::ParameterList plist;
844 plist.set(
"Block Size",blockSize_);
847 outputTest_->reset();
851 bool isConverged =
true;
856 RCP<CGIteration<ScalarType,MV,OP> > block_cg_iter;
857 if (blockSize_ == 1) {
862 outputTest_, plist));
872 #ifdef BELOS_TEUCHOS_TIME_MONITOR 873 Teuchos::TimeMonitor slvtimer(*timerSolve_);
876 while ( numRHS2Solve > 0 ) {
879 std::vector<int> convRHSIdx;
880 std::vector<int> currRHSIdx( currIdx );
881 currRHSIdx.resize(numCurrRHS);
884 block_cg_iter->resetNumIters();
887 outputTest_->resetNumCalls();
890 RCP<MV> R_0 = MVT::CloneViewNonConst( *(rcp_const_cast<MV>(problem_->getInitResVec())), currIdx );
895 block_cg_iter->initializeCG(newstate);
901 block_cg_iter->iterate();
905 if (convTest_->getStatus() ==
Passed) {
910 std::vector<int> convIdx =
911 rcp_dynamic_cast<conv_test_type>(convTest_)->convIndices();
916 if (convIdx.size() == currRHSIdx.size())
921 problem_->setCurrLS();
926 std::vector<int> unconvIdx(currRHSIdx.size());
927 for (
unsigned int i=0; i<currRHSIdx.size(); ++i) {
929 for (
unsigned int j=0; j<convIdx.size(); ++j) {
930 if (currRHSIdx[i] == convIdx[j]) {
936 currIdx2[have] = currIdx2[i];
937 currRHSIdx[have++] = currRHSIdx[i];
942 currRHSIdx.resize(have);
943 currIdx2.resize(have);
946 problem_->setLSIndex( currRHSIdx );
949 std::vector<MagnitudeType> norms;
950 R_0 = MVT::CloneCopy( *(block_cg_iter->getNativeResiduals(&norms)),currIdx2 );
951 for (
int i=0; i<have; ++i) { currIdx2[i] = i; }
954 block_cg_iter->setBlockSize( have );
959 block_cg_iter->initializeCG(defstate);
965 else if (maxIterTest_->getStatus() ==
Passed) {
974 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
975 "Belos::BlockCGSolMgr::solve(): Neither the convergence test nor " 976 "the maximum iteration count test passed. Please report this bug " 977 "to the Belos developers.");
980 catch (
const std::exception &e) {
981 std::ostream& err = printer_->stream (
Errors);
982 err <<
"Error! Caught std::exception in CGIteration::iterate() at " 983 <<
"iteration " << block_cg_iter->getNumIters() << std::endl
984 << e.what() << std::endl;
991 problem_->setCurrLS();
994 startPtr += numCurrRHS;
995 numRHS2Solve -= numCurrRHS;
996 if ( numRHS2Solve > 0 ) {
997 numCurrRHS = ( numRHS2Solve < blockSize_) ? numRHS2Solve : blockSize_;
999 if ( adaptiveBlockSize_ ) {
1000 blockSize_ = numCurrRHS;
1001 currIdx.resize( numCurrRHS );
1002 currIdx2.resize( numCurrRHS );
1003 for (
int i=0; i<numCurrRHS; ++i)
1004 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
1007 currIdx.resize( blockSize_ );
1008 currIdx2.resize( blockSize_ );
1009 for (
int i=0; i<numCurrRHS; ++i)
1010 { currIdx[i] = startPtr+i; currIdx2[i] = i; }
1011 for (
int i=numCurrRHS; i<blockSize_; ++i)
1012 { currIdx[i] = -1; currIdx2[i] = i; }
1015 problem_->setLSIndex( currIdx );
1018 block_cg_iter->setBlockSize( blockSize_ );
1021 currIdx.resize( numRHS2Solve );
1032 #ifdef BELOS_TEUCHOS_TIME_MONITOR 1038 Teuchos::TimeMonitor::summarize( printer_->stream(
TimingDetails) );
1043 numIters_ = maxIterTest_->getNumIters();
1049 const std::vector<MagnitudeType>* pTestValues =
1050 rcp_dynamic_cast<conv_test_type>(convTest_)->getTestValue();
1052 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues == NULL, std::logic_error,
1053 "Belos::BlockCGSolMgr::solve(): The convergence test's getTestValue() " 1054 "method returned NULL. Please report this bug to the Belos developers.");
1056 TEUCHOS_TEST_FOR_EXCEPTION(pTestValues->size() < 1, std::logic_error,
1057 "Belos::BlockCGSolMgr::solve(): The convergence test's getTestValue() " 1058 "method returned a vector of length zero. Please report this bug to the " 1059 "Belos developers.");
1064 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
1074 template<
class ScalarType,
class MV,
class OP>
1077 std::ostringstream oss;
1078 oss <<
"Belos::BlockCGSolMgr<...,"<<Teuchos::ScalarTraits<ScalarType>::name()<<
">";
1080 oss <<
"Ortho Type='"<<orthoType_<<
"\', Block Size=" << blockSize_;
Teuchos::RCP< const MV > R
The current residual.
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem)
Set the linear problem that needs to be solved.
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...
int maxIters_
Maximum iteration count (read from parameter list).
static const std::string orthoType_default_
Class which manages the output and verbosity of the Belos solvers.
int getNumIters() const
Get the iteration count for the most recent call to solve().
bool isSet_
Whether or not the parameters have been set (via setParameters()).
Teuchos::RCP< Teuchos::ParameterList > params_
Current parameter list.
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
static const bool adaptiveBlockSize_default_
Teuchos::RCP< StatusTestOutput< ScalarType, MV, OP > > outputTest_
Output "status test" that controls all the other status tests.
Teuchos::ScalarTraits< ScalarType > SCT
MagnitudeType achievedTol() const
Tolerance achieved by the last solve() invocation.
const LinearProblem< ScalarType, MV, OP > & getProblem() const
Return a reference to the linear problem being solved by this solver manager.
This class implements the preconditioned Conjugate Gradient (CG) iteration.
Structure to contain pointers to CGIteration state variables.
Belos concrete class for performing the conjugate-gradient (CG) iteration.
A factory class for generating StatusTestOutput objects.
Belos concrete class for performing the block conjugate-gradient (CG) iteration.
An implementation of StatusTestResNorm using a family of residual norms.
std::string label_
Prefix label for all the timers.
The Belos::BlockCGSolMgr provides a powerful and fully-featured solver manager over the CG and BlockC...
Belos::StatusTest class for specifying a maximum number of iterations.
BlockCGSolMgrLinearProblemFailure(const std::string &what_arg)
BlockCGSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i.e.
static const std::string label_default_
A factory class for generating StatusTestOutput objects.
Teuchos::RCP< MatOrthoManager< ScalarType, MV, OP > > ortho_
Orthogonalization manager.
Iterated Modified Gram-Schmidt (IMGS) implementation of the Belos::OrthoManager class.
static const int blockSize_default_
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const
Get a parameter list containing the current parameters for this object.
BlockCGSolMgr(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem, const Teuchos::RCP< Teuchos::ParameterList > &pl)
Teuchos::RCP< StatusTestMaxIters< ScalarType, MV, OP > > maxIterTest_
Maximum iteration count stopping criterion.
static const MagnitudeType convtol_default_
Traits class which defines basic operations on multivectors.
Belos::StatusTest for logically combining several status tests.
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > sTest_
Aggregate stopping criterion.
Details::SolverManagerRequiresLapack< ScalarType, MV, OP, requiresLapack > base_type
virtual ~BlockCGSolMgr()
Destructor.
Classical Gram-Schmidt (with DGKS correction) implementation of the Belos::OrthoManager class...
OperatorTraits< ScalarType, MV, OP > OPT
MultiVecTraits< ScalarType, MV > MVT
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. ...
static const int maxIters_default_
A linear system to solve, and its associated information.
static const int verbosity_default_
Class which describes the linear problem to be solved by the iterative solver.
MagnitudeType achievedTol_
Tolerance achieved by the last solve() invocation.
BlockCGSolMgrOrthoFailure is thrown when the orthogonalization manager is unable to generate orthonor...
Type traits class that says whether Teuchos::LAPACK has a valid implementation for the given ScalarTy...
bool isLOADetected() const
Return whether a loss of accuracy was detected by this solver during the most current solve...
Teuchos::ScalarTraits< ScalarType >::magnitudeType MagnitudeType
static const int outputFreq_default_
ReturnType
Whether the Belos solve converged for all linear systems.
Teuchos::RCP< StatusTestGenResNorm< ScalarType, MV, OP > > convTest_
Convergence stopping criterion.
Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > problem_
The linear problem to solve.
Iterated Classical Gram-Schmidt (ICGS) implementation of the Belos::OrthoManager class.
An implementation of the Belos::MatOrthoManager that performs orthogonalization using multiple steps ...
BlockCGSolMgrOrthoFailure(const std::string &what_arg)
An implementation of the Belos::MatOrthoManager that performs orthogonalization using multiple steps ...
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.
static const MagnitudeType orthoKappa_default_
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
MagnitudeType convtol_
Convergence tolerance (read from parameter list).
Teuchos::RCP< Teuchos::Time > timerSolve_
Solve timer.
An implementation of the Belos::MatOrthoManager that performs orthogonalization using (potentially) m...
A class for extending the status testing capabilities of Belos via logical combinations.
Class which defines basic traits for the operator type.
Parent class to all Belos exceptions.
static const bool showMaxResNormOnly_default_
Teuchos::RCP< OutputManager< ScalarType > > printer_
Output manager, that handles printing of different kinds of messages.
Base class for Belos::SolverManager subclasses which normally can only compile with ScalarType types ...
Belos header file which uses auto-configuration information to include necessary C++ headers...
int numIters_
Number of iterations taken by the last solve() invocation.
static const Teuchos::RCP< std::ostream > outputStream_default_
Teuchos::ScalarTraits< MagnitudeType > MT
void reset(const ResetType type)
Performs a reset of the solver manager specified by the ResetType. This informs the solver manager th...
static const int outputStyle_default_
static const bool requiresLapack
Teuchos::RCP< std::ostream > outputStream_
Output stream to which the output manager prints.
MagnitudeType orthoKappa_
Orthogonalization parameter (read from parameter list).
Stub implementation of BlockCGIter, for ScalarType types for which Teuchos::LAPACK does NOT have a va...