42 #ifndef BELOS_PSEUDO_BLOCK_TFQMR_SOLMGR_HPP
43 #define BELOS_PSEUDO_BLOCK_TFQMR_SOLMGR_HPP
61 #ifdef BELOS_TEUCHOS_TIME_MONITOR
93 template<
class ScalarType,
class MV,
class OP>
291 template<
class ScalarType,
class MV,
class OP>
293 outputStream_(Teuchos::rcpFromRef(std::cout)),
296 achievedTol_(Teuchos::ScalarTraits<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>::zero()),
297 maxIters_(maxIters_default_),
299 verbosity_(verbosity_default_),
300 outputStyle_(outputStyle_default_),
301 outputFreq_(outputFreq_default_),
302 defQuorum_(defQuorum_default_),
303 expResTest_(expResTest_default_),
304 impResScale_(impResScale_default_),
305 expResScale_(expResScale_default_),
306 label_(label_default_),
313 template<
class ScalarType,
class MV,
class OP>
318 outputStream_(Teuchos::rcpFromRef(std::cout)),
321 achievedTol_(Teuchos::ScalarTraits<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType>::zero()),
322 maxIters_(maxIters_default_),
324 verbosity_(verbosity_default_),
325 outputStyle_(outputStyle_default_),
326 outputFreq_(outputFreq_default_),
327 defQuorum_(defQuorum_default_),
328 expResTest_(expResTest_default_),
329 impResScale_(impResScale_default_),
330 expResScale_(expResScale_default_),
331 label_(label_default_),
343 template<
class ScalarType,
class MV,
class OP>
356 maxIters_ = params->
get(
"Maximum Iterations",maxIters_default_);
359 params_->set(
"Maximum Iterations", maxIters_);
361 maxIterTest_->setMaxIters( maxIters_ );
366 std::string tempLabel = params->
get(
"Timer Label", label_default_);
369 if (tempLabel != label_) {
371 params_->set(
"Timer Label", label_);
372 std::string solveLabel = label_ +
": PseudoBlockTFQMRSolMgr total solve time";
373 #ifdef BELOS_TEUCHOS_TIME_MONITOR
381 if (Teuchos::isParameterType<int>(*params,
"Verbosity")) {
382 verbosity_ = params->
get(
"Verbosity", verbosity_default_);
384 verbosity_ = (int)Teuchos::getParameter<Belos::MsgType>(*params,
"Verbosity");
388 params_->set(
"Verbosity", verbosity_);
390 printer_->setVerbosity(verbosity_);
395 if (Teuchos::isParameterType<int>(*params,
"Output Style")) {
396 outputStyle_ = params->
get(
"Output Style", outputStyle_default_);
398 outputStyle_ = (int)Teuchos::getParameter<Belos::OutputType>(*params,
"Output Style");
402 params_->set(
"Output Style", outputStyle_);
408 outputStream_ = Teuchos::getParameter<Teuchos::RCP<std::ostream> >(*params,
"Output Stream");
411 params_->set(
"Output Stream", outputStream_);
413 printer_->setOStream( outputStream_ );
419 outputFreq_ = params->
get(
"Output Frequency", outputFreq_default_);
423 params_->set(
"Output Frequency", outputFreq_);
425 outputTest_->setOutputFrequency( outputFreq_ );
434 if (params->
isParameter(
"Convergence Tolerance")) {
436 convtol_ = params->
get (
"Convergence Tolerance",
444 params_->set(
"Convergence Tolerance", convtol_);
448 if (params->
isParameter(
"Implicit Tolerance Scale Factor")) {
450 impTolScale_ = params->
get (
"Implicit Tolerance Scale Factor",
455 impTolScale_ = params->
get (
"Implicit Tolerance Scale Factor",
460 params_->set(
"Implicit Tolerance Scale Factor", impTolScale_);
464 if (params->
isParameter(
"Implicit Residual Scaling")) {
465 std::string tempImpResScale = Teuchos::getParameter<std::string>( *params,
"Implicit Residual Scaling" );
468 if (impResScale_ != tempImpResScale) {
469 impResScale_ = tempImpResScale;
472 params_->set(
"Implicit Residual Scaling", impResScale_);
477 if (params->
isParameter(
"Explicit Residual Scaling")) {
478 std::string tempExpResScale = Teuchos::getParameter<std::string>( *params,
"Explicit Residual Scaling" );
481 if (expResScale_ != tempExpResScale) {
482 expResScale_ = tempExpResScale;
485 params_->set(
"Explicit Residual Scaling", expResScale_);
490 if (params->
isParameter(
"Explicit Residual Test")) {
491 expResTest_ = Teuchos::getParameter<bool>( *params,
"Explicit Residual Test" );
494 params_->set(
"Explicit Residual Test", expResTest_);
502 defQuorum_ = params->
get(
"Deflation Quorum", defQuorum_);
503 params_->set (
"Deflation Quorum", defQuorum_);
504 if (! impConvTest_.is_null ()) {
505 impConvTest_->setQuorum (defQuorum_);
507 if (! expConvTest_.is_null ()) {
508 expConvTest_->setQuorum (defQuorum_);
514 std::string solveLabel = label_ +
": PseudoBlockTFQMRSolMgr total solve time";
515 #ifdef BELOS_TEUCHOS_TIME_MONITOR
526 template<
class ScalarType,
class MV,
class OP>
539 Teuchos::rcp(
new StatusTestGenResNorm_t( impTolScale_*convtol_, defQuorum_ ) );
541 impConvTest_ = tmpImpConvTest;
545 Teuchos::rcp(
new StatusTestGenResNorm_t( convtol_, defQuorum_ ) );
546 tmpExpConvTest->defineResForm( StatusTestGenResNorm_t::Explicit,
Belos::TwoNorm );
548 expConvTest_ = tmpExpConvTest;
551 convTest_ =
Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::SEQ, impConvTest_, expConvTest_ ) );
557 Teuchos::rcp(
new StatusTestGenResNorm_t( convtol_, defQuorum_ ) );
559 impConvTest_ = tmpImpConvTest;
562 expConvTest_ = impConvTest_;
563 convTest_ = impConvTest_;
565 sTest_ =
Teuchos::rcp(
new StatusTestCombo_t( StatusTestCombo_t::OR, maxIterTest_, convTest_ ) );
573 std::string solverDesc =
" Pseudo Block TFQMR ";
574 outputTest_->setSolverDesc( solverDesc );
584 template<
class ScalarType,
class MV,
class OP>
597 "The relative residual tolerance that needs to be achieved by the\n"
598 "iterative solver in order for the linear system to be declared converged.");
600 "The scale factor used by the implicit residual test when explicit residual\n"
601 "testing is used. May enable faster convergence when TFQMR bound is too loose.");
602 pl->
set(
"Maximum Iterations", static_cast<int>(maxIters_default_),
603 "The maximum number of block iterations allowed for each\n"
604 "set of RHS solved.");
605 pl->
set(
"Verbosity", static_cast<int>(verbosity_default_),
606 "What type(s) of solver information should be outputted\n"
607 "to the output stream.");
608 pl->
set(
"Output Style", static_cast<int>(outputStyle_default_),
609 "What style is used for the solver information outputted\n"
610 "to the output stream.");
611 pl->
set(
"Output Frequency", static_cast<int>(outputFreq_default_),
612 "How often convergence information should be outputted\n"
613 "to the output stream.");
614 pl->
set(
"Deflation Quorum", static_cast<int>(defQuorum_default_),
615 "The number of linear systems that need to converge before they are deflated.");
616 pl->
set(
"Output Stream", Teuchos::rcpFromRef(std::cout),
617 "A reference-counted pointer to the output stream where all\n"
618 "solver output is sent.");
619 pl->
set(
"Explicit Residual Test", static_cast<bool>(expResTest_default_),
620 "Whether the explicitly computed residual should be used in the convergence test.");
621 pl->
set(
"Implicit Residual Scaling", static_cast<const char *>(impResScale_default_),
622 "The type of scaling used in the implicit residual convergence test.");
623 pl->
set(
"Explicit Residual Scaling", static_cast<const char *>(expResScale_default_),
624 "The type of scaling used in the explicit residual convergence test.");
625 pl->
set(
"Timer Label", static_cast<const char *>(label_default_),
626 "The string to use as a prefix for the timer labels.");
634 template<
class ScalarType,
class MV,
class OP>
641 setParameters(Teuchos::parameterList(*getValidParameters()));
645 "Belos::PseudoBlockTFQMRSolMgr::solve(): Linear problem is not a valid object.");
648 "Belos::PseudoBlockTFQMRSolMgr::solve(): Linear problem is not ready, setProblem() has not been called.");
652 "Belos::PseudoBlockTFQMRSolMgr::solve(): Linear problem and requested status tests are incompatible.");
657 int numRHS2Solve = MVT::GetNumberVecs( *(problem_->getRHS()) );
658 int numCurrRHS = numRHS2Solve;
660 std::vector<int> currIdx( numRHS2Solve );
661 for (
int i=0; i<numRHS2Solve; ++i) {
662 currIdx[i] = startPtr+i;
666 problem_->setLSIndex( currIdx );
673 outputTest_->reset();
676 bool isConverged =
true;
686 #ifdef BELOS_TEUCHOS_TIME_MONITOR
690 while ( numRHS2Solve > 0 ) {
693 std::vector<int> convRHSIdx;
694 std::vector<int> currRHSIdx( currIdx );
695 currRHSIdx.resize(numCurrRHS);
698 block_tfqmr_iter->resetNumIters();
701 outputTest_->resetNumCalls();
704 Teuchos::RCP<MV> R_0 = MVT::CloneViewNonConst( *(Teuchos::rcp_const_cast<MV>(problem_->getInitPrecResVec())), currIdx );
709 block_tfqmr_iter->initializeTFQMR(newstate);
715 block_tfqmr_iter->iterate();
722 if ( convTest_->getStatus() ==
Passed ) {
725 std::vector<int> convIdx = expConvTest_->convIndices();
729 if (convIdx.size() == currRHSIdx.size())
733 problem_->updateSolution( block_tfqmr_iter->getCurrentUpdate(), true );
736 problem_->setCurrLS();
740 std::vector<int> unconvIdx( currRHSIdx.size() );
741 for (
unsigned int i=0; i<currRHSIdx.size(); ++i) {
743 for (
unsigned int j=0; j<convIdx.size(); ++j) {
744 if (currRHSIdx[i] == convIdx[j]) {
751 currRHSIdx[have++] = currRHSIdx[i];
754 unconvIdx.resize(have);
755 currRHSIdx.resize(have);
758 problem_->setLSIndex( currRHSIdx );
768 defstate.
Rtilde = MVT::CloneView( *currentState.
Rtilde, unconvIdx);
769 defstate.
U = MVT::CloneView( *currentState.
U, unconvIdx );
770 defstate.
AU = MVT::CloneView( *currentState.
AU, unconvIdx );
771 defstate.
V = MVT::CloneView( *currentState.
V, unconvIdx );
772 defstate.
W = MVT::CloneView( *currentState.
W, unconvIdx );
773 defstate.
D = MVT::CloneView( *currentState.
D, unconvIdx );
776 for (std::vector<int>::iterator uIter = unconvIdx.begin(); uIter != unconvIdx.end(); uIter++)
778 defstate.
alpha.push_back( currentState.
alpha[ *uIter ] );
779 defstate.
eta.push_back( currentState.
eta[ *uIter ] );
780 defstate.
rho.push_back( currentState.
rho[ *uIter ] );
781 defstate.
tau.push_back( currentState.
tau[ *uIter ] );
782 defstate.
theta.push_back( currentState.
theta[ *uIter ] );
785 block_tfqmr_iter->initializeTFQMR(defstate);
792 else if ( maxIterTest_->getStatus() ==
Passed ) {
807 "Belos::PseudoBlockTFQMRSolMgr::solve(): Invalid return from PseudoBlockTFQMRIter::iterate().");
812 achievedTol_ = MT::one();
814 MVT::MvInit( *X, SCT::zero() );
815 printer_->stream(
Warnings) <<
"Belos::PseudoBlockTFQMRSolMgr::solve(): Warning! NaN has been detected!"
819 catch (
const std::exception &e) {
820 printer_->stream(
Errors) <<
"Error! Caught std::exception in PseudoBlockTFQMRIter::iterate() at iteration "
821 << block_tfqmr_iter->getNumIters() << std::endl
822 << e.what() << std::endl;
828 problem_->updateSolution( block_tfqmr_iter->getCurrentUpdate(), true );
831 problem_->setCurrLS();
834 startPtr += numCurrRHS;
835 numRHS2Solve -= numCurrRHS;
836 if ( numRHS2Solve > 0 ) {
837 numCurrRHS = numRHS2Solve;
838 currIdx.resize( numCurrRHS );
839 for (
int i=0; i<numCurrRHS; ++i)
840 { currIdx[i] = startPtr+i; }
843 if (defQuorum_ > numCurrRHS) {
845 impConvTest_->setQuorum( numCurrRHS );
847 expConvTest_->setQuorum( numCurrRHS );
851 problem_->setLSIndex( currIdx );
854 currIdx.resize( numRHS2Solve );
865 #ifdef BELOS_TEUCHOS_TIME_MONITOR
874 numIters_ = maxIterTest_->getNumIters();
887 const std::vector<MagnitudeType>* pTestValues = NULL;
889 pTestValues = expConvTest_->getTestValue();
890 if (pTestValues == NULL || pTestValues->size() < 1) {
891 pTestValues = impConvTest_->getTestValue();
896 pTestValues = impConvTest_->getTestValue();
899 "Belos::PseudoBlockTFQMRSolMgr::solve(): The implicit convergence test's "
900 "getTestValue() method returned NULL. Please report this bug to the "
901 "Belos developers.");
903 "Belos::TMQMRSolMgr::solve(): The implicit convergence test's "
904 "getTestValue() method returned a vector of length zero. Please report "
905 "this bug to the Belos developers.");
910 achievedTol_ = *std::max_element (pTestValues->begin(), pTestValues->end());
920 template<
class ScalarType,
class MV,
class OP>
923 std::ostringstream oss;
ScaleType convertStringToScaleType(const std::string &scaleType)
Convert the given string to its ScaleType enum value.
static constexpr const char * expResScale_default_
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...
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 manages the output and verbosity of the Belos solvers.
Teuchos::RCP< std::ostream > outputStream_
bool is_null(const boost::shared_ptr< T > &p)
Teuchos::RCP< const MV > Rtilde
This class implements the preconditioned transpose-free QMR algorithm for solving non-Hermitian linea...
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > convTest_
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)
Structure to contain pointers to PseudoBlockTFQMRIter state variables.
bool is_null(const std::shared_ptr< T > &p)
Teuchos::RCP< Teuchos::Time > timerSolve_
Teuchos::RCP< StatusTestGenResNorm< ScalarType, MV, OP > > impConvTest_
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
A factory class for generating StatusTestOutput objects.
MultiVecTraits< ScalarType, MV > MVT
Belos concrete class for generating iterations with the preconditioned tranpose-free QMR (TFQMR) meth...
Teuchos::RCP< SolverManager< ScalarType, MV, OP > > clone() const override
clone for Inverted Injection (DII)
static constexpr int defQuorum_default_
An implementation of StatusTestResNorm using a family of residual norms.
static constexpr int verbosity_default_
Teuchos::RCP< const MV > AU
static constexpr int outputStyle_default_
PseudoBlockTFQMRSolMgrLinearProblemFailure(const std::string &what_arg)
static const double convTol
Default convergence tolerance.
Belos::StatusTest class for specifying a maximum number of iterations.
std::vector< ScalarType > alpha
MagnitudeType impTolScale_
static std::string name()
const LinearProblem< ScalarType, MV, OP > & getProblem() const override
Return a reference to the linear problem being solved by this solver manager.
A factory class for generating StatusTestOutput objects.
Traits class which defines basic operations on multivectors.
Belos::StatusTest for logically combining several status tests.
bool isParameter(const std::string &name) const
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > sTest_
A Belos::StatusTest class for specifying a maximum number of iterations.
PseudoBlockTFQMRSolMgr()
Empty constructor for PseudoBlockTFQMRSolMgr. This constructor takes no arguments and sets the defaul...
PseudoBlockTFQMRSolMgrLinearProblemFailure is thrown when the linear problem is not setup (i...
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. ...
bool isLOADetected() const override
Whether loss of accuracy was detected during the last solve() invocation.
static const double impTolScale
"Implicit Tolerance Scale Factor"
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const override
Get a parameter list containing the valid parameters for this object.
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)
static constexpr const char * impResScale_default_
std::string description() const override
Method to return description of the pseudo-block TFQMR solver manager.
OperatorTraits< ScalarType, MV, OP > OPT
ReturnType solve() override
This method performs possibly repeated calls to the underlying linear solver's iterate() routine unti...
Teuchos::ScalarTraits< ScalarType > SCT
A linear system to solve, and its associated information.
std::vector< MagnitudeType > theta
Class which describes the linear problem to be solved by the iterative solver.
static constexpr bool expResTest_default_
The Belos::PseudoBlockTFQMRSolMgr provides a powerful and fully-featured solver manager over the pseu...
Teuchos::RCP< const MV > D
ReturnType
Whether the Belos solve converged for all linear systems.
std::vector< ScalarType > eta
Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > problem_
void setProblem(const Teuchos::RCP< LinearProblem< ScalarType, MV, OP > > &problem) override
Set the linear problem that needs to be solved.
int getNumIters() const override
Get the iteration count for the most recent call to solve().
The Belos::SolverManager is a templated virtual base class that defines the basic interface that any ...
Teuchos::RCP< const MV > U
void validateParameters(ParameterList const &validParamList, int const depth=1000, EValidateUsed const validateUsed=VALIDATE_USED_ENABLED, EValidateDefaults const validateDefaults=VALIDATE_DEFAULTS_ENABLED) const
Teuchos::RCP< StatusTestGenResNorm< ScalarType, MV, OP > > expConvTest_
MagnitudeType achievedTol() const override
Tolerance achieved by the last solve() invocation.
Teuchos::Array< Teuchos::RCP< Teuchos::Time > > getTimers() const
Return the timers for this object.
Teuchos::RCP< Teuchos::ParameterList > params_
std::vector< MagnitudeType > tau
Teuchos::RCP< const Teuchos::ParameterList > getCurrentParameters() const override
Get a parameter list containing the current parameters for this object.
static constexpr int outputFreq_default_
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.
Teuchos::RCP< StatusTestOutput< ScalarType, MV, OP > > outputTest_
Belos::StatusTestResNorm for specifying general residual norm stopping criteria.
Teuchos::RCP< const MV > W
The current residual basis.
bool isType(const std::string &name) const
static constexpr const char * label_default_
A class for extending the status testing capabilities of Belos via logical combinations.
virtual ~PseudoBlockTFQMRSolMgr()
Destructor.
std::vector< ScalarType > rho
Class which defines basic traits for the operator type.
Parent class to all Belos exceptions.
Teuchos::RCP< OutputManager< ScalarType > > printer_
Default parameters common to most Belos solvers.
Teuchos::ScalarTraits< MagnitudeType > MT
MagnitudeType achievedTol_
Teuchos::ScalarTraits< ScalarType >::magnitudeType MagnitudeType
Belos header file which uses auto-configuration information to include necessary C++ headers...
Teuchos::RCP< const MV > V
static constexpr int maxIters_default_
void setParameters(const Teuchos::RCP< Teuchos::ParameterList > ¶ms) override
Set the parameters the solver manager should use to solve the linear problem.
Teuchos::RCP< StatusTestMaxIters< ScalarType, MV, OP > > maxIterTest_