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
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 ¶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::Abstract::Group::applyJacobianInverse | ( | self, | ||
args | ||||
) |
applyJacobianInverse(self, ParameterList params, Vector input, Vector result) -> ReturnType NOX::Abstract::Group::ReturnType NOX::Abstract::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::Abstract::Group::applyJacobianInverseMultiVector | ( | self, | ||
args | ||||
) |
applyJacobianInverseMultiVector(self, ParameterList params, MultiVector input, MultiVector result) -> ReturnType NOX::Abstract::Group::ReturnType NOX::Abstract::Group::applyJacobianInverseMultiVector(Teuchos::ParameterList ¶ms, 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 ¶ms, 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 ¶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::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 ¶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::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 ¶ms, 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 ¶ms, 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 ¶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::Abstract::Group::computeNewton | ( | self, | ||
args | ||||
) |
computeNewton(self, ParameterList params) -> ReturnType NOX::Abstract::Group::ReturnType NOX::Abstract::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::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