Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

LOCA::Epetra::Group Class Reference

Extension of the NOX::Epetra::Group to LOCA. More...

#include <LOCA_Epetra_Group.H>

Inheritance diagram for LOCA::Epetra::Group:

[legend]
Collaboration diagram for LOCA::Epetra::Group:
[legend]
List of all members.

Public Member Functions

 Group (NOX::Parameter::List &printParams, NOX::Parameter::List &linearSolverParams, Interface &i, const ParameterVector &p, NOX::Epetra::Vector &x, Epetra_Operator &J)
 Constructor with Jacobian Operator only.
 Group (NOX::Parameter::List &printParams, NOX::Parameter::List &linearSolverParams, Interface &i, const ParameterVector &p, NOX::Epetra::Vector &x, Epetra_Operator &J, Epetra_Operator &M)
 Constructor with a separate Jacobian (J) and Preconditioner (M).
 Group (const Group &source, NOX::CopyType type=NOX::DeepCopy)
 Copy constructor. If type is DeepCopy, takes ownership of valid shared Jacobian and shared preconditioning matrix.
virtual ~Group ()
 Destructor.
virtual Group & operator= (const Group &source)
 Assignment operator.
virtual NOX::Epetra::Interface & getUserInterface ()
 Return the userInterface.
virtual void printSolution (const NOX::Epetra::Vector &x, const double conParam) const
 Call the user interface print() routine, any vector.
void setScaleVector (const NOX::Abstract::Vector &s)
 Sets the scale vector.
Overloaded NOX::Epetra::Group methods.
virtual NOX::Abstract::Group & operator= (const NOX::Abstract::Group &source)
 Assignment operator.
virtual NOX::Abstract::Group * clone (NOX::CopyType type=NOX::DeepCopy) const
 Cloning function.
virtual NOX::Abstract::Group::ReturnType computeF ()
 Overloaded computeF().
virtual NOX::Abstract::Group::ReturnType computeJacobian ()
 Overloaded computeJacobian().
Implementation of LOCA::Abstract::Group virtual methods.
virtual LOCA::Abstract::Group & operator= (const LOCA::Abstract::Group &source)
 Assignment operator.
Implementation of LOCA::Continuation::AbstractGroup virtual methods.
virtual void setParams (const ParameterVector &p)
 Set the parameters.
virtual void setParam (int paramID, double val)
 Set parameter indexed by paramID.
virtual void setParam (string paramID, double val)
 Set parameter indexed by paramID.
const LOCA::ParameterVector & getParams () const
 Return a const reference to the ParameterVector owned by the group.
virtual double getParam (int paramID) const
 Return copy of parameter indexed by paramID.
virtual double getParam (string paramID) const
 Return copy of parameter indexed by paramID.
virtual double computeScaledDotProduct (const NOX::Abstract::Vector &a, const NOX::Abstract::Vector &b) const
 Compute a scaled dot product.
virtual void printSolution (const double conParam) const
 Call the user interface print() routine, solution vector.
virtual void printSolution (const NOX::Abstract::Vector &x, const double conParam) const
 Call the user interface print() routine, any vector.
virtual NOX::Abstract::Group::ReturnType applyHouseholderJacobianInverse (NOX::Parameter::List &params, const NOX::Abstract::Vector &f, const NOX::Abstract::Vector &dfdp, const NOX::Abstract::Vector &ux, double up, double beta, NOX::Abstract::Vector &result_x, double &result_p) const
 Solve arclength continuation equations using Householder projection.
virtual void scaleVector (NOX::Abstract::Vector &x) const
 Scales a vector using scaling vector.
Implementation of LOCA::MultiContinuation::AbstractGroup virtual methods.
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.
Implementation of LOCA::Bifurcation::TPBord::AbstractGroup virtual methods.
virtual NOX::Abstract::Group::ReturnType applyBorderedJacobianInverse (bool trans, NOX::Parameter::List &params, const NOX::Abstract::Vector &a, const NOX::Abstract::Vector &b, const NOX::Abstract::Vector &vInput, double sInput, NOX::Abstract::Vector &vResult, double &sResult) const
 Solve a bordered system of equations.
Implementation of LOCA::Homotopy::AbstractGroup virtual methods.
virtual NOX::Abstract::Group::ReturnType augmentJacobianForHomotopy (double conParamValue)
 Replace Jacobian $J$ by $J+pI$ where $I$ is the identity matrix and $p$ is a scalar (conParamValue).

Protected Member Functions

void setBorderedAztecOptions (const NOX::Parameter::List &p, AztecOO &aztec) const
 Sets aztec solver options for matrix-free bordered system.

Protected Attributes

LOCA::ParameterVector params
 Parameter vector.
Interface & userInterface
 Reference to the user supplied interface functions.
Epetra_Vector * tmpVectorPtr2
 Extra vector needed for intermediate calculations of LOCA routines.
NOX::Abstract::Vector * scaleVecPtr
 Stores a pointer to the scale vector.

Detailed Description

Extension of the NOX::Epetra::Group to LOCA.

This class is derived both from the NOX::Epetra::Group and LOCA::Abstract::Group classes and therefore inherits the implementation of the NOX::Abstract::Group interface provided by NOX::Epetra::Group.

This class provides implementations of LOCA AbstractGroup virtual methods specific to the Epetra group. It stores a parameter vector for setting/retrieving parameter values (LOCA::Continuation::AbstractGroup), provides a facility for computing eigenvalues (LOCA::Continuation::AbstractGroup) using the Anasazi package, and augements the Jacobian matrix for homotopy (LOCA::Homotopy::AbstractGroup), It currently has no support for storing a mass matrix and therefore cannot be used in Hopf or generalized eigenvalue computations. Since it is derived from the LOCA::Abstract::Group (which is in-turn derived from all FiniteDifference groups), this group implicitly uses the finite-difference implementations of parameter and second derivatives provided by the FiniteDifference groups.

The computeF() and computeJacobian() methods of the NOX::Epetra::Group parent class are overloaded here. They both set the entire contents of the parameter vector in the problem interface before calling the NOX::Epetra::Group computeF() and computeJacobian().

Constructor & Destructor Documentation

LOCA::Epetra::Group::Group (  NOX::Parameter::List &  printParams,
NOX::Parameter::List &  linearSolverParams,
Interface &  i,
const ParameterVector &  p,
NOX::Epetra::Vector &  x,
Epetra_Operator &  J
) 
 

Constructor with Jacobian Operator only.

Either there is no preconditioning or the Jacobian will be used for preconditioning. An Epetra_Operator must be supplied for the Jacobian even in Matrix-Free mode. linearSolverParams is the "Linear Solver" sublist of parameter list.

The scaling vector is set to a default of all one's

LOCA::Epetra::Group::Group (  NOX::Parameter::List &  printParams,
NOX::Parameter::List &  linearSolverParams,
Interface &  i,
const ParameterVector &  p,
NOX::Epetra::Vector &  x,
Epetra_Operator &  J,
Epetra_Operator &  M
) 
 

Constructor with a separate Jacobian (J) and Preconditioner (M).

linearSolverParams is the "Linear %Solver" sublist of parameter list. The scaling vector is set to a default of all one's

Member Function Documentation

NOX::Abstract::Group::ReturnType LOCA::Epetra::Group::applyBorderedJacobianInverse (  bool  trans,
NOX::Parameter::List &  params,
const NOX::Abstract::Vector &  a,
const NOX::Abstract::Vector &  b,
const NOX::Abstract::Vector &  vInput,
double  sInput,
NOX::Abstract::Vector &  vResult,
double &  sResult
)  const [virtual]
 

Solve a bordered system of equations.

Compute the solution to the bordered system of equations

\[ \begin{bmatrix} J & a \\ b^T & 0 \end{bmatrix} \begin{bmatrix} \text{vResult} \\ \text{sResult} \end{bmatrix} = \begin{bmatrix} \text{vInput} \\ \text{sInput} \end{bmatrix} \]

Reimplemented from LOCA::Abstract::Group.

NOX::Abstract::Group::ReturnType LOCA::Epetra::Group::applyHouseholderJacobianInverse (  NOX::Parameter::List &  params,
const NOX::Abstract::Vector &  f,
const NOX::Abstract::Vector &  dfdp,
const NOX::Abstract::Vector &  ux,
double  up,
double  beta,
NOX::Abstract::Vector &  result_x,
double &  result_p
)  const [virtual]
 

Solve arclength continuation equations using Householder projection.

This method computes a solution to the following system of equations

\[ \begin{bmatrix} J & \frac{df}{dp} \end{bmatrix} Q \Delta x = f \]

where $Q\in\Re^{n+1\times n}$ is an orthogonal matrix such that for any $z\in\Re^n$,

\[ Q z = P \begin{bmatrix} z \\ 0 \end{bmatrix}. \]

Here $P = I - \beta u u^T\in\Re^{n+1\times n+1}$ is a Householder transformation such that $P v = \|v\|_2 e_{n+1}$ and $u_{n+1} = 1$ where $v\in\Re^{n+1}$ is the predictor vector and $e_{n+1}$ is the $n+1$ column of the identity.

The implementation here uses Aztec with an Ifpack preconditioner for $J$.

Reimplemented from LOCA::Continuation::AbstractGroup.

NOX::Abstract::Group::ReturnType LOCA::Epetra::Group::computeF (   )  [virtual]
 

Overloaded computeF().

Calls LOCA::Epetra::Interface::setParams before evalulating F.

Reimplemented from NOX::Epetra::Group.

NOX::Abstract::Group::ReturnType LOCA::Epetra::Group::computeJacobian (   )  [virtual]
 

Overloaded computeJacobian().

Calls LOCA::Epetra::Interface::setParams before evalulating J.

Reimplemented from NOX::Epetra::Group.

double LOCA::Epetra::Group::computeScaledDotProduct (  const NOX::Abstract::Vector &  a,
const NOX::Abstract::Vector &  b
)  const [virtual]
 

Compute a scaled dot product.

The implementation here uses the scaling vector $s$ if one is supplied:

\[ \sum_{i=1}^n a_i*b_i*s_i*s_i. \]

If the scaling vector is not provided, the standard dot product is used.

Reimplemented from LOCA::Continuation::AbstractGroup.

void LOCA::Epetra::Group::projectToDraw (  const NOX::Abstract::Vector &  x,
double *  px
)  const [virtual]
 

Projects solution to a few scalars for multiparameter continuation.

This method is called every time a solution is saved by the multiparameter continuation code MF for later visualization and should project the solution vector down to a few scalars. The array px will be preallocated to the proper length given by projectToDrawDimension().

The implementation here is to call the corresponding method in the interface.

Reimplemented from LOCA::MultiContinuation::AbstractGroup.

int LOCA::Epetra::Group::projectToDrawDimension (   )  const [virtual]
 

Returns the dimension of the project to draw array.

The implementation here is to call the corresponding method in the interface.

Reimplemented from LOCA::MultiContinuation::AbstractGroup.

void LOCA::Epetra::Group::scaleVector (  NOX::Abstract::Vector &  x  )  const [virtual]
 

Scales a vector using scaling vector.

The implementation here uses the scaling vector $s$ if one is supplied:

\[ x_i = a_i*s_i. \]

If the scaling vector is not provided, the vector is rescaled by the square root of its length.

Reimplemented from LOCA::Continuation::AbstractGroup.

Member Data Documentation

Epetra_Vector* LOCA::Epetra::Group::tmpVectorPtr2 [protected]
 

Extra vector needed for intermediate calculations of LOCA routines.

NOTE: there already is a tmpVectorPtr in the NOX::Epetra::Group. This is a second temporary vector if that one extra isn't enough.

The documentation for this class was generated from the following files:
Generated on Thu Sep 18 12:40:44 2008 for NOX by doxygen 1.3.9.1