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_CrsMatrix *	getJacobian ()=0
	Return the Jacobian from the application.
virtual const Epetra_CrsGraph *	getGraph ()=0
	Return the Graph of the fine level problem from the application.
virtual const Epetra_CrsGraph *	getModifiedGraph ()=0
virtual const Epetra_Vector *	getSolution ()=0
	Return the current solution from the application.
virtual const Epetra_Map &	getMap ()=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:

• --with-ml_nox
• --enable-epetra
• --enable-epetraext
• --enable-nox
• --enable-nox-epetra
• --enable-prerelease
• --enable-aztecoo
• --enable-amesos

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:

• ml_nox_fineinterface.H

---