ML_NOX::Ml_Nox_Fineinterface Class Reference

Ml_Nox_Fineinterface: a virtual class used by ML_Nox_Preconditioner. More...

#include <ml_nox_fineinterface.H>

List of all members.

Public Member Functions

 Ml_Nox_Fineinterface ()
 Constructor.
virtual ~Ml_Nox_Fineinterface ()
 virtual Constructor
virtual bool computeF (const Epetra_Vector &x, Epetra_Vector &F, const FillType fillFlag)=0
 Compute and return F (derived from NOX::EpetraNew::Interface::Required).
virtual bool computeJacobian (const Epetra_Vector &x)=0
 Compute the current Jacobian (derived from NOX::EpetraNew::Interface::Jacobian).
virtual bool computePreconditioner (const Epetra_Vector &x, NOX::Parameter::List *precParams=0)=0
 Compute the current Preconditioner (derived from NOX::EpetraNew::Interface::Preconditioner).
virtual Epetra_CrsMatrixgetJacobian ()=0
 Return the Jacobian from the application.
virtual const Epetra_CrsGraphgetGraph ()=0
 Return the Graph of the fine level problem from the application.
virtual const Epetra_CrsGraphgetModifiedGraph ()=0
virtual const Epetra_VectorgetSolution ()=0
 Return the current solution from the application.
virtual const Epetra_MapgetMap ()=0
 Return the Map of the current solution from the application.
virtual bool isnewJacobian ()
 Query whether the current Jacobian matches the current solution vector.
virtual int getnumJacobian ()
 Query how often the Jacobian has been recomputed.
virtual double * Get_Nullspace (const int nummyrows, const int numpde, const int dim_nullsp)=0
 Compute and return the Nullspace of the problem from the application.
virtual void ApplyAllConstraints (Epetra_Vector &gradient, int level)
virtual bool getBlockInfo (int *nblocks, int **blocks, int **block_pde)=0
 Compute and return the block node information from the application.
double getsumtime ()
 Query the summed time spent in this interface.
void resetsumtime ()
 Reset the summed time spent in this interface to a certain value.
int getnumcallscomputeF ()
 Query the number of calls to the computeF method of this class.
bool setnumcallscomputeF (int ncalls)
 Reset the number of calls to the computeF method of this class.
int OutLevel ()

Public Attributes

bool isnewJacobian_
 Flag to indicate, that the Jacobian has been evaluated by the application.
int numJacobian_
 count number of evaluated Jacobians
int printlevel_
 Printlevel.
double t_
 t_ should be used for time measurement of time spent in this class
int ncalls_computeF_
 ncalls_computeF_ is used to count the number of calls to computeF


Detailed Description

Ml_Nox_Fineinterface: a virtual class used by ML_Nox_Preconditioner.

ML_NOX::Ml_Nox_Fineinterface is a pure virtual class that serves as an interface between the ML_Nox_Preconditioner and any application. It implements all three NOX interfaces NOX::EpetraNew::Interface::Required, NOX::EpetraNew::Interface::Jacobian and NOX::EpetraNew::Interface::Preconditioner. Besides serving as an interface for the nonlinear iteration, it also serves as an interface to do finite differencing of Jacobians and as the fine level interface all coarser level interfaces refer to. It therefore plays a major role in using the ML_Nox_Preconditioner.

To make use of the full functionality of this class it requires ML to be configured with the following options:

Note:
Currently, using this class makes it necessary to configure and make install of Trilinos WITHOUT the --with-ml_nox, and then repeating the configure and make install process WITH the --with-ml_nox option to be able to resolve the dependencies of this class on NOX header files
Author:
Michael Gee, SNL 9214


Constructor & Destructor Documentation

ML_NOX::Ml_Nox_Fineinterface::Ml_Nox_Fineinterface  )  [inline]
 

Constructor.

Constructor

virtual ML_NOX::Ml_Nox_Fineinterface::~Ml_Nox_Fineinterface  )  [inline, virtual]
 

virtual Constructor

virtual Constructor


Member Function Documentation

virtual bool ML_NOX::Ml_Nox_Fineinterface::computeF const Epetra_Vector x,
Epetra_Vector F,
const FillType  fillFlag
[pure virtual]
 

Compute and return F (derived from NOX::EpetraNew::Interface::Required).

Compute and return F (derived from NOX::EpetraNew::Interface::Required). This method is called by the nonlinear preconditioner. It supplies a solution vector x and needs a residual vector F computed by this funtion on output.

Parameters:
x (In) : current solution vector
F (Out) : residual vector matching x
fillFlag (In) : flag indicating for what purpose this routine was called, see NOX documentation of NOX::EpetraNew::Interface::Required

virtual bool ML_NOX::Ml_Nox_Fineinterface::computeJacobian const Epetra_Vector x  )  [pure virtual]
 

Compute the current Jacobian (derived from NOX::EpetraNew::Interface::Jacobian).

Compute the current Jacobian (derived from NOX::EpetraNew::Interface::Jacobian). This method is called by the nonlinear preconditioner. It supplies a solution vector x and wants a Jacobian computed matching this solution vector on output. getJacobian will be used to obtain the Jacobian

See also:
getJacobian
Parameters:
x (In) : current solution vector

virtual bool ML_NOX::Ml_Nox_Fineinterface::computePreconditioner const Epetra_Vector x,
NOX::Parameter::List *  precParams = 0
[pure virtual]
 

Compute the current Preconditioner (derived from NOX::EpetraNew::Interface::Preconditioner).

FIXME: just found out that this interface is never used by ML_Nox_Preconditioner, as ML_Nox_Preconditioner implements it's own NOX::EpetraNew::Interface::Preconditioner. delete this?

virtual double* ML_NOX::Ml_Nox_Fineinterface::Get_Nullspace const int  nummyrows,
const int  numpde,
const int  dim_nullsp
[pure virtual]
 

Compute and return the Nullspace of the problem from the application.

Compute and return the Nullspace of the problem from the application. This method is called by the nonlinear preconditioner to obtain the Nullspace of the problem from the application. If the application returns NULL on exit, the ML_Nox_Preconditioner will use a default Nullspace of correct size (given by dim_nullsp) and will assume constant number of dofs per node (constant block size). This will lead to errors in the aggregation process if the problem is NOT of constant block size!

Parameters:
nummyrows (In) : dimension of the nullspace vectors
numpde (In) : number of PDEs (normally dofs per node)
dim_nullsp (In) : dimension of the nullspace

virtual bool ML_NOX::Ml_Nox_Fineinterface::getBlockInfo int *  nblocks,
int **  blocks,
int **  block_pde
[pure virtual]
 

Compute and return the block node information from the application.

Compute and return the block node information from the application. This method is called by the nonlinear preconditioner to obtain information about non-constant block sizes. It is used only in the case of the VBMETIS aggregation scheme. If on exit blocks and block_pde are NULL, the ML_Nox_Preconditioner will assume a constant vblock size and will use METIS instead of the VBMETIS aggregation scheme.

Parameters:
nblocks (Out) : on exit, number of variable sized nodal blocks
blocks (Out) : on exit, allocated vector of length NumMyRows containing the block indize of each row in C-style numbering (starting with 0)
block_pde (Out) : on exit, allocated vector of length NumMyRows containing the number of PDE a certain row belongs to.

virtual const Epetra_CrsGraph* ML_NOX::Ml_Nox_Fineinterface::getGraph  )  [pure virtual]
 

Return the Graph of the fine level problem from the application.

Return the Graph of the fine level problem from the application. The ML_Nox_Preconditioner uses this method to get the graph of the fine level problem from the application.

virtual Epetra_CrsMatrix* ML_NOX::Ml_Nox_Fineinterface::getJacobian  )  [pure virtual]
 

Return the Jacobian from the application.

Return the Jacobian from the application. The ML_Nox_Preconditioner uses this method to get the jacobian from the application. It will never be used in the matrixfree case.

See also:
ML_Nox_Preconditioner

virtual const Epetra_Map& ML_NOX::Ml_Nox_Fineinterface::getMap  )  [pure virtual]
 

Return the Map of the current solution from the application.

Return the Map of the current solution from the application. The ML_Nox_Preconditioner uses this method to get the map of the current solution vector of the fine level problem from the application.

int ML_NOX::Ml_Nox_Fineinterface::getnumcallscomputeF  )  [inline]
 

Query the number of calls to the computeF method of this class.

Query the number of calls to the computeF method of this class. This is for performance analysis.

virtual int ML_NOX::Ml_Nox_Fineinterface::getnumJacobian  )  [inline, virtual]
 

Query how often the Jacobian has been recomputed.

Query how often the Jacobian has been recomputed.

virtual const Epetra_Vector* ML_NOX::Ml_Nox_Fineinterface::getSolution  )  [pure virtual]
 

Return the current solution from the application.

Return the current solution from the application. The ML_Nox_Preconditioner uses this method to get the current solution vector of the fine level problem from the application.

double ML_NOX::Ml_Nox_Fineinterface::getsumtime  )  [inline]
 

Query the summed time spent in this interface.

Query the summed time spent in this interface. This is for performance analysis.

virtual bool ML_NOX::Ml_Nox_Fineinterface::isnewJacobian  )  [inline, virtual]
 

Query whether the current Jacobian matches the current solution vector.

Query whether the current Jacobian matches the current solution vector.

void ML_NOX::Ml_Nox_Fineinterface::resetsumtime  )  [inline]
 

Reset the summed time spent in this interface to a certain value.

Reset the summed time spent in this interface to a certain value. This is for performance analysis.

bool ML_NOX::Ml_Nox_Fineinterface::setnumcallscomputeF int  ncalls  )  [inline]
 

Reset the number of calls to the computeF method of this class.

Reset the number of calls to the computeF method of this class. This is for performance analysis.


Member Data Documentation

bool ML_NOX::Ml_Nox_Fineinterface::isnewJacobian_
 

Flag to indicate, that the Jacobian has been evaluated by the application.

Flag to indicate, that the Jacobian has been evaluated by the application. the ML_NOX::Ml_Nox_Fineinterface should set this to true, whenever the evaluated Jacobian matches the F in the computeF. It should be set to false if there is either no Jacobian evaluated or it does not match the F from the computeF function

int ML_NOX::Ml_Nox_Fineinterface::ncalls_computeF_
 

ncalls_computeF_ is used to count the number of calls to computeF

ncalls_computeF_ is used to count the number of calls to computeF

int ML_NOX::Ml_Nox_Fineinterface::numJacobian_
 

count number of evaluated Jacobians

The user's ML_NOX::Ml_Nox_Fineinterface derived class should use this to count the number of Jacobian evaluations for statistical and debug-purpose

int ML_NOX::Ml_Nox_Fineinterface::printlevel_
 

Printlevel.

The user's ML_NOX::Ml_Nox_Fineinterface derived class should set a printlevel value between 0 and 10

double ML_NOX::Ml_Nox_Fineinterface::t_
 

t_ should be used for time measurement of time spent in this class

t_ should be used for time measurement. The methods getsumtime and resetsumtime will be used to query this value for performance measurement


The documentation for this class was generated from the following file:
Generated on Thu Sep 18 12:40:58 2008 for ML by doxygen 1.3.9.1