Inheritance diagram for PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra:

Collaboration diagram for PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra:

Public Member Functions
def	__init__
def	getProblem
def	getNumIters
def	getTimers
def	solve
def	setGlobalStatusTest
def	getGlobalStatusTest
def	setLockingStatusTest
def	getLockingStatusTest
def	setDebugStatusTest
def	getDebugStatusTest
Public Attributes
	this

Detailed Description

The BlockDavidsonSolMgr provides a powerful solver manager over the
BlockDavidson eigensolver.

This solver manager implements a hard-locking mechanism, whereby
eigenpairs designated to be locked are moved from the eigensolver and
placed in auxilliary storage. The eigensolver is then restarted and
continues to iterate, orthogonal to the locked eigenvectors.

The solver manager provides to the solver a StatusTestCombo object
constructed as follows: combo = globaltest OR lockingtest OR debugtest
where  globaltest terminates computation when global convergence has
been detected.  It is encapsulated in a StatusTestWithOrdering object,
to ensure that computation is terminated only after the most
significant eigenvalues/eigenvectors have met the convergence
criteria.  If not specified via setGlobalStatusTest(), globaltest is a
StatusTestResNorm object which tests the M-norms of the direct
residuals relative to the Ritz values.

lockingtest halts BlockDavidson::iterate() in order to deflate
converged eigenpairs for locking.  It will query the underlying
BlockDavidson eigensolver to determine when eigenvectors should be
locked.  If not specified via setLockingStatusTest(), lockingtest is a
StatusTestResNorm object.

debugtest allows a user to specify additional monitoring of the
iteration, encapsulated in a StatusTest object  If not specified via
setDebugStatusTest(), debugtest is ignored.  In most cases, it should
return ::Failed; if it returns ::Passed, solve() will throw an
AnasaziError exception.

Additionally, the solver manager will terminate solve() after a
specified number of restarts.

Much of this behavior is controlled via parameters and options passed
to the solver manager. For more information, see
BlockDavidsonSolMgr().

Chris Baker, Ulrich Hetmaniuk, Rich Lehoucq, Heidi Thornquist

C++ includes: AnasaziBlockDavidsonSolMgr.hpp

Constructor & Destructor Documentation

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.__init__	(	self,
		args
	)

__init__(Anasazi::BlockDavidsonSolMgr<(double,Epetra_MultiVector,Epetra_Operator)> self, Teuchos::RCP< Anasazi::Eigenproblem< double,Epetra_MultiVector,Epetra_Operator > > const & problem, 
    ParameterList pl) -> BlockDavidsonSolMgrEpetra

Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP
>::BlockDavidsonSolMgr(const Teuchos::RCP< Eigenproblem< ScalarType,
MV, OP > > &problem, Teuchos::ParameterList &pl)

Basic constructor for BlockDavidsonSolMgr.

This constructor accepts the Eigenproblem to be solved in addition to
a parameter list of options for the solver manager. These options
include the following: Solver parameters  "Which" - a string
specifying the desired eigenvalues: SM, LM, SR or LR. Default: "SR"

"Block Size" - a int specifying the block size to be used by the
underlying block Davidson solver. Default: problem->getNEV()

"Num Blocks" - a int specifying the number of blocks allocated for
the Krylov basis. Default: 2

"Maximum Restarts" - a int specifying the maximum number of restarts
the underlying solver is allowed to perform. Default: 20

"Verbosity" - a sum of MsgType specifying the verbosity. Default:
::Errors

Convergence parameters (if using default convergence test; see
setGlobalStatusTest())  "Convergence Tolerance" - a MagnitudeType
specifying the level that residual norms must reach to decide
convergence. Default: machine precision.

"Relative Convergence Tolerance" - a bool specifying whether
residuals norms should be scaled by their eigenvalues for the
purposing of deciding convergence. Default: true

"Convergence Norm" - a string specifying the norm for convergence
testing: "2" or "M"

Locking parameters (if using default locking test; see
setLockingStatusTest())  "Use Locking" - a bool specifying whether
the algorithm should employ locking of converged eigenpairs. Default:
false

"Max Locked" - a int specifying the maximum number of eigenpairs to
be locked. Default: problem->getNEV()

"Locking Quorum" - a int specifying the number of eigenpairs that
must meet the locking criteria before locking actually occurs.
Default: 1

"Locking Tolerance" - a MagnitudeType specifying the level that
residual norms must reach to decide locking. Default: 0.1*convergence
tolerance

"Relative Locking Tolerance" - a bool specifying whether residuals
norms should be scaled by their eigenvalues for the purposing of
deciding locking. Default: true

"Locking Norm" - a string specifying the norm for locking testing:
"2" or "M"

Member Function Documentation

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.getDebugStatusTest	(	self,
		args
	)

getDebugStatusTest(BlockDavidsonSolMgrEpetra self) -> Teuchos::RCP< Anasazi::StatusTest< double,Epetra_MultiVector,Epetra_Operator > > const &

const Teuchos::RCP<
StatusTest< ScalarType, MV, OP > > & Anasazi::BlockDavidsonSolMgr<
ScalarType, MV, OP >::getDebugStatusTest() const

Get the status test for debugging.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.getGlobalStatusTest	(	self,
		args
	)

getGlobalStatusTest(BlockDavidsonSolMgrEpetra self) -> Teuchos::RCP< Anasazi::StatusTest< double,Epetra_MultiVector,Epetra_Operator > > const &

const
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > &
Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP
>::getGlobalStatusTest() const

Get the status test defining global convergence.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.getLockingStatusTest	(	self,
		args
	)

getLockingStatusTest(BlockDavidsonSolMgrEpetra self) -> Teuchos::RCP< Anasazi::StatusTest< double,Epetra_MultiVector,Epetra_Operator > > const &

const
Teuchos::RCP< StatusTest< ScalarType, MV, OP > > &
Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP
>::getLockingStatusTest() const

Get the status test defining locking.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.getNumIters	(	self,
		args
	)

getNumIters(BlockDavidsonSolMgrEpetra self) -> int

int
Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP >::getNumIters()
const

Get the iteration count for the most recent call to  solve().

Reimplemented from PyTrilinos.Anasazi.SolverManagerEpetra.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.getProblem	(	self,
		args
	)

getProblem(BlockDavidsonSolMgrEpetra self) -> EigenproblemEpetra

const Eigenproblem<ScalarType,MV,OP>& Anasazi::BlockDavidsonSolMgr<
ScalarType, MV, OP >::getProblem() const

Return the eigenvalue problem.

Reimplemented from PyTrilinos.Anasazi.SolverManagerEpetra.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.getTimers	(	self,
		args
	)

getTimers(BlockDavidsonSolMgrEpetra self) -> Teuchos::Array< Teuchos::RCP< Teuchos::Time > >

Teuchos::Array<Teuchos::RCP<Teuchos::Time> >
Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP >::getTimers() const

Return the timers for this object.

The timers are ordered as follows: time spent in solve() routine

time spent restarting

time spent locking converged eigenvectors

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.setDebugStatusTest	(	self,
		args
	)

setDebugStatusTest(BlockDavidsonSolMgrEpetra self, Teuchos::RCP< Anasazi::StatusTest< double,Epetra_MultiVector,Epetra_Operator > > const & debug)

void
Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP
>::setDebugStatusTest(const Teuchos::RCP< StatusTest< ScalarType, MV,
OP > > &debug)

Set the status test for debugging.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.setGlobalStatusTest	(	self,
		args
	)

setGlobalStatusTest(BlockDavidsonSolMgrEpetra self, Teuchos::RCP< Anasazi::StatusTest< double,Epetra_MultiVector,Epetra_Operator > > const & _global)

void
Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP
>::setGlobalStatusTest(const Teuchos::RCP< StatusTest< ScalarType, MV,
OP > > &global)

Set the status test defining global convergence.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.setLockingStatusTest	(	self,
		args
	)

setLockingStatusTest(BlockDavidsonSolMgrEpetra self, Teuchos::RCP< Anasazi::StatusTest< double,Epetra_MultiVector,Epetra_Operator > > const & locking)

void
Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP
>::setLockingStatusTest(const Teuchos::RCP< StatusTest< ScalarType,
MV, OP > > &locking)

Set the status test defining locking.

def PyTrilinos.Anasazi.BlockDavidsonSolMgrEpetra.solve	(	self,
		args
	)

solve(BlockDavidsonSolMgrEpetra self) -> Anasazi::ReturnType

ReturnType Anasazi::BlockDavidsonSolMgr< ScalarType, MV, OP >::solve()

This method performs possibly repeated calls to the underlying
eigensolver's iterate() routine until the problem has been solved (as
decided by the solver manager) or the solver manager decides to quit.

This method calls BlockDavidson::iterate(), which will return either
because a specially constructed status test evaluates to ::Passed or
an exception is thrown.

A return from BlockDavidson::iterate() signifies one of the following
scenarios: the maximum number of restarts has been exceeded. In this
scenario, the solver manager will place  all converged eigenpairs into
the eigenproblem and return ::Unconverged.

the locking conditions have been met. In this scenario, some of the
current eigenpairs will be removed  from the eigensolver and placed
into auxiliary storage. The eigensolver will be restarted with the
remaining part of the Krylov subspace  and some random information to
replace the removed subspace.

global convergence has been met. In this case, the most significant
NEV eigenpairs in the solver and locked storage  have met the
convergence criterion. (Here, NEV refers to the number of eigenpairs
requested by the Eigenproblem.)  In this scenario, the solver manager
will return ::Converged.

::ReturnType specifying: ::Converged: the eigenproblem was solved to
the specification required by the solver manager.

::Unconverged: the eigenproblem was not solved to the specification
desired by the solver manager.

Reimplemented from PyTrilinos.Anasazi.SolverManagerEpetra.

The documentation for this class was generated from the following file:

Anasazi.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation