42 #ifndef BELOS_PCPG_SOLMGR_HPP
43 #define BELOS_PCPG_SOLMGR_HPP
63 #ifdef BELOS_TEUCHOS_TIME_MONITOR
66 #if defined(HAVE_TEUCHOSCORE_CXX11)
67 # include <type_traits>
68 #endif // defined(HAVE_TEUCHOSCORE_CXX11)
137 template<
class ScalarType,
class MV,
class OP,
138 const bool supportsScalarType =
143 Belos::Details::LapackSupportsScalar<ScalarType>::value &&
144 ! Teuchos::ScalarTraits<ScalarType>::isComplex>
168 template<
class ScalarType,
class MV,
class OP>
260 return Teuchos::tuple(timerSolve_);
331 std::string description()
const;
361 static constexpr
int maxIters_default_ = 1000;
362 static constexpr
int deflatedBlocks_default_ = 2;
363 static constexpr
int savedBlocks_default_ = 16;
366 static constexpr
int outputFreq_default_ = -1;
367 static constexpr
const char * label_default_ =
"Belos";
368 static constexpr
const char * orthoType_default_ =
"ICGS";
389 int deflatedBlocks_, savedBlocks_,
verbosity_, outputStyle_, outputFreq_;
408 template<
class ScalarType,
class MV,
class OP>
410 outputStream_(Teuchos::rcpFromRef(std::cout)),
415 maxIters_(maxIters_default_),
416 deflatedBlocks_(deflatedBlocks_default_),
417 savedBlocks_(savedBlocks_default_),
418 verbosity_(verbosity_default_),
419 outputStyle_(outputStyle_default_),
420 outputFreq_(outputFreq_default_),
421 orthoType_(orthoType_default_),
423 label_(label_default_),
429 template<
class ScalarType,
class MV,
class OP>
434 outputStream_(Teuchos::rcpFromRef(std::cout)),
440 maxIters_(maxIters_default_),
441 deflatedBlocks_(deflatedBlocks_default_),
442 savedBlocks_(savedBlocks_default_),
443 verbosity_(verbosity_default_),
444 outputStyle_(outputStyle_default_),
445 outputFreq_(outputFreq_default_),
446 orthoType_(orthoType_default_),
448 label_(label_default_),
452 problem_.is_null (), std::invalid_argument,
453 "Belos::PCPGSolMgr two-argument constructor: "
454 "'problem' is null. You must supply a non-null Belos::LinearProblem "
455 "instance when calling this constructor.");
464 template<
class ScalarType,
class MV,
class OP>
477 maxIters_ = params->
get(
"Maximum Iterations",maxIters_default_);
480 params_->set(
"Maximum Iterations", maxIters_);
482 maxIterTest_->setMaxIters( maxIters_ );
487 savedBlocks_ = params->
get(
"Num Saved Blocks",savedBlocks_default_);
489 "Belos::PCPGSolMgr: \"Num Saved Blocks\" must be strictly positive.");
496 params_->set(
"Num Saved Blocks", savedBlocks_);
499 deflatedBlocks_ = params->
get(
"Num Deflated Blocks",deflatedBlocks_default_);
501 "Belos::PCPGSolMgr: \"Num Deflated Blocks\" must be positive.");
504 "Belos::PCPGSolMgr: \"Num Deflated Blocks\" must be <= \"Num Saved Blocks\".");
508 params_->set(
"Num Deflated Blocks", static_cast<int>(deflatedBlocks_));
513 std::string tempLabel = params->
get(
"Timer Label", label_default_);
516 if (tempLabel != label_) {
518 params_->set(
"Timer Label", label_);
519 std::string solveLabel = label_ +
": PCPGSolMgr total solve time";
520 #ifdef BELOS_TEUCHOS_TIME_MONITOR
524 ortho_->setLabel( label_ );
531 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
532 verbosity_ = params->
get(
"Verbosity", verbosity_default_);
534 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
538 params_->set(
"Verbosity", verbosity_);
540 printer_->setVerbosity(verbosity_);
545 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
546 outputStyle_ = params->
get(
"Output Style", outputStyle_default_);
548 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
552 params_->set(
"Output Style", outputStyle_);
558 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
561 params_->set(
"Output Stream", outputStream_);
563 printer_->setOStream( outputStream_ );
569 outputFreq_ = params->
get(
"Output Frequency", outputFreq_default_);
573 params_->set(
"Output Frequency", outputFreq_);
575 outputTest_->setOutputFrequency( outputFreq_ );
584 bool changedOrthoType =
false;
586 std::string tempOrthoType = params->
get(
"Orthogonalization",orthoType_default_);
587 if (tempOrthoType != orthoType_) {
588 orthoType_ = tempOrthoType;
589 changedOrthoType =
true;
592 params_->set(
"Orthogonalization", orthoType_);
595 if (params->
isParameter(
"Orthogonalization Constant")) {
597 orthoKappa_ = params->
get (
"Orthogonalization Constant",
601 orthoKappa_ = params->
get (
"Orthogonalization Constant",
606 params_->set(
"Orthogonalization Constant",orthoKappa_);
607 if (orthoType_==
"DGKS") {
608 if (orthoKappa_ > 0 && ortho_ !=
Teuchos::null && !changedOrthoType) {
618 if (orthoType_==
"DGKS" && orthoKappa_ > 0) {
620 paramsOrtho->
set (
"depTol", orthoKappa_ );
631 if (params->
isParameter(
"Convergence Tolerance")) {
633 convtol_ = params->
get (
"Convergence Tolerance",
641 params_->set(
"Convergence Tolerance", convtol_);
643 convTest_->setTolerance( convtol_ );
653 convTest_ =
Teuchos::rcp(
new StatusTestResNorm_t( convtol_, 1 ) );
655 sTest_ =
Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
663 std::string solverDesc =
" PCPG ";
664 outputTest_->setSolverDesc( solverDesc );
668 std::string solveLabel = label_ +
": PCPGSolMgr total solve time";
669 #ifdef BELOS_TEUCHOS_TIME_MONITOR
679 template<
class ScalarType,
class MV,
class OP>
688 "The relative residual tolerance that needs to be achieved by the\n"
689 "iterative solver in order for the linear system to be declared converged.");
690 pl->
set(
"Maximum Iterations", static_cast<int>(maxIters_default_),
691 "The maximum number of iterations allowed for each\n"
692 "set of RHS solved.");
693 pl->
set(
"Num Deflated Blocks", static_cast<int>(deflatedBlocks_default_),
694 "The maximum number of vectors in the seed subspace." );
695 pl->
set(
"Num Saved Blocks", static_cast<int>(savedBlocks_default_),
696 "The maximum number of vectors saved from old Krylov subspaces." );
697 pl->
set(
"Verbosity", static_cast<int>(verbosity_default_),
698 "What type(s) of solver information should be outputted\n"
699 "to the output stream.");
700 pl->
set(
"Output Style", static_cast<int>(outputStyle_default_),
701 "What style is used for the solver information outputted\n"
702 "to the output stream.");
703 pl->
set(
"Output Frequency", static_cast<int>(outputFreq_default_),
704 "How often convergence information should be outputted\n"
705 "to the output stream.");
706 pl->
set(
"Output Stream", Teuchos::rcpFromRef(std::cout),
707 "A reference-counted pointer to the output stream where all\n"
708 "solver output is sent.");
709 pl->
set(
"Timer Label", static_cast<const char *>(label_default_),
710 "The string to use as a prefix for the timer labels.");
711 pl->
set(
"Orthogonalization", static_cast<const char *>(orthoType_default_),
712 "The type of orthogonalization to use: DGKS, ICGS, IMGS");
714 "The constant used by DGKS orthogonalization to determine\n"
715 "whether another step of classical Gram-Schmidt is necessary.");
723 template<
class ScalarType,
class MV,
class OP>
727 if (!isSet_) { setParameters( params_ ); }
734 "Belos::PCPGSolMgr::solve(): Linear problem is not a valid object.");
737 "Belos::PCPGSolMgr::solve(): Linear problem is not ready, setProblem() has not been called.");
740 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
741 std::vector<int> currIdx(1);
747 problem_->setLSIndex( currIdx );
750 bool isConverged =
true;
755 plist.
set(
"Saved Blocks", savedBlocks_);
756 plist.
set(
"Block Size", 1);
757 plist.
set(
"Keep Diagonal",
true);
758 plist.
set(
"Initialize Diagonal",
true);
769 #ifdef BELOS_TEUCHOS_TIME_MONITOR
772 while ( numRHS2Solve > 0 ) {
775 outputTest_->reset();
779 R_ = MVT::Clone( *(problem_->getRHS()), 1 );
781 problem_->computeCurrResVec( &*R_ );
793 std::vector<MagnitudeType> rnorm0(1);
794 MVT::MvNorm( *R_, rnorm0 );
797 std::cout <<
"Solver Manager: dimU_ = " << dimU_ << std::endl;
801 std::vector<int> active_columns( dimU_ );
802 for (
int i=0; i < dimU_; ++i) active_columns[i] = i;
803 Uactive = MVT::CloneView(*U_, active_columns);
804 Cactive = MVT::CloneView(*C_, active_columns);
807 std::cout <<
" Solver Manager : check duality of seed basis " << std::endl;
809 MVT::MvTransMv( one, *Uactive, *Cactive, H );
810 H.
print( std::cout );
813 MVT::MvTransMv( one, *Uactive, *R_, Z );
815 MVT::MvTimesMatAddMv( one, *Uactive, Z, zero, *tempU );
816 MVT::MvAddMv( one, *tempU, one, *cur_soln_vec, *cur_soln_vec );
817 MVT::MvTimesMatAddMv( one, *Cactive, Z, zero, *tempU );
818 MVT::MvAddMv( -one, *tempU, one, *R_, *R_ );
819 std::vector<MagnitudeType> rnorm(1);
820 MVT::MvNorm( *R_, rnorm );
821 if( rnorm[0] < rnorm0[0] * .001 ){
822 MVT::MvTransMv( one, *Uactive, *R_, Z );
823 MVT::MvTimesMatAddMv( one, *Uactive, Z, zero, *tempU );
824 MVT::MvAddMv( one, *tempU, one, *cur_soln_vec, *cur_soln_vec );
825 MVT::MvTimesMatAddMv( one, *Cactive, Z, zero, *tempU );
826 MVT::MvAddMv( -one, *tempU, one, *R_, *R_ );
843 if( dimU_ > 0 ) pcpgState.
curDim = dimU_;
844 pcpg_iter->initialize(pcpgState);
850 if( !dimU_ ) printer_->stream(
Debug) <<
" No recycled subspace available for RHS index " << currIdx[0] << std::endl << std::endl;
851 pcpg_iter->resetNumIters();
853 if( dimU_ > savedBlocks_ )
854 std::cout <<
"Error: dimU_ = " << dimU_ <<
" > savedBlocks_ = " << savedBlocks_ << std::endl;
860 if( debug ) printf(
"********** Calling iterate...\n");
861 pcpg_iter->iterate();
868 if ( convTest_->getStatus() ==
Passed ) {
877 else if ( maxIterTest_->getStatus() ==
Passed ) {
892 "Belos::PCPGSolMgr::solve(): Invalid return from PCPGIter::iterate().");
897 achievedTol_ = MT::one();
899 MVT::MvInit( *X, SCT::zero() );
900 printer_->stream(
Warnings) <<
"Belos::PCPG::solve(): Warning! NaN has been detected!"
904 catch (
const std::exception &e) {
905 printer_->stream(
Errors) <<
"Error! Caught exception in PCPGIter::iterate() at iteration "
906 << pcpg_iter->getNumIters() << std::endl
907 << e.what() << std::endl;
914 problem_->updateSolution( update,
true );
917 problem_->setCurrLS();
925 std::cout <<
"SolverManager: dimU_ " << dimU_ <<
" prevUdim= " << q << std::endl;
927 if( q > deflatedBlocks_ )
928 std::cout <<
"SolverManager: Error deflatedBlocks = " << deflatedBlocks_ << std::endl;
939 rank = ARRQR(dimU_,q, *oldState.
D );
941 std::cout <<
" rank decreased in ARRQR, something to do? " << std::endl;
947 if( dimU_ > deflatedBlocks_ ){
949 if( !deflatedBlocks_ ){
952 dimU_ = deflatedBlocks_;
956 bool Harmonic =
false;
960 std::vector<int> active_cols( dimU_ );
961 for (
int i=0; i < dimU_; ++i) active_cols[i] = i;
964 Uorth = MVT::CloneCopy(*C_, active_cols);
967 Uorth = MVT::CloneCopy(*U_, active_cols);
972 rank = ortho_->normalize(*Uorth,
Teuchos::rcp(&R,
false));
979 "Belos::PCPGSolMgr::solve(): Failed to compute orthonormal basis for initial recycled subspace.");
988 if( problem_->isHermitian() ) lrwork = dimU_;
989 std::vector<ScalarType> work(lwork);
990 std::vector<ScalarType> Svec(dimU_);
991 std::vector<ScalarType> rwork(lrwork);
992 lapack.
GESVD(
'N',
'O',
1001 "Belos::PCPGSolMgr::solve(): LAPACK _GESVD failed to compute singular values.");
1003 if( work[0] != 67. * dimU_ )
1004 std::cout <<
" SVD " << dimU_ <<
" lwork " << work[0] << std::endl;
1005 for(
int i=0; i< dimU_; i++)
1006 std::cout << i <<
" " << Svec[i] << std::endl;
1010 int startRow = 0, startCol = 0;
1012 startCol = dimU_ - deflatedBlocks_;
1020 std::vector<int> active_columns( dimU_ );
1021 std::vector<int> def_cols( deflatedBlocks_ );
1022 for (
int i=0; i < dimU_; ++i) active_columns[i] = i;
1023 for (
int i=0; i < deflatedBlocks_; ++i) def_cols[i] = i;
1027 MVT::MvTimesMatAddMv( one, *Ucopy, V, zero, *Uactive );
1032 MVT::MvTimesMatAddMv( one, *Ccopy, V, zero, *Cactive );
1035 dimU_ = deflatedBlocks_;
1037 printer_->stream(
Debug) <<
" Generated recycled subspace using RHS index " << currIdx[0] <<
" of dimension " << dimU_ << std::endl << std::endl;
1040 problem_->setCurrLS();
1044 if ( numRHS2Solve > 0 ) {
1048 problem_->setLSIndex( currIdx );
1051 currIdx.resize( numRHS2Solve );
1060 #ifdef BELOS_TEUCHOS_TIME_MONITOR
1070 using Teuchos::rcp_dynamic_cast;
1073 const std::vector<MagnitudeType>* pTestValues =
1074 rcp_dynamic_cast<conv_test_type>(convTest_)->getTestValue();
1077 "Belos::PCPGSolMgr::solve(): The convergence test's getTestValue() "
1078 "method returned NULL. Please report this bug to the Belos developers.");
1081 "Belos::PCPGSolMgr::solve(): The convergence test's getTestValue() "
1082 "method returned a vector of length zero. Please report this bug to the "
1083 "Belos developers.");
1088 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
1092 numIters_ = maxIterTest_->getNumIters();
1103 template<
class ScalarType,
class MV,
class OP>
1114 std::vector<int> curind(1);
1115 std::vector<int> ipiv(p - q);
1116 std::vector<ScalarType> Pivots(p);
1118 ScalarType rteps = 1.5e-8;
1121 for( i = q ; i < p ; i++ ){
1124 RCP<MV> P = MVT::CloneViewNonConst(*U_,curind);
1125 RCP<MV> AP = MVT::CloneViewNonConst(*C_,curind);
1127 MVT::MvAddMv( anorm(0,0), *P, zero, *AP, *P );
1128 MVT::MvAddMv( zero, *P, anorm(0,0), *AP, *AP );
1132 for( i = q ; i < p ; i++ ){
1133 if( q < i && i < p-1 ){
1136 for( j = i+1 ; j < p ; j++ ){
1137 const int k = ipiv[j-q];
1138 if( Pivots[k] > Pivots[l] ){
1145 ipiv[imax-q] = ipiv[i-q];
1151 if( Pivots[k] > 1.5625e-2 ){
1152 anorm(0,0) = Pivots[k];
1156 RCP<const MV> P = MVT::CloneView(*U_,curind);
1157 RCP<const MV> AP = MVT::CloneView(*C_,curind);
1158 MVT::MvTransMv( one, *P, *AP, anorm );
1161 if( rteps <= anorm(0,0) && anorm(0,0) < 9.765625e-4){
1169 std::cout <<
"ARRQR: Bad case not implemented" << std::endl;
1171 if( anorm(0,0) < rteps ){
1172 std::cout <<
"ARRQR : deficient case not implemented " << std::endl;
1180 RCP<MV> P = MVT::CloneViewNonConst(*U_,curind);
1181 RCP<MV> AP = MVT::CloneViewNonConst(*C_,curind);
1182 MVT::MvAddMv( anorm(0,0), *P, zero, *AP, *P );
1183 MVT::MvAddMv( zero, *P, anorm(0,0), *AP, *AP );
1187 P = MVT::CloneViewNonConst(*U_,curind);
1188 AP = MVT::CloneViewNonConst(*C_,curind);
1189 for( j = i+1 ; j < p ; j++ ){
1192 RCP<MV> Q = MVT::CloneViewNonConst(*U_,curind);
1193 MVT::MvTransMv( one, *Q, *AP, alpha);
1194 MVT::MvAddMv( -alpha(0,0), *P, one, *Q, *Q );
1196 RCP<MV> AQ = MVT::CloneViewNonConst(*C_,curind);
1197 MVT::MvAddMv( -alpha(0,0), *AP, one, *AQ, *AQ );
1199 gamma(0,0) = ( Pivots[l] - alpha(0,0))*( Pivots[l] + alpha(0,0));
1200 if( gamma(0,0) > 0){
1212 template<
class ScalarType,
class MV,
class OP>
1215 std::ostringstream oss;
1218 oss <<
"Ortho Type='"<<orthoType_;
static const double orthoKappa
DGKS orthogonalization constant.
ScalarType * values() const
Collection of types and exceptions used within the Belos solvers.
int prevUdim
Number of block columns in matrices C and U before current iteration.
bool isLOADetected() const
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...
PCPGSolMgr(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem, const Teuchos::RCP< Teuchos::ParameterList > &pl)
Class which manages the output and verbosity of the Belos solvers.
static const bool scalarTypeIsSupported
bool is_null(const boost::shared_ptr< T > &p)
Teuchos::RCP< StatusTestOutput< ScalarType, MV, OP > > outputTest_
Belos concrete class to iterate Preconditioned Conjugate Projected Gradients.
int numIters_
Number of iterations taken by the last solve() invocation.
PCPGSolMgrOrthoFailure is thrown when the orthogonalization manager is unable to generate orthonormal...
Teuchos::RCP< MV > R
The current residual.
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)
Teuchos::RCP< MV > C
C = AU, U spans recycled subspace.
Base class for Belos::SolverManager subclasses which normally can only compile with real ScalarType t...
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
A factory class for generating StatusTestOutput objects.
virtual std::ostream & print(std::ostream &os) const
int curDim
The current dimension of the reduction.
An implementation of StatusTestResNorm using a family of residual norms.
PCPGSolMgrOrthoFailure(const std::string &what_arg)
int maxIters_
Maximum iteration count (read from parameter list).
const LinearProblem< ScalarType, MV, OP > & getProblem() const
Get current linear problem being solved for in this object.
MagnitudeType orthoKappa_
Orthogonalization parameter (read from parameter list).
Structure to contain pointers to PCPGIter state variables.
Teuchos::RCP< Teuchos::Time > timerSolve_
PCPGSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i.e.
static const double convTol
Default convergence tolerance.
Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > problem_
Belos::StatusTest class for specifying a maximum number of iterations.
Teuchos::RCP< std::ostream > outputStream_
static std::string name()
A factory class for generating StatusTestOutput objects.
Traits class which defines basic operations on multivectors.
Belos::StatusTest for logically combining several status tests.
Teuchos::RCP< const Teuchos::SerialDenseMatrix< int, ScalarType > > D
The current Hessenberg matrix.
bool isParameter(const std::string &name) const
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const
Get a parameter list containing the current parameters for this object.
OperatorTraits< ScalarType, MV, OP > OPT
A Belos::StatusTest class for specifying a maximum number of iterations.
MagnitudeType achievedTol() const
Tolerance achieved by the last solve() invocation.
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. ...
MagnitudeType convtol_
Convergence tolerance (read from parameter list).
void reset(const ResetType type)
Performs a reset of the solver manager specified by the ResetType. This informs the solver manager th...
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > sTest_
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)
MagnitudeType achievedTol_
Tolerance achieved by the last solve() invocation.
A linear system to solve, and its associated information.
MultiVecTraits< ScalarType, MV > MVT
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem)
Set the linear problem that needs to be solved.
Class which describes the linear problem to be solved by the iterative solver.
PCPGSolMgrLAPACKFailure is thrown when a nonzero value is retuned from an LAPACK call.
virtual Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const
clone for Inverted Injection (DII)
PCPGSolMgrLAPACKFailure(const std::string &what_arg)
int getNumIters() const
Get the iteration count for the most recent call to solve().
Type traits class that says whether Teuchos::LAPACK has a valid implementation for the given ScalarTy...
ReturnType
Whether the Belos solve converged for all linear systems.
void validateParameters(ParameterList const &validParamList, int const depth=1000, EValidateUsed const validateUsed=VALIDATE_USED_ENABLED, EValidateDefaults const validateDefaults=VALIDATE_DEFAULTS_ENABLED) const
Teuchos::RCP< OutputManager< ScalarType > > printer_
Teuchos::RCP< MV > U
The recycled subspace.
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
OrdinalType numCols() const
Teuchos::ScalarTraits< ScalarType >::magnitudeType MagnitudeType
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 GESVD(const char &JOBU, const char &JOBVT, const OrdinalType &m, const OrdinalType &n, ScalarType *A, const OrdinalType &lda, MagnitudeType *S, ScalarType *U, const OrdinalType &ldu, ScalarType *V, const OrdinalType &ldv, ScalarType *WORK, const OrdinalType &lwork, MagnitudeType *RWORK, OrdinalType *info) const
Teuchos::ScalarTraits< ScalarType > SCT
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
PCPG iterative linear solver.
bool isType(const std::string &name) const
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.
Teuchos::RCP< StatusTestGenResNorm< ScalarType, MV, OP > > convTest_
Teuchos::RCP< StatusTestMaxIters< ScalarType, MV, OP > > maxIterTest_
virtual ~PCPGSolMgr()
Destructor.
Class which defines basic traits for the operator type.
Parent class to all Belos exceptions.
Default parameters common to most Belos solvers.
Teuchos::RCP< MatOrthoManager< ScalarType, MV, OP > > ortho_
Details::SolverManagerRequiresRealLapack< ScalarType, MV, OP, scalarTypeIsSupported > base_type
Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const override
clone for Inverted Injection (DII)
This class implements the PCPG iteration, where a single-std::vector Krylov subspace is constructed...
Belos header file which uses auto-configuration information to include necessary C++ headers...
Teuchos::RCP< Teuchos::ParameterList > params_
PCPGSolMgrLinearProblemFailure(const std::string &what_arg)
OrdinalType numRows() const
Teuchos::ScalarTraits< MagnitudeType > MT
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.