|
NOX Development
|
A group representing the minimally augemented turning point equations. More...
#include <LOCA_TurningPoint_MinimallyAugmented_ExtendedGroup.H>


Public Member Functions | |
| ExtendedGroup (const Teuchos::RCP< LOCA::GlobalData > &global_data, const Teuchos::RCP< LOCA::Parameter::SublistParser > &topParams, const Teuchos::RCP< Teuchos::ParameterList > &tpParams, const Teuchos::RCP< LOCA::TurningPoint::MinimallyAugmented::AbstractGroup > &g) | |
| Constructor with initial data passed through parameter lists. | |
| ExtendedGroup (const ExtendedGroup &source, NOX::CopyType type=NOX::DeepCopy) | |
| Copy constructor. | |
| virtual | ~ExtendedGroup () |
| Destructor. | |
Implementation of NOX::Abstract::Group virtual methods | |
| virtual NOX::Abstract::Group & | operator= (const NOX::Abstract::Group &source) |
| Assignment operator. | |
| virtual Teuchos::RCP< NOX::Abstract::Group > | clone (NOX::CopyType type=NOX::DeepCopy) const |
| Cloning function. | |
| virtual void | setX (const NOX::Abstract::Vector &y) |
| Set the solution vector, x, to y. | |
| virtual void | computeX (const NOX::Abstract::Group &g, const NOX::Abstract::Vector &d, double step) |
| Compute this.x = grp.x + step * d. | |
| virtual NOX::Abstract::Group::ReturnType | computeF () |
| Compute the turning point equation residual | |
| virtual NOX::Abstract::Group::ReturnType | computeJacobian () |
| Compute the blocks of the Jacobian derivative of | |
| virtual NOX::Abstract::Group::ReturnType | computeGradient () |
| Gradient computation is not defined for this group. | |
| virtual NOX::Abstract::Group::ReturnType | computeNewton (Teuchos::ParameterList ¶ms) |
| Compute Newton direction using applyJacobianInverse(). | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobian (const NOX::Abstract::Vector &input, NOX::Abstract::Vector &result) const |
| Computes the extended Jacobian vector product. | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobianTranspose (const NOX::Abstract::Vector &input, NOX::Abstract::Vector &result) const |
| Computes the extended Jacobian transpose vector product. | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobianInverse (Teuchos::ParameterList ¶ms, const NOX::Abstract::Vector &input, NOX::Abstract::Vector &result) const |
| Applies the inverse of the extended Jacobian matrix. | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobianMultiVector (const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| Applies Jacobian for extended system. | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobianTransposeMultiVector (const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| Jacobian transpose for extended system. | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobianInverseMultiVector (Teuchos::ParameterList ¶ms, const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| Applies Jacobian inverse for extended system. | |
| virtual bool | isF () const |
Return true if the extended residual | |
| virtual bool | isJacobian () const |
Return true if the extended Jacobian is valid. | |
| virtual bool | isGradient () const |
| Always returns false. | |
| virtual bool | isNewton () const |
Return true if the extended Newton direction is valid. | |
| virtual const NOX::Abstract::Vector & | getX () const |
| Return extended solution vector | |
| virtual const NOX::Abstract::Vector & | getF () const |
| Return extended equation residual | |
| virtual double | getNormF () const |
| Return 2-norm of | |
| virtual const NOX::Abstract::Vector & | getGradient () const |
| Vector returned is not valid. | |
| virtual const NOX::Abstract::Vector & | getNewton () const |
| Return extended Newton direction. | |
| virtual Teuchos::RCP< const NOX::Abstract::Vector > | getXPtr () const |
| Return RCP to extended solution vector | |
| virtual Teuchos::RCP< const NOX::Abstract::Vector > | getFPtr () const |
| Return RCP to extended equation residual | |
| virtual Teuchos::RCP< const NOX::Abstract::Vector > | getGradientPtr () const |
| Vector returned is not valid. | |
| virtual Teuchos::RCP< const NOX::Abstract::Vector > | getNewtonPtr () const |
| Return RCP to extended Newton direction. | |
| virtual double | getNormNewtonSolveResidual () const |
| Return the norm of the Newton solve residual. | |
Implementation of LOCA::Extended::MultiAbstractGroup | |
virtual methods | |
| virtual Teuchos::RCP< const LOCA::MultiContinuation::AbstractGroup > | getUnderlyingGroup () const |
| Return underlying group. | |
| virtual Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup > | getUnderlyingGroup () |
| Return underlying group. | |
Implementation of LOCA::MultiContinuation::AbstractGroup | |
virtual methods | |
| virtual void | copy (const NOX::Abstract::Group &source) |
| Assignment operator. | |
| virtual void | setParamsMulti (const std::vector< int > ¶mIDs, const NOX::Abstract::MultiVector::DenseMatrix &vals) |
| Set parameters indexed by (integer) paramIDs. | |
| virtual void | setParams (const ParameterVector &p) |
| Set the parameter vector in the group to p. | |
| virtual void | setParam (std::string paramID, double val) |
| Set parameter indexed by paramID. | |
| virtual void | setParam (int paramID, double val) |
| Set parameter indexed by paramID. | |
| virtual const ParameterVector & | getParams () const |
| Return a const reference to the paramter vector owned by the group. | |
| virtual double | getParam (int paramID) const |
| Return copy of parameter indexed by paramID. | |
| virtual double | getParam (std::string paramID) const |
| Return copy of parameter indexed by paramID. | |
| virtual NOX::Abstract::Group::ReturnType | computeDfDpMulti (const std::vector< int > ¶mIDs, NOX::Abstract::MultiVector &dfdp, bool isValidF) |
| virtual void | preProcessContinuationStep (LOCA::Abstract::Iterator::StepStatus stepStatus) |
| Perform any preprocessing before a continuation step starts. | |
| virtual void | postProcessContinuationStep (LOCA::Abstract::Iterator::StepStatus stepStatus) |
| Perform any postprocessing after a continuation step finishes. | |
| virtual void | projectToDraw (const NOX::Abstract::Vector &x, double *px) const |
| Projects solution to a few scalars for multiparameter continuation. | |
| virtual int | projectToDrawDimension () const |
| Returns the dimension of the project to draw array. | |
| virtual void | printSolution (const double conParam) const |
| Function to print out extended solution and continuation parameter after successful continuation step. | |
| virtual void | printSolution (const NOX::Abstract::Vector &x_, const double conParam) const |
| Function to print out extended solution and continuation parameter after successful continuation step. | |
Implementation of | |
LOCA::BorderedSystem::AbstractGroup virtual methods | |
| virtual int | getBorderedWidth () const |
| Return the total width of the bordered rows/columns. | |
| virtual Teuchos::RCP< const NOX::Abstract::Group > | getUnborderedGroup () const |
| Get bottom-level unbordered group. | |
| virtual bool | isCombinedAZero () const |
| Indicates whether combined A block is zero. | |
| virtual bool | isCombinedBZero () const |
| Indicates whether combined B block is zero. | |
| virtual bool | isCombinedCZero () const |
| Indicates whether combined C block is zero. | |
| virtual void | extractSolutionComponent (const NOX::Abstract::MultiVector &v, NOX::Abstract::MultiVector &v_x) const |
| virtual void | extractParameterComponent (bool use_transpose, const NOX::Abstract::MultiVector &v, NOX::Abstract::MultiVector::DenseMatrix &v_p) const |
| virtual void | loadNestedComponents (const NOX::Abstract::MultiVector &v_x, const NOX::Abstract::MultiVector::DenseMatrix &v_p, NOX::Abstract::MultiVector &v) const |
| virtual void | fillA (NOX::Abstract::MultiVector &A) const |
| Fill the combined A block as described above. | |
| virtual void | fillB (NOX::Abstract::MultiVector &B) const |
| Fill the combined B block as described above. | |
| virtual void | fillC (NOX::Abstract::MultiVector::DenseMatrix &C) const |
| Fill the combined C block as described above. | |
Public Member Functions inherited from LOCA::Extended::MultiAbstractGroup | |
| MultiAbstractGroup () | |
| Default constructor. | |
| virtual | ~MultiAbstractGroup () |
| Destructor. | |
| virtual Teuchos::RCP< const LOCA::MultiContinuation::AbstractGroup > | getBaseLevelUnderlyingGroup () const |
| Return base-level underlying group. | |
| virtual Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup > | getBaseLevelUnderlyingGroup () |
| Return base-level underlying group. | |
| virtual Teuchos::RCP< NOX::Abstract::Group > | getNestedGroup () |
| Override from NOX::Abstract::Group base class. Calls getUnderlyingGroup() from this class. | |
| virtual Teuchos::RCP< const NOX::Abstract::Group > | getNestedGroup () const |
| Override from NOX::Abstract::Group base class. Calls getUnderlyingGroup() from this class. | |
Public Member Functions inherited from NOX::Abstract::Group | |
| Group () | |
| Constructor. | |
| virtual | ~Group () |
| Destructor. | |
| virtual NOX::Abstract::Group::ReturnType | applyRightPreconditioning (bool useTranspose, Teuchos::ParameterList ¶ms, const NOX::Abstract::Vector &input, NOX::Abstract::Vector &result) const |
| Apply right preconditiong to the given input vector. | |
| virtual NOX::Abstract::Group::ReturnType | applyRightPreconditioningMultiVector (bool useTranspose, Teuchos::ParameterList ¶ms, const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| applyRightPreconditioning for multiple right-hand sides | |
| virtual const NOX::Abstract::Vector & | getScaledX () const |
| virtual void | logLastLinearSolveStats (NOX::SolverStats &stats) const |
| Adds statistics from last linear solve to the SovlerStats object. | |
| 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(). | |
Public Member Functions inherited from LOCA::MultiContinuation::AbstractGroup | |
| AbstractGroup () | |
| Default constructor. | |
| virtual | ~AbstractGroup () |
| Destructor. | |
| virtual double | computeScaledDotProduct (const NOX::Abstract::Vector &a, const NOX::Abstract::Vector &b) const |
| Compute a scaled dot product. | |
| virtual void | scaleVector (NOX::Abstract::Vector &x) const |
| Scales a vector using scaling vector. | |
Public Member Functions inherited from LOCA::BorderedSystem::AbstractGroup | |
| AbstractGroup () | |
| Constructor. | |
| virtual | ~AbstractGroup () |
| Destructor. | |
Public Member Functions inherited from LOCA::Abstract::TransposeSolveGroup | |
| TransposeSolveGroup () | |
| Constructor. | |
| virtual | ~TransposeSolveGroup () |
| Destructor. | |
Implementation of LOCA::Abstract::TransposeSolveGroup | |
virtual methods | |
| Teuchos::RCP< LOCA::GlobalData > | globalData |
| Pointer LOCA global data object. | |
| Teuchos::RCP< LOCA::Parameter::SublistParser > | parsedParams |
| Parsed top-level parameters. | |
| Teuchos::RCP< Teuchos::ParameterList > | turningPointParams |
| Bifurcation parameter list. | |
| Teuchos::RCP< LOCA::TurningPoint::MinimallyAugmented::AbstractGroup > | grpPtr |
| Pointer to base group that defines | |
| Teuchos::RCP< LOCA::TurningPoint::MinimallyAugmented::Constraint > | constraint |
| Pointer to the constraint equation. | |
| Teuchos::RCP< LOCA::MultiContinuation::ConstrainedGroup > | conGroup |
| Pointer to constrained group implementation. | |
| int | bifParamID |
| Stores the bifurcation parameter index. | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobianTransposeInverse (Teuchos::ParameterList ¶ms, const NOX::Abstract::Vector &input, NOX::Abstract::Vector &result) const |
| Solve Jacobian-tranpose system. | |
| virtual NOX::Abstract::Group::ReturnType | applyJacobianTransposeInverseMultiVector (Teuchos::ParameterList ¶ms, const NOX::Abstract::MultiVector &input, NOX::Abstract::MultiVector &result) const |
| Solve Jacobian-tranpose system with multiple right-hand sides. | |
| double | getBifParam () const |
| Get bifurcation parameter. | |
| Teuchos::RCP< const NOX::Abstract::Vector > | getLeftNullVec () const |
| Returns left null vector. | |
| Teuchos::RCP< const NOX::Abstract::Vector > | getRightNullVec () const |
| Returns right null vector v. | |
| Teuchos::RCP< const NOX::Abstract::Vector > | getAVec () const |
| Returns "A" vector. | |
| Teuchos::RCP< const NOX::Abstract::Vector > | getBVec () const |
| Returns "B". | |
| void | setBifParam (double param) |
| Set bifurcation parameter. | |
Additional Inherited Members | |
Public Types inherited from NOX::Abstract::Group | |
| 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... | |
A group representing the minimally augemented turning point equations.
The LOCA::TurningPoint::MinimallyAugmented::ExtendedGroup is a concrete implementation of the NOX::Abstract::Group, LOCA::MultiContinuation::AbstractGroup and LOCA::Extended::MultiAbstractGroup that defines the following extended set of equations that are regular at a generic turning point:
![\[
G(z) = \left[
\begin{array}{c}
F(x,p) \\
\sigma
\end{array}
\right] = 0
\]](form_635.png)
where ![$z = [x, p]\in\Re^{n+1}$](form_636.png)






![\[
\begin{bmatrix}
J & a \\
b^T & 0
\end{bmatrix}
\begin{bmatrix}
v \\
\sigma_1
\end{bmatrix} =
\begin{bmatrix}
0 \\
n
\end{bmatrix},
\]](form_580.png)
![\[
\begin{bmatrix}
J^T & b \\
a^T & 0
\end{bmatrix}
\begin{bmatrix}
w \\
\sigma_2
\end{bmatrix} =
\begin{bmatrix}
0 \\
n
\end{bmatrix},
\]](form_581.png)
![\[
\sigma = w^T J v/n
\]](form_587.png)
for any vectors 


![\[
\begin{split}
\sigma_x &= (w^T J v)_x/n = w^T J_x v/n \\
\sigma_p &= (w^T J v)_p/n = w^T J_p v/n
\end{split}
\]](form_588.png)
The group stores an underlying group of type LOCA::TurningPoint::MinimallyAugmented::AbstractGroup to represent the equations 



This class implements all of the NOX::Abstract::Group, LOCA::MultiContinuation::AbstractGroup, and LOCA::Extended::MultiAbstractGroup methods for this extended set of equations and therefore is a complete group which can be passed to most NOX solvers to locate a single turning point or to the LOCA::Stepper to compute a family of turning points in a second parameter.
The class is intialized via the tpParams parameter list argument to the constructor. The parameters this class recognizes are:



























|
virtual |
Computes the extended Jacobian vector product.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Applies the inverse of the extended Jacobian matrix.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Applies Jacobian inverse for extended system.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Applies Jacobian for extended system.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Computes the extended Jacobian transpose vector product.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Solve Jacobian-tranpose system.
Implements LOCA::Abstract::TransposeSolveGroup.
|
virtual |
Solve Jacobian-tranpose system with multiple right-hand sides.
Implements LOCA::Abstract::TransposeSolveGroup.
|
virtual |
Jacobian transpose for extended system.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Cloning function.
Implements NOX::Abstract::Group.
|
virtual |
Compute 

Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Compute the turning point equation residual 
This method fills the extended residual
![\[
G(z) = \left[
\begin{array}{c}
F(x,p) \\
\sigma
\end{array}
\right].
\]](form_637.png)
Implements NOX::Abstract::Group.
|
virtual |
Gradient computation is not defined for this group.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Compute the blocks of the Jacobian derivative of 
This method computes the 



![\[
D_z G(z) =
\begin{bmatrix}
J & F_p \\
\sigma_x & \sigma_p
\end{bmatrix}
\]](form_641.png)
Reimplemented from NOX::Abstract::Group.
|
virtual |
Compute Newton direction using applyJacobianInverse().
Reimplemented from NOX::Abstract::Group.
|
virtual |
Compute this.x = grp.x + step * d.
Implements NOX::Abstract::Group.
References conGroup, LOCA::Extended::Vector::getScalar(), and LOCA::MultiContinuation::ExtendedVector::getXVec().
|
virtual |
Assignment operator.
Implements LOCA::MultiContinuation::AbstractGroup.
References bifParamID, conGroup, globalData, parsedParams, and turningPointParams.
|
virtual |
Given the vector v, extract the parameter components of all of the nested subvectors in v down to the solution component for the unbordered group.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Given the vector v, extract the underlying solution component corresponding to the unbordered group.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Fill the combined A block as described above.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Fill the combined B block as described above.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Fill the combined C block as described above.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Return the total width of the bordered rows/columns.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Return extended equation residual 
Implements NOX::Abstract::Group.
|
virtual |
Return RCP to extended equation residual 
Implements NOX::Abstract::Group.
|
virtual |
Vector returned is not valid.
Implements NOX::Abstract::Group.
|
virtual |
Vector returned is not valid.
Implements NOX::Abstract::Group.
|
virtual |
Return extended Newton direction.
Implements NOX::Abstract::Group.
|
virtual |
Return RCP to extended Newton direction.
Implements NOX::Abstract::Group.
|
virtual |
Return 2-norm of 
Implements NOX::Abstract::Group.
|
virtual |
Return copy of parameter indexed by paramID.
Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Return copy of parameter indexed by paramID.
Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Return a const reference to the paramter vector owned by the group.
Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Get bottom-level unbordered group.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Return underlying group.
Implements LOCA::Extended::MultiAbstractGroup.
|
virtual |
Return underlying group.
Implements LOCA::Extended::MultiAbstractGroup.
|
virtual |
Return extended solution vector 
Implements NOX::Abstract::Group.
|
virtual |
Return RCP to extended solution vector 
Implements NOX::Abstract::Group.
|
virtual |
Indicates whether combined A block is zero.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Indicates whether combined B block is zero.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Indicates whether combined C block is zero.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Return true if the extended residual 
Implements NOX::Abstract::Group.
|
virtual |
Always returns false.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Return true if the extended Jacobian is valid.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Return true if the extended Newton direction is valid.
Reimplemented from NOX::Abstract::Group.
|
virtual |
Given the solution component v_x and combined parameter components v_p, distribute these components through the nested sub-vectors in v.
Implements LOCA::BorderedSystem::AbstractGroup.
|
virtual |
Assignment operator.
Implements NOX::Abstract::Group.
|
virtual |
Perform any postprocessing after a continuation step finishes.
The stepStatus argument indicates whether the step was successful.
Reimplemented from LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Perform any preprocessing before a continuation step starts.
The stepStatus argument indicates whether the previous step was successful.
Reimplemented from LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Function to print out extended solution and continuation parameter after successful continuation step.
This method prints the solution, null-vector, and parameter components of the extended solution vector using the printSolution method of the underlying group.
Reimplemented from LOCA::MultiContinuation::AbstractGroup.
References NOX::Utils::StepperDetails.
|
virtual |
Function to print out extended solution and continuation parameter after successful continuation step.
This method prints the solution, null-vector, and parameter components of the extended solution vector using the printSolution method of the underlying group.
Reimplemented from LOCA::MultiContinuation::AbstractGroup.
References LOCA::Extended::Vector::getScalar(), LOCA::MultiContinuation::ExtendedVector::getXVec(), and NOX::Utils::StepperDetails.
|
virtual |
Projects solution to a few scalars for multiparameter continuation.
Reimplemented from LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Returns the dimension of the project to draw array.
Reimplemented from LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Set parameter indexed by paramID.
Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Set parameter indexed by paramID.
Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Set the parameter vector in the group to p.
Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Set parameters indexed by (integer) paramIDs.
Implements LOCA::MultiContinuation::AbstractGroup.
|
virtual |
Set the solution vector, x, to y.
Implements NOX::Abstract::Group.