Inheritance diagram for PyTrilinos.NOX.Abstract.Group:

Collaboration diagram for PyTrilinos.NOX.Abstract.Group:

Public Member Functions
def	__init__
def	setX
def	computeX
def	computeF
def	computeJacobian
def	computeGradient
def	computeNewton
def	applyJacobian
def	applyJacobianTranspose
def	applyJacobianInverse
def	applyRightPreconditioning
def	applyJacobianMultiVector
def	applyJacobianTransposeMultiVector
def	applyJacobianInverseMultiVector
def	applyRightPreconditioningMultiVector
def	isF
def	isJacobian
def	isGradient
def	isNewton
def	getNormF
def	getX
def	getF
def	getGradient
def	getNewton
def	getNormLastLinearSolveResidual
def	clone
Static Public Attributes
	Ok = _Abstract.Group_Ok
	NotDefined = _Abstract.Group_NotDefined
	BadDependency = _Abstract.Group_BadDependency
	NotConverged = _Abstract.Group_NotConverged
	Failed = _Abstract.Group_Failed

Detailed Description

NOX pure abstract interface to a "group"; i.e., a solution vector
and the corresponding F-vector, Jacobian matrix, gradient vector, and
Newton vector.

This class is a member of the namespace NOX::Abstract.

The user should implement their own concrete implementation of this
class or use one of the implementations provided by us. Typically the
implementation is also tied to a particular NOX::Abstract::Vector
implementation.

The group may be implemented so that multiple groups can share
underlying memory space. This is particularly important when it comes
to the Jacobian, which is often to big to be replicated for every
group. Thus, we have included instructions on how shared data should
be treated for the operator=() and clone() functions.

C++ includes: NOX_Abstract_Group.H

Member Function Documentation

def PyTrilinos.NOX.Abstract.Group.applyJacobian	(	self,
		args
	)

applyJacobian(Group self, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyJacobian(const NOX::Abstract::Vector
&input, NOX::Abstract::Vector &result) const

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.

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::BadDependency - If the Jacobian $J$ has not been
computed

NOX::Abstract::Group::Failed - If the computation fails

NOX::Abstract::Group::Ok - Otherwise

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.applyJacobianInverse	(	self,
		args
	)

applyJacobianInverse(Group self, ParameterList params, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyJacobianInverse(Teuchos::ParameterList
&params, const NOX::Abstract::Vector &input, NOX::Abstract::Vector
&result) const

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 "Tolerance" parameter specifies that the solution should be such
that \\[ \\frac{\\| J v - u \\|_2}{\\max \\{ 1,
\\|u\\|_2\\} } < \\mbox{Tolerance} \\]

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::BadDependency - If $J$ has not been computed

NOX::Abstract::Group::NotConverged - If the linear solve fails to
satisfy the "Tolerance" specified in params

NOX::Abstract::Group::Failed - If the computation fails

NOX::Abstract::Group::Ok - Otherwise

The parameter "Tolerance" may be added/modified in the list of
parameters - this is the ideal solution tolerance for an iterative
linear solve.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.applyJacobianInverseMultiVector	(	self,
		args
	)

applyJacobianInverseMultiVector(Group self, ParameterList params, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyJacobianInverseMultiVector(Teuchos::ParameterList
&params, const NOX::Abstract::MultiVector &input,
NOX::Abstract::MultiVector &result) const

applyJacobianInverse for multiple right-hand sides

The default implementation here calls applyJacobianInverse() for each
right hand side serially but should be overloaded if a block solver is
available.

def PyTrilinos.NOX.Abstract.Group.applyJacobianMultiVector	(	self,
		args
	)

applyJacobianMultiVector(Group self, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyJacobianMultiVector(const
NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result)
const

applyJacobian for multiple right-hand sides

The default implementation here calls applyJacobian() for each right
hand side serially but should be overloaded if a block method is
available.

def PyTrilinos.NOX.Abstract.Group.applyJacobianTranspose	(	self,
		args
	)

applyJacobianTranspose(Group self, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyJacobianTranspose(const
NOX::Abstract::Vector &input, NOX::Abstract::Vector &result) const

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.

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::BadDependency - If $J$ has not been computed

NOX::Abstract::Group::Failed - If the computation fails

NOX::Abstract::Group::Ok - Otherwise

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.applyJacobianTransposeMultiVector	(	self,
		args
	)

applyJacobianTransposeMultiVector(Group self, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyJacobianTransposeMultiVector(const
NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result)
const

applyJacobianTranspose for multiple right-hand sides

The default implementation here calls applyJacobianTranspose() for
each right hand side serially but should be overloaded if a block
method is available.

def PyTrilinos.NOX.Abstract.Group.applyRightPreconditioning	(	self,
		args
	)

applyRightPreconditioning(Group self, bool useTranspose, ParameterList params, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyRightPreconditioning(bool useTranspose,
Teuchos::ParameterList &params, const NOX::Abstract::Vector &input,
NOX::Abstract::Vector &result) const

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 "Tolerance" parameter specifies that the solution should be such
that \\[ \\frac{\\| M v - u \\|_2}{\\max \\{ 1,
\\|u\\|_2\\} } < \\mbox{Tolerance} \\]

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::NotConverged - If the linear solve fails to
satisfy the "Tolerance" specified in params

NOX::Abstract::Group::Failed - If the computation fails

NOX::Abstract::Group::Ok - Otherwise

The parameters are from the "Linear %Solver" sublist of the
"Direction" sublist that is passed to solver during construction.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.applyRightPreconditioningMultiVector	(	self,
		args
	)

applyRightPreconditioningMultiVector(Group self, bool useTranspose, ParameterList params, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::applyRightPreconditioningMultiVector(bool
useTranspose, Teuchos::ParameterList &params, const
NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result)
const

applyRightPreconditioning for multiple right-hand sides

The default implementation here calls applyRightPreconditioning() for
each right hand side serially but should be overloaded if a block
method is available.

def PyTrilinos.NOX.Abstract.Group.clone	(	self,
		args
	)

clone(Group self, NOX::CopyType type=DeepCopy) -> Teuchos::RCP< NOX::Abstract::Group >

virtual
Teuchos::RCP<NOX::Abstract::Group>
NOX::Abstract::Group::clone(NOX::CopyType type=NOX::DeepCopy) const =0

Create a new Group of the same derived type as this one by cloning
this one, and return a ref count pointer to the new group.

If type is NOX::DeepCopy, then we need to create an exact replica of
"this". Otherwise, if type is NOX::ShapeCopy, we need only replicate
the shape of "this" (only the memory is allocated, the values are
not copied into the vectors and Jacobian). Returns NULL if clone is
not supported.

Any shared data should have its ownership transfered to this group
from the source for a NOX::DeepCopy.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.computeF	(	self,
		args
	)

computeF(Group self) -> NOX::Abstract::Group::ReturnType

virtual
NOX::Abstract::Group::ReturnType NOX::Abstract::Group::computeF()=0

Compute and store F(x).

It's generally useful to also compute and store the 2-norm of F(x) at
this point for later access by the getNormF() function.

NOX::Abstract::Group::Failed - If the computation fails in any way

NOX::Abstract::Group::Ok - Otherwise

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.computeGradient	(	self,
		args
	)

computeGradient(Group self) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::computeGradient()

Compute and store gradient.

We can pose the nonlinear equation problem $F(x) = 0$ as an
optimization problem as follows: \\[ \\min f(x) \\equiv
\\frac{1}{2} \\|F(x)\\|_2^2. \\]

In that case, the gradient (of $f$) is defined as \\[ g \\equiv
J^T F. \\]

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::BadDependency - If either $F$ or $J$ has not
been computed

NOX::Abstract::Group::Failed - If the computation fails in any other
way

NOX::Abstract::Group::Ok - Otherwise

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.computeJacobian	(	self,
		args
	)

computeJacobian(Group self) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::computeJacobian()

Compute and store Jacobian.

Recall that \\[ F(x) = \\left[ \\begin{array}{c} F_1(x) \\\\
F_2(x) \\\\ \\vdots \\\\ F_n(x) \\\\ \\end{array}
\\right]. \\]

The Jacobian is denoted by $J$ and defined by \\[ J_{ij} =
\\frac{\\partial F_i}{\\partial x_j} (x). \\]

If this is a shared object, this group should taken ownership of the
Jacobian before it computes it.

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::Failed - If the computation fails in any other
way

NOX::Abstract::Group::Ok - Otherwise

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.computeNewton	(	self,
		args
	)

computeNewton(Group self, ParameterList params) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::computeNewton(Teuchos::ParameterList &params)

Compute the Newton direction, using parameters for the linear solve.

The Newton direction is the solution, s, of \\[ J s = -F. \\]

The parameters are from the "Linear %Solver" sublist of the
"Direction" sublist that is passed to solver during construction.

The "Tolerance" parameter may be added/modified in the sublist of
"Linear Solver" parameters that is passed into this function. The
solution should be such that \\[ \\frac{\\| J s - (-F)
\\|_2}{\\max \\{ 1, \\|F\\|_2\\} } < \\mbox{Tolerance}
\\]

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::BadDependency - If either $F$ or $J$ has not
been computed

NOX::Abstract::Group::NotConverged - If the linear solve fails to
satisfy the "Tolerance" specified in params

NOX::Abstract::Group::Failed - If the computation fails in any other
way

NOX::Abstract::Group::Ok - Otherwise

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.computeX	(	self,
		args
	)

computeX(Group self, Group grp, Vector d, double step)

virtual void
NOX::Abstract::Group::computeX(const NOX::Abstract::Group &grp, const
NOX::Abstract::Vector &d, double step)=0

Compute x = grp.x + step * d.

Let $x$ denote this group's solution vector. Let $\\hat x$ denote
the result of grp.getX(). Then set \\[ x = \\hat x +
\\mbox{step} \\; d. \\]

This should invalidate the function value, Jacobian, gradient, and
Newton direction.

Throw an error if the copy fails.

Reference to this object

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.getF	(	self,
		args
	)

getF(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >

virtual
Teuchos::RCP< const NOX::Abstract::Vector >
NOX::Abstract::Group::getFPtr() const

Return RCP to F(x)

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.getGradient	(	self,
		args
	)

getGradient(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >

virtual
Teuchos::RCP< const NOX::Abstract::Vector >
NOX::Abstract::Group::getGradientPtr() const

Return RCP to gradient.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.getNewton	(	self,
		args
	)

getNewton(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >

virtual
Teuchos::RCP< const NOX::Abstract::Vector >
NOX::Abstract::Group::getNewtonPtr() const

Return RCP to Newton direction.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.getNormF	(	self,
		args
	)

getNormF(Group self) -> double

virtual double
NOX::Abstract::Group::getNormF() const =0

Return 2-norm of F(x).

In other words, \\[ \\sqrt{\\sum_{i=1}^n F_i^2} \\]

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.getNormLastLinearSolveResidual	(	self,
		args
	)

getNormLastLinearSolveResidual(Group self, double & residual) -> NOX::Abstract::Group::ReturnType

NOX::Abstract::Group::ReturnType
NOX::Abstract::Group::getNormLastLinearSolveResidual(double &residual)
const

Return the norm of the last linear solve residual as the result of
either a call to computeNewton() or applyJacobianInverse().

NOX::Abstract::Group::NotDefined - Returned by default implementation
in NOX::Abstract::Group

NOX::Abstract::Group::BadDependency - If no linear solve has been
calculated

NOX::Abstract::Group::Failed - Any other type of failure

NOX::Abstract::Group::Ok - Otherwise

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.getX	(	self,
		args
	)

getX(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >

virtual
Teuchos::RCP< const NOX::Abstract::Vector >
NOX::Abstract::Group::getXPtr() const

Return RCP to solution vector.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.isF	(	self,
		args
	)

isF(Group self) -> bool

virtual bool
NOX::Abstract::Group::isF() const =0

Return true if F is valid.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.isGradient	(	self,
		args
	)

isGradient(Group self) -> bool

bool
NOX::Abstract::Group::isGradient() const

Return true if the gradient is valid.

Default implementation in NOX::Abstract::Group returns false.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.isJacobian	(	self,
		args
	)

isJacobian(Group self) -> bool

bool
NOX::Abstract::Group::isJacobian() const

Return true if the Jacobian is valid.

Default implementation in NOX::Abstract::Group returns false.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.isNewton	(	self,
		args
	)

isNewton(Group self) -> bool

bool
NOX::Abstract::Group::isNewton() const

Return true if the Newton direction is valid.

Default implementation in NOX::Abstract::Group returns false.

Reimplemented in PyTrilinos.NOX.Epetra.Group.

def PyTrilinos.NOX.Abstract.Group.setX	(	self,
		args
	)

setX(Group self, Vector y)

virtual void
NOX::Abstract::Group::setX(const NOX::Abstract::Vector &y)=0

Set the solution vector x to y.

This should invalidate the function value, Jacobian, gradient, and
Newton direction.

Throw an error if the copy fails.

Reference to this object

Reimplemented in PyTrilinos.NOX.Epetra.Group.

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

Abstract.py

Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation