PyTrilinos::NOX::Abstract::Group Class Reference

Inheritance diagram for PyTrilinos::NOX::Abstract::Group:

Inheritance graph
[legend]
Collaboration diagram for PyTrilinos::NOX::Abstract::Group:

Collaboration graph
[legend]

List of all members.

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 getX
def getF
def getNormF
def getGradient
def getNewton
def getNormLastLinearSolveResidual
def clone
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 getX
def getF
def getNormF
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(self, Vector input, Vector result) -> 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 

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

applyJacobian(self, Vector input, Vector result) -> 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 

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

applyJacobianInverse(self, ParameterList params, Vector input, Vector result) -> 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. 

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

applyJacobianInverse(self, ParameterList params, Vector input, Vector result) -> 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. 

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

applyJacobianInverseMultiVector(self, ParameterList params, MultiVector input, MultiVector result) -> 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::applyJacobianInverseMultiVector (   self,
  args 
)

applyJacobianInverseMultiVector(self, ParameterList params, MultiVector input, MultiVector result) -> 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(self, MultiVector input, MultiVector result) -> 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::applyJacobianMultiVector (   self,
  args 
)

applyJacobianMultiVector(self, MultiVector input, MultiVector result) -> 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(self, Vector input, Vector result) -> 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 

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

applyJacobianTranspose(self, Vector input, Vector result) -> 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 

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

applyJacobianTransposeMultiVector(self, MultiVector input, MultiVector result) -> 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::applyJacobianTransposeMultiVector (   self,
  args 
)

applyJacobianTransposeMultiVector(self, MultiVector input, MultiVector result) -> 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(self, bool useTranspose, ParameterList params, Vector input, 
    Vector result) -> 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. 

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

applyRightPreconditioning(self, bool useTranspose, ParameterList params, Vector input, 
    Vector result) -> 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. 

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

applyRightPreconditioningMultiVector(self, bool useTranspose, ParameterList params, MultiVector input, 
    MultiVector result) -> 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::applyRightPreconditioningMultiVector (   self,
  args 
)

applyRightPreconditioningMultiVector(self, bool useTranspose, ParameterList params, MultiVector input, 
    MultiVector result) -> 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(self, 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. 

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

clone(self, 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. 

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

computeF(self) -> 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 

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

computeF(self) -> 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 

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

computeGradient(self) -> 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 

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

computeGradient(self) -> 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 

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

computeJacobian(self) -> 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 

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

computeJacobian(self) -> 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 

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

computeNewton(self, ParameterList params) -> 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 

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

computeNewton(self, ParameterList params) -> 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 

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

computeX(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 

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

computeX(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 

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

getF(self) -> Vector

virtual const
NOX::Abstract::Vector& NOX::Abstract::Group::getF() const =0

Return F(x). 

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

getF(self) -> Vector

virtual const
NOX::Abstract::Vector& NOX::Abstract::Group::getF() const =0

Return F(x). 

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

getGradient(self) -> Vector

virtual
const NOX::Abstract::Vector& NOX::Abstract::Group::getGradient() const
=0

Return gradient. 

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

getGradient(self) -> Vector

virtual
const NOX::Abstract::Vector& NOX::Abstract::Group::getGradient() const
=0

Return gradient. 

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

getNewton(self) -> Vector

virtual const
NOX::Abstract::Vector& NOX::Abstract::Group::getNewton() const =0

Return Newton direction. 

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

getNewton(self) -> Vector

virtual const
NOX::Abstract::Vector& NOX::Abstract::Group::getNewton() const =0

Return Newton direction. 

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

getNormF(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} \\] 

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

getNormF(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} \\] 

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

getNormLastLinearSolveResidual(self, double residual) -> 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 

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

getNormLastLinearSolveResidual(self, double residual) -> 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 

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

getX(self) -> Vector

virtual const
NOX::Abstract::Vector& NOX::Abstract::Group::getX() const =0

Return solution vector. 

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

getX(self) -> Vector

virtual const
NOX::Abstract::Vector& NOX::Abstract::Group::getX() const =0

Return solution vector. 

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

isF(self) -> bool

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

Return true if F is valid. 

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

isF(self) -> bool

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

Return true if F is valid. 

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

isGradient(self) -> bool

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

Return true if the gradient is valid.

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

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

isGradient(self) -> bool

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

Return true if the gradient is valid.

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

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

isJacobian(self) -> bool

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

Return true if the Jacobian is valid.

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

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

isJacobian(self) -> bool

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

Return true if the Jacobian is valid.

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

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

isNewton(self) -> bool

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

Return true if the Newton direction is valid.

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

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

isNewton(self) -> bool

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

Return true if the Newton direction is valid.

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

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

setX(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 

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

setX(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 


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

Generated on Thu Dec 17 11:00:22 2009 for PyTrilinos by  doxygen 1.5.9