Inheritance diagram for PyTrilinos.NOX.Epetra.LinearSystem:

Collaboration diagram for PyTrilinos.NOX.Epetra.LinearSystem:

Public Member Functions
def	__init__
def	applyJacobian
def	applyJacobianTranspose
def	applyJacobianInverse
def	applyRightPreconditioning
def	getScaling
def	resetScaling
def	computeJacobian
def	createPreconditioner
def	destroyPreconditioner
def	recomputePreconditioner
def	getPreconditionerPolicy
def	isPreconditionerConstructed
def	hasPreconditioner
def	getJacobianOperator
def	getGeneratedPrecOperator
def	setJacobianOperatorForSolve
def	setPrecOperatorForSolve
def	getNumLinearSolves
def	getLinearItersLastSolve
def	getLinearItersTotal
def	getAchievedTol
def	__disown__
Public Attributes
	this
Static Public Attributes
	PRPT_REBUILD = ___init__.LinearSystem_PRPT_REBUILD
	PRPT_RECOMPUTE = ___init__.LinearSystem_PRPT_RECOMPUTE
	PRPT_REUSE = ___init__.LinearSystem_PRPT_REUSE

Detailed Description

Pure virtual class interface for allowing different linear solvers to
be used by the NOX::Epetra::Group.

C++ includes: NOX_Epetra_LinearSystem.H

Constructor & Destructor Documentation

def PyTrilinos.NOX.Epetra.LinearSystem.__init__	(	self,
		args
	)

__init__(NOX::Epetra::LinearSystem self) -> LinearSystem

NOX::Epetra::LinearSystem::LinearSystem()

Constructor.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

Member Function Documentation

def PyTrilinos.NOX.Epetra.LinearSystem.applyJacobian	(	self,
		args
	)

applyJacobian(LinearSystem self, Vector input, Vector nox_result) -> bool

virtual bool NOX::Epetra::LinearSystem::applyJacobian(const
NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const =0

Applies Jacobian to the given input vector and puts the answer in the
result.

Computes \\[ v = J u, \\] where $J$ is the Jacobian, $u$ is the
input vector, and $v$ is the result vector. Returns true if
successful.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.applyJacobianInverse	(	self,
		args
	)

applyJacobianInverse(LinearSystem self, ParameterList params, Vector input, Vector nox_result) -> bool

virtual bool
NOX::Epetra::LinearSystem::applyJacobianInverse(Teuchos::ParameterList
&params, const NOX::Epetra::Vector &input, NOX::Epetra::Vector
&result)=0

Applies the inverse of the Jacobian matrix to the given input vector
and puts the answer in result.

Computes \\[ v = J^{-1} u, \\] where $J$ is the Jacobian, $u$ is
the input vector, and $v$ is the result vector.

The parameter list contains the linear solver options.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.applyJacobianTranspose	(	self,
		args
	)

applyJacobianTranspose(LinearSystem self, Vector input, Vector nox_result) -> bool

virtual bool
NOX::Epetra::LinearSystem::applyJacobianTranspose(const
NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const =0

Applies Jacobian-Transpose to the given input vector and puts the
answer in the result.

Computes \\[ v = J^T u, \\] where $J$ is the Jacobian, $u$ is the
input vector, and $v$ is the result vector. Returns true if
successful.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.applyRightPreconditioning	(	self,
		args
	)

applyRightPreconditioning(LinearSystem self, bool useTranspose, ParameterList params, Vector input, Vector nox_result) -> bool

virtual bool
NOX::Epetra::LinearSystem::applyRightPreconditioning(bool
useTranspose, Teuchos::ParameterList &params, const
NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const =0

Apply right preconditiong to the given input vector.

Let $M$ be a right preconditioner for the Jacobian $J$; in other
words, $M$ is a matrix such that \\[ JM \\approx I. \\]

Compute \\[ u = M^{-1} v, \\] where $u$ is the input vector and
$v$ is the result vector.

If useTranspose is true, then the transpose of the preconditioner is
applied: \\[ u = {M^{-1}}^T v, \\] The transpose preconditioner is
currently only required for Tensor methods.

The parameter list contains the linear solver options.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.computeJacobian	(	self,
		args
	)

computeJacobian(LinearSystem self, Vector x) -> bool

virtual bool NOX::Epetra::LinearSystem::computeJacobian(const
NOX::Epetra::Vector &x)=0

Evaluates the Jacobian based on the solution vector x.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.createPreconditioner	(	self,
		args
	)

createPreconditioner(LinearSystem self, Vector x, ParameterList p, bool recomputeGraph) -> bool

virtual bool NOX::Epetra::LinearSystem::createPreconditioner(const
NOX::Epetra::Vector &x, Teuchos::ParameterList &p, bool
recomputeGraph) const =0

Explicitly constructs a preconditioner based on the solution vector x
and the parameter list p.

The user has the option of recomputing the graph when a new
preconditioner is created. The NOX::Epetra::Group controls the isValid
flag for the preconditioner and will control when to call this.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.destroyPreconditioner	(	self,
		args
	)

destroyPreconditioner(LinearSystem self) -> bool

virtual bool
NOX::Epetra::LinearSystem::destroyPreconditioner() const =0

Deletes the preconditioner.

The NOX::Epetra::Group controls the isValid flag for the
preconditioner and will control when to call this.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.getAchievedTol	(	self,
		args
	)

getAchievedTol(LinearSystem self) -> double

virtual double NOX::Epetra::LinearSystem::getAchievedTol()

Statistics for the achieved tolerance of last linear solve (def: 0.0)

def PyTrilinos.NOX.Epetra.LinearSystem.getGeneratedPrecOperator	(	self,
		args
	)

getGeneratedPrecOperator(LinearSystem self) -> Teuchos::RCP< Epetra_Operator const >
getGeneratedPrecOperator(LinearSystem self) -> Teuchos::RCP< Epetra_Operator >

virtual
Teuchos::RCP<Epetra_Operator>
NOX::Epetra::LinearSystem::getGeneratedPrecOperator()=0

Return preconditioner operator.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.getJacobianOperator	(	self,
		args
	)

getJacobianOperator(LinearSystem self) -> Teuchos::RCP< Epetra_Operator const >
getJacobianOperator(LinearSystem self) -> Teuchos::RCP< Epetra_Operator >

virtual Teuchos::RCP<Epetra_Operator>
NOX::Epetra::LinearSystem::getJacobianOperator()=0

Return Jacobian operator.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.getLinearItersLastSolve	(	self,
		args
	)

getLinearItersLastSolve(LinearSystem self) -> int

virtual int
NOX::Epetra::LinearSystem::getLinearItersLastSolve()

Statistics for number of iterations taken in last linear solve (def:
0)

def PyTrilinos.NOX.Epetra.LinearSystem.getLinearItersTotal	(	self,
		args
	)

getLinearItersTotal(LinearSystem self) -> int

virtual int NOX::Epetra::LinearSystem::getLinearItersTotal()

Statistics for cumulative number of iterations in all linear solve
(def: 0)

def PyTrilinos.NOX.Epetra.LinearSystem.getNumLinearSolves	(	self,
		args
	)

getNumLinearSolves(LinearSystem self) -> int

virtual int NOX::Epetra::LinearSystem::getNumLinearSolves()

Statistics for number of times the linear solver has been called (def:
0)

def PyTrilinos.NOX.Epetra.LinearSystem.getPreconditionerPolicy	(	self,
		args
	)

getPreconditionerPolicy(LinearSystem self, bool advanceReuseCounter=True) -> NOX::Epetra::LinearSystem::PreconditionerReusePolicyType

virtual
PreconditionerReusePolicyType
NOX::Epetra::LinearSystem::getPreconditionerPolicy(bool
advanceReuseCounter=true)=0

Evaluates the preconditioner policy at the current state.

NOTE: This can change values between nonlienar iterations. It is not a
static value.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.getScaling	(	self,
		args
	)

getScaling(LinearSystem self) -> Teuchos::RCP< NOX::Epetra::Scaling >

virtual
Teuchos::RCP<NOX::Epetra::Scaling>
NOX::Epetra::LinearSystem::getScaling()=0

Get the scaling object.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.hasPreconditioner	(	self,
		args
	)

hasPreconditioner(LinearSystem self) -> bool

virtual bool NOX::Epetra::LinearSystem::hasPreconditioner() const =0

Indicates whether the linear system has a preconditioner.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.isPreconditionerConstructed	(	self,
		args
	)

isPreconditionerConstructed(LinearSystem self) -> bool

virtual bool
NOX::Epetra::LinearSystem::isPreconditionerConstructed() const =0

Indicates whether a preconditioner has been constructed.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.recomputePreconditioner	(	self,
		args
	)

recomputePreconditioner(LinearSystem self, Vector x, ParameterList linearSolverParams) -> bool

virtual bool
NOX::Epetra::LinearSystem::recomputePreconditioner(const
NOX::Epetra::Vector &x, Teuchos::ParameterList &linearSolverParams)
const =0

Recalculates the preconditioner using an already allocated graph.

Use this to compute a new preconditioner while using the same graph
for the preconditioner. This avoids deleting and reallocating the
memory required for the preconditioner and results in a big speed-up
for large-scale jobs.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.resetScaling	(	self,
		args
	)

resetScaling(LinearSystem self, Teuchos::RCP< NOX::Epetra::Scaling > const & s)

virtual void NOX::Epetra::LinearSystem::resetScaling(const
Teuchos::RCP< NOX::Epetra::Scaling > &s)=0

Sets the diagonal scaling vector(s) used in scaling the linear system.

See NOX::Epetra::Scaling for details on how to specify scaling of the
linear system.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.setJacobianOperatorForSolve	(	self,
		args
	)

setJacobianOperatorForSolve(LinearSystem self, Teuchos::RCP< Epetra_Operator const > const & solveJacOp)

virtual void
NOX::Epetra::LinearSystem::setJacobianOperatorForSolve(const
Teuchos::RCP< const Epetra_Operator > &solveJacOp)=0

Set Jacobian operator for solve.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

def PyTrilinos.NOX.Epetra.LinearSystem.setPrecOperatorForSolve	(	self,
		args
	)

setPrecOperatorForSolve(LinearSystem self, Teuchos::RCP< Epetra_Operator const > const & solvePrecOp)

virtual void
NOX::Epetra::LinearSystem::setPrecOperatorForSolve(const Teuchos::RCP<
const Epetra_Operator > &solvePrecOp)=0

Set preconditioner operator for solve.

Note: This should only be called if hasPreconditioner() returns true.

Reimplemented in PyTrilinos.NOX.Epetra.LinearSystemAztecOO.

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

NOX/Epetra/__init__.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation