Concrete implementation of NOX::Abstract::Group for Trilinos/Epetra. This group is set up to use the linear algebra services provided through the Trilinos/Epetra package with AztecOO for the linear solver. C++ includes: NOX_Epetra_Group.H
def PyTrilinos::NOX::Epetra::Group::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, ParameterList printingParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> i, Vector initialGuess) -> Group __init__(self, ParameterList printingParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> i, Vector initialGuess, Teuchos::RCP<(NOX::Epetra::LinearSystem)> linSys) -> Group __init__(self, Group source, CopyType type = DeepCopy) -> Group Group::Group(const NOX::Epetra::Group &source, NOX::CopyType type=NOX::DeepCopy) Copy constructor. If type is DeepCopy, takes ownership of valid shared linear system.
def PyTrilinos::NOX::Epetra::Group::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, ParameterList printingParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> i, Vector initialGuess) -> Group __init__(self, ParameterList printingParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> i, Vector initialGuess, Teuchos::RCP<(NOX::Epetra::LinearSystem)> linSys) -> Group __init__(self, Group source, CopyType type = DeepCopy) -> Group Group::Group(const NOX::Epetra::Group &source, NOX::CopyType type=NOX::DeepCopy) Copy constructor. If type is DeepCopy, takes ownership of valid shared linear system.
def PyTrilinos::NOX::Epetra::Group::applyJacobian | ( | self, | ||
args | ||||
) |
applyJacobian(self, Vector input, Vector result) -> ReturnType applyJacobian(self, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::applyJacobian | ( | self, | ||
args | ||||
) |
applyJacobian(self, Vector input, Vector result) -> ReturnType applyJacobian(self, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::applyJacobianInverse | ( | self, | ||
args | ||||
) |
applyJacobianInverse(self, ParameterList params, Vector input, Vector result) -> ReturnType applyJacobianInverse(self, ParameterList params, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType Group::applyJacobianInverse(Teuchos::ParameterList ¶ms, 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::Epetra::Group::applyJacobianInverse | ( | self, | ||
args | ||||
) |
applyJacobianInverse(self, ParameterList params, Vector input, Vector result) -> ReturnType applyJacobianInverse(self, ParameterList params, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType Group::applyJacobianInverse(Teuchos::ParameterList ¶ms, 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::Epetra::Group::applyJacobianTranspose | ( | self, | ||
args | ||||
) |
applyJacobianTranspose(self, Vector input, Vector result) -> ReturnType applyJacobianTranspose(self, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::applyJacobianTranspose | ( | self, | ||
args | ||||
) |
applyJacobianTranspose(self, Vector input, Vector result) -> ReturnType applyJacobianTranspose(self, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::applyRightPreconditioning | ( | self, | ||
args | ||||
) |
applyRightPreconditioning(self, bool useTranspose, ParameterList params, Vector input, Vector result) -> ReturnType applyRightPreconditioning(self, bool useTranspose, ParameterList params, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType Group::applyRightPreconditioning(bool useTranspose, Teuchos::ParameterList ¶ms, 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::Epetra::Group::applyRightPreconditioning | ( | self, | ||
args | ||||
) |
applyRightPreconditioning(self, bool useTranspose, ParameterList params, Vector input, Vector result) -> ReturnType applyRightPreconditioning(self, bool useTranspose, ParameterList params, Vector input, Vector result) -> ReturnType Abstract::Group::ReturnType Group::applyRightPreconditioning(bool useTranspose, Teuchos::ParameterList ¶ms, 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::Epetra::Group::clone | ( | self, | ||
args | ||||
) |
clone(self, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::Group)> Teuchos::RCP< NOX::Abstract::Group > Group::clone(CopyType type=DeepCopy) const 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::Epetra::Group::clone | ( | self, | ||
args | ||||
) |
clone(self, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::Group)> Teuchos::RCP< NOX::Abstract::Group > Group::clone(CopyType type=DeepCopy) const 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::Epetra::Group::computeF | ( | self, | ||
args | ||||
) |
computeF(self) -> ReturnType Abstract::Group::ReturnType Group::computeF() 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::Epetra::Group::computeF | ( | self, | ||
args | ||||
) |
computeF(self) -> ReturnType Abstract::Group::ReturnType Group::computeF() 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::Epetra::Group::computeGradient | ( | self, | ||
args | ||||
) |
computeGradient(self) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::computeGradient | ( | self, | ||
args | ||||
) |
computeGradient(self) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::computeJacobian | ( | self, | ||
args | ||||
) |
computeJacobian(self) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::computeJacobian | ( | self, | ||
args | ||||
) |
computeJacobian(self) -> ReturnType Abstract::Group::ReturnType 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::Epetra::Group::computeJacobianConditionNumber | ( | self, | ||
args | ||||
) |
computeJacobianConditionNumber(self, int maxIters, double tolerance, int krylovSubspaceSize = 100, bool printOutput = False) -> ReturnType Abstract::Group::ReturnType NOX::Epetra::Group::computeJacobianConditionNumber(int maxIters, double tolerance, int krylovSubspaceSize=100, bool printOutput=false)
def PyTrilinos::NOX::Epetra::Group::computeJacobianConditionNumber | ( | self, | ||
args | ||||
) |
computeJacobianConditionNumber(self, int maxIters, double tolerance, int krylovSubspaceSize = 100, bool printOutput = False) -> ReturnType Abstract::Group::ReturnType NOX::Epetra::Group::computeJacobianConditionNumber(int maxIters, double tolerance, int krylovSubspaceSize=100, bool printOutput=false)
def PyTrilinos::NOX::Epetra::Group::computeNewton | ( | self, | ||
args | ||||
) |
computeNewton(self, ParameterList params) -> ReturnType Abstract::Group::ReturnType Group::computeNewton(Teuchos::ParameterList ¶ms) 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::Epetra::Group::computeNewton | ( | self, | ||
args | ||||
) |
computeNewton(self, ParameterList params) -> ReturnType Abstract::Group::ReturnType Group::computeNewton(Teuchos::ParameterList ¶ms) 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::Epetra::Group::computeX | ( | self, | ||
args | ||||
) |
computeX(self, Group grp, Vector d, double step) computeX(self, Group grp, Vector d, double step) void Group::computeX(const NOX::Abstract::Group &grp, const NOX::Abstract::Vector &d, double step) 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::Epetra::Group::computeX | ( | self, | ||
args | ||||
) |
computeX(self, Group grp, Vector d, double step) computeX(self, Group grp, Vector d, double step) void Group::computeX(const NOX::Abstract::Group &grp, const NOX::Abstract::Vector &d, double step) 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::Epetra::Group::getF | ( | self, | ||
args | ||||
) |
getF(self) -> Vector const Abstract::Vector & Group::getF() const Return F(x).
def PyTrilinos::NOX::Epetra::Group::getF | ( | self, | ||
args | ||||
) |
getF(self) -> Vector const Abstract::Vector & Group::getF() const Return F(x).
def PyTrilinos::NOX::Epetra::Group::getGradient | ( | self, | ||
args | ||||
) |
getGradient(self) -> Vector const Abstract::Vector & Group::getGradient() const Return gradient.
def PyTrilinos::NOX::Epetra::Group::getGradient | ( | self, | ||
args | ||||
) |
getGradient(self) -> Vector const Abstract::Vector & Group::getGradient() const Return gradient.
def PyTrilinos::NOX::Epetra::Group::getJacobianConditionNumber | ( | self, | ||
args | ||||
) |
getJacobianConditionNumber(self) -> double double NOX::Epetra::Group::getJacobianConditionNumber() const Returns the condition number of the Jacobian matrix.
def PyTrilinos::NOX::Epetra::Group::getJacobianConditionNumber | ( | self, | ||
args | ||||
) |
getJacobianConditionNumber(self) -> double double NOX::Epetra::Group::getJacobianConditionNumber() const Returns the condition number of the Jacobian matrix.
def PyTrilinos::NOX::Epetra::Group::getLinearSystem | ( | self, | ||
args | ||||
) |
getLinearSystem(self) -> Teuchos::RCP<(q(const).NOX::Epetra::LinearSystem)> getLinearSystem(self) -> Teuchos::RCP<(NOX::Epetra::LinearSystem)> Teuchos::RCP< NOX::Epetra::LinearSystem > Group::getLinearSystem() Return the Linear System.
def PyTrilinos::NOX::Epetra::Group::getLinearSystem | ( | self, | ||
args | ||||
) |
getLinearSystem(self) -> Teuchos::RCP<(q(const).NOX::Epetra::LinearSystem)> getLinearSystem(self) -> Teuchos::RCP<(NOX::Epetra::LinearSystem)> Teuchos::RCP< NOX::Epetra::LinearSystem > Group::getLinearSystem() Return the Linear System.
def PyTrilinos::NOX::Epetra::Group::getNewton | ( | self, | ||
args | ||||
) |
getNewton(self) -> Vector const Abstract::Vector & Group::getNewton() const Return Newton direction.
def PyTrilinos::NOX::Epetra::Group::getNewton | ( | self, | ||
args | ||||
) |
getNewton(self) -> Vector const Abstract::Vector & Group::getNewton() const Return Newton direction.
def PyTrilinos::NOX::Epetra::Group::getNormF | ( | self, | ||
args | ||||
) |
getNormF(self) -> double double Group::getNormF() const Return 2-norm of F(x). In other words, \\[ \\sqrt{\\sum_{i=1}^n F_i^2} \\]
def PyTrilinos::NOX::Epetra::Group::getNormF | ( | self, | ||
args | ||||
) |
getNormF(self) -> double double Group::getNormF() const Return 2-norm of F(x). In other words, \\[ \\sqrt{\\sum_{i=1}^n F_i^2} \\]
def PyTrilinos::NOX::Epetra::Group::getNormLastLinearSolveResidual | ( | self, | ||
args | ||||
) |
getNormLastLinearSolveResidual(self, double residual) -> ReturnType Abstract::Group::ReturnType NOX::Epetra::Group::getNormLastLinearSolveResidual(double &residual) const Returns the 2-norm of the residual of the linear model used in the Newton solve computation, ||Js+f||. This does not account for line search adjustments to the step length!
def PyTrilinos::NOX::Epetra::Group::getNormLastLinearSolveResidual | ( | self, | ||
args | ||||
) |
getNormLastLinearSolveResidual(self, double residual) -> ReturnType Abstract::Group::ReturnType NOX::Epetra::Group::getNormLastLinearSolveResidual(double &residual) const Returns the 2-norm of the residual of the linear model used in the Newton solve computation, ||Js+f||. This does not account for line search adjustments to the step length!
def PyTrilinos::NOX::Epetra::Group::getRequiredInterface | ( | self, | ||
args | ||||
) |
getRequiredInterface(self) -> Teuchos::RCP<(NOX::Epetra::Interface::Required)> Teuchos::RCP< NOX::Epetra::Interface::Required > Group::getRequiredInterface() Return the userInterface.
def PyTrilinos::NOX::Epetra::Group::getRequiredInterface | ( | self, | ||
args | ||||
) |
getRequiredInterface(self) -> Teuchos::RCP<(NOX::Epetra::Interface::Required)> Teuchos::RCP< NOX::Epetra::Interface::Required > Group::getRequiredInterface() Return the userInterface.
def PyTrilinos::NOX::Epetra::Group::getX | ( | self, | ||
args | ||||
) |
getX(self) -> Vector const Abstract::Vector & Group::getX() const Return solution vector.
def PyTrilinos::NOX::Epetra::Group::getX | ( | self, | ||
args | ||||
) |
getX(self) -> Vector const Abstract::Vector & Group::getX() const Return solution vector.
def PyTrilinos::NOX::Epetra::Group::isConditionNumber | ( | self, | ||
args | ||||
) |
isConditionNumber(self) -> bool bool Group::isConditionNumber() const Returns true if the condition number has been computed.
def PyTrilinos::NOX::Epetra::Group::isConditionNumber | ( | self, | ||
args | ||||
) |
isConditionNumber(self) -> bool bool Group::isConditionNumber() const Returns true if the condition number has been computed.
def PyTrilinos::NOX::Epetra::Group::isF | ( | self, | ||
args | ||||
) |
isF(self) -> bool bool Group::isF() const Return true if F is valid.
def PyTrilinos::NOX::Epetra::Group::isF | ( | self, | ||
args | ||||
) |
isF(self) -> bool bool Group::isF() const Return true if F is valid.
def PyTrilinos::NOX::Epetra::Group::isGradient | ( | self, | ||
args | ||||
) |
isGradient(self) -> bool bool Group::isGradient() const Return true if the gradient is valid. Default implementation in NOX::Abstract::Group returns false.
def PyTrilinos::NOX::Epetra::Group::isGradient | ( | self, | ||
args | ||||
) |
isGradient(self) -> bool bool Group::isGradient() const Return true if the gradient is valid. Default implementation in NOX::Abstract::Group returns false.
def PyTrilinos::NOX::Epetra::Group::isJacobian | ( | self, | ||
args | ||||
) |
isJacobian(self) -> bool bool Group::isJacobian() const Return true if the Jacobian is valid. Default implementation in NOX::Abstract::Group returns false.
def PyTrilinos::NOX::Epetra::Group::isJacobian | ( | self, | ||
args | ||||
) |
isJacobian(self) -> bool bool Group::isJacobian() const Return true if the Jacobian is valid. Default implementation in NOX::Abstract::Group returns false.
def PyTrilinos::NOX::Epetra::Group::isNewton | ( | self, | ||
args | ||||
) |
isNewton(self) -> bool bool Group::isNewton() const Return true if the Newton direction is valid. Default implementation in NOX::Abstract::Group returns false.
def PyTrilinos::NOX::Epetra::Group::isNewton | ( | self, | ||
args | ||||
) |
isNewton(self) -> bool bool Group::isNewton() const Return true if the Newton direction is valid. Default implementation in NOX::Abstract::Group returns false.
def PyTrilinos::NOX::Epetra::Group::isNormNewtonSolveResidual | ( | self, | ||
args | ||||
) |
isNormNewtonSolveResidual(self) -> bool bool Group::isNormNewtonSolveResidual() const Returns true if the value of the Norm of the linear model for a full Newton step ||Js + f|| is valid with respect to the current solution vector.
def PyTrilinos::NOX::Epetra::Group::isNormNewtonSolveResidual | ( | self, | ||
args | ||||
) |
isNormNewtonSolveResidual(self) -> bool bool Group::isNormNewtonSolveResidual() const Returns true if the value of the Norm of the linear model for a full Newton step ||Js + f|| is valid with respect to the current solution vector.
def PyTrilinos::NOX::Epetra::Group::isPreconditioner | ( | self, | ||
args | ||||
) |
isPreconditioner(self) -> bool bool Group::isPreconditioner() const Returns true if an explicitly constructed preconditioner exists (i.e. one that is computed and saved for further use in multiple calls to applyRightPreconditioner).
def PyTrilinos::NOX::Epetra::Group::isPreconditioner | ( | self, | ||
args | ||||
) |
isPreconditioner(self) -> bool bool Group::isPreconditioner() const Returns true if an explicitly constructed preconditioner exists (i.e. one that is computed and saved for further use in multiple calls to applyRightPreconditioner).
def PyTrilinos::NOX::Epetra::Group::setX | ( | self, | ||
args | ||||
) |
setX(self, Vector y) setX(self, Vector y) void Group::setX(const NOX::Abstract::Vector &y) 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::Epetra::Group::setX | ( | self, | ||
args | ||||
) |
setX(self, Vector y) setX(self, Vector y) void Group::setX(const NOX::Abstract::Vector &y) 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