|
Public Types |
| enum | ReturnType {
Ok,
NotDefined,
BadDependency,
NotConverged,
Failed
} |
| | The computation of, say, the Newton direction in computeNewton() may fail in many different ways, so we have included a variety of return codes to describe the failures. Of course, we also have a code for success. More...
|
Public Member Functions |
| | Group () |
| | Constructor.
|
|
virtual | ~Group () |
| | Destructor.
|
| virtual NOX::Abstract::Group & | operator= (const NOX::Abstract::Group &source)=0 |
| | Copies the source group into this group.
|
|
| virtual void | setX (const NOX::Abstract::Vector &y)=0 |
| | Set the solution vector x to y.
|
| virtual void | computeX (const NOX::Abstract::Group &grp, const NOX::Abstract::Vector &d, double step)=0 |
| | Compute x = grp.x + step * d.
|
| virtual NOX::Abstract::Group::ReturnType | computeF ()=0 |
| | Compute and store F(x).
|
| virtual NOX::Abstract::Group::ReturnType | computeJacobian () |
| | Compute and store Jacobian.
|
| virtual NOX::Abstract::Group::ReturnType | computeGradient () |
| | Compute and store gradient.
|
| virtual NOX::Abstract::Group::ReturnType | computeNewton (NOX::Parameter::List ¶ms) |
| | Compute the Newton direction, using parameters for the linear solve.
|
|
Operations using the Jacobian matrix.
|
| virtual NOX::Abstract::Group::ReturnType | 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.
|
| virtual NOX::Abstract::Group::ReturnType | 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.
|
| virtual NOX::Abstract::Group::ReturnType | applyJacobianInverse (NOX::Parameter::List ¶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.
|
| virtual NOX::Abstract::Group::ReturnType | applyRightPreconditioning (bool useTranspose, NOX::Parameter::List ¶ms, const NOX::Abstract::Vector &input, NOX::Abstract::Vector &result) const |
| | Apply right preconditiong to the given input vector.
|
|
Operations using the Jacobian matrix.
|
| virtual NOX::Abstract::Group::ReturnType | applyJacobianMultiVector (const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| | applyJacobian for multiple right-hand sides
|
| virtual NOX::Abstract::Group::ReturnType | applyJacobianTransposeMultiVector (const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| | applyJacobianTranspose for multiple right-hand sides
|
| virtual NOX::Abstract::Group::ReturnType | applyJacobianInverseMultiVector (NOX::Parameter::List ¶ms, const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| | applyJacobianInverse for multiple right-hand sides
|
| virtual NOX::Abstract::Group::ReturnType | applyRightPreconditioningMultiVector (bool useTranspose, NOX::Parameter::List ¶ms, const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| | applyRightPreconditioning for multiple right-hand sides
|
|
Checks to see if various objects have been computed. Returns true if the corresponding "compute" function has been called since the last change to the solution vector.
|
|
virtual bool | isF () const =0 |
| | Return true if F is valid.
|
| virtual bool | isJacobian () const |
| | Return true if the Jacobian is valid.
|
| virtual bool | isGradient () const |
| | Return true if the gradient is valid.
|
| virtual bool | isNewton () const |
| | Return true if the Newton direction is valid.
|
|
Note that these function do not check whether or not the vectors are valid. Must use the "Is" functions for that purpose.
|
|
virtual const NOX::Abstract::Vector & | getX () const =0 |
| | Return solution vector.
|
|
virtual const NOX::Abstract::Vector & | getF () const =0 |
| | Return F(x).
|
| virtual double | getNormF () const =0 |
| | Return 2-norm of F(x).
|
|
virtual const NOX::Abstract::Vector & | getGradient () const =0 |
| | Return gradient.
|
|
virtual const NOX::Abstract::Vector & | getNewton () const =0 |
| | Return Newton direction.
|
| virtual NOX::Abstract::Group::ReturnType | getNormLastLinearSolveResidual (double &residual) const |
| | Return the norm of the last linear solve residual as the result of either a call to computeNewton() or applyJacobianInverse().
|
|
| virtual 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 pointer to the new group.
|
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.
![\[ v = J u, \]](form_55.png)
is the Jacobian, 
is the input vector, and 
is the result vector.![\[ v = J^{-1} u, \]](form_59.png)
![\[ \frac{\| J v - u \|_2}{\max \{ 1, \|u\|_2\} } < \mbox{Tolerance} \]](form_60.png)
![\[ v = J^T u, \]](form_58.png)
be a right preconditioner for the Jacobian ![\[ JM \approx I. \]](form_62.png)
![\[ u = M^{-1} v, \]](form_63.png)
![\[ u = {M^{-1}}^T v, \]](form_64.png)
![\[ \frac{\| M v - u \|_2}{\max \{ 1, \|u\|_2\} } < \mbox{Tolerance} \]](form_65.png)
as an optimization problem as follows: ![\[ \min f(x) \equiv \frac{1}{2} \|F(x)\|_2^2. \]](form_49.png)
) is defined as ![\[ g \equiv J^T F. \]](form_51.png)
or ![\[ F(x) = \left[ \begin{array}{c} F_1(x) \\ F_2(x) \\ \vdots \\ F_n(x) \\ \end{array} \right]. \]](form_45.png)
![\[ J_{ij} = \frac{\partial F_i}{\partial x_j} (x). \]](form_47.png)
![\[ J s = -F. \]](form_53.png)
![\[ \frac{\| J s - (-F) \|_2}{\max \{ 1, \|F\|_2\} } < \mbox{Tolerance} \]](form_54.png)
denote this group's solution vector. Let 
denote the result of grp.getX(). Then set ![\[ x = \hat x + \mbox{step} \; d. \]](form_44.png)
![\[ \sqrt{\sum_{i=1}^n F_i^2} \]](form_66.png)
