NOX::Epetra::LinearSystemAztecOO Class Reference

Concrete implementation of NOX::Epetra::LinearSolver for AztecOO. More...

#include <NOX_Epetra_LinearSystem_AztecOO.H>

Inheritance diagram for NOX::Epetra::LinearSystemAztecOO:

[legend]Collaboration diagram for NOX::Epetra::LinearSystemAztecOO:


Public Member Functions
	LinearSystemAztecOO (Teuchos::ParameterList &printingParams, Teuchos::ParameterList &linearSolverParams, const Teuchos::RCP< NOX::Epetra::Interface::Required > &iReq, const NOX::Epetra::Vector &cloneVector, const Teuchos::RCP< NOX::Epetra::Scaling > scalingObject=Teuchos::null)
	Constructor with no Operators.
	LinearSystemAztecOO (Teuchos::ParameterList &printingParams, Teuchos::ParameterList &linearSolverParams, const Teuchos::RCP< NOX::Epetra::Interface::Required > &iReq, const Teuchos::RCP< NOX::Epetra::Interface::Jacobian > &iJac, const Teuchos::RCP< Epetra_Operator > &J, const NOX::Epetra::Vector &cloneVector, const Teuchos::RCP< NOX::Epetra::Scaling > scalingObject=Teuchos::null)
	Constructor with a user supplied Jacobian Operator only.
	LinearSystemAztecOO (Teuchos::ParameterList &printingParams, Teuchos::ParameterList &linearSolverParams, const Teuchos::RCP< NOX::Epetra::Interface::Required > &i, const Teuchos::RCP< NOX::Epetra::Interface::Preconditioner > &iPrec, const Teuchos::RCP< Epetra_Operator > &M, const NOX::Epetra::Vector &cloneVector, const Teuchos::RCP< NOX::Epetra::Scaling > scalingObject=Teuchos::null)
	Constructor with a user supplied Preconditioner Operator only.
	LinearSystemAztecOO (Teuchos::ParameterList &printingParams, Teuchos::ParameterList &linearSolverParams, const Teuchos::RCP< NOX::Epetra::Interface::Jacobian > &iJac, const Teuchos::RCP< Epetra_Operator > &J, const Teuchos::RCP< NOX::Epetra::Interface::Preconditioner > &iPrec, const Teuchos::RCP< Epetra_Operator > &M, const NOX::Epetra::Vector &cloneVector, const Teuchos::RCP< NOX::Epetra::Scaling > scalingObject=Teuchos::null)
virtual	~LinearSystemAztecOO ()
	Destructor.
virtual bool	applyJacobian (const NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const
	Applies Jacobian to the given input vector and puts the answer in the result.
virtual bool	applyJacobianTranspose (const NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const
	Applies Jacobian-Transpose to the given input vector and puts the answer in the result.
virtual bool	applyJacobianInverse (Teuchos::ParameterList &linearSolverParams, const NOX::Epetra::Vector &input, NOX::Epetra::Vector &result)
	Applies the inverse of the Jacobian matrix to the given input vector and puts the answer in result.
virtual bool	applyRightPreconditioning (bool useTranspose, Teuchos::ParameterList &linearSolverParams, const NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const
	Apply right preconditiong to the given input vector.
virtual bool	createPreconditioner (const NOX::Epetra::Vector &x, Teuchos::ParameterList &linearSolverParams, bool recomputeGraph) const
	Explicitly constructs a preconditioner based on the solution vector x and the parameter list p.
virtual bool	destroyPreconditioner () const
	Deletes all objects associated with the chosen preconditioner. This is called during linear solves and when the solution vector changes to reset the preconditioner.
virtual bool	recomputePreconditioner (const NOX::Epetra::Vector &x, Teuchos::ParameterList &linearSolverParams) const
	Recalculates the preconditioner using an already allocated graph.
virtual PreconditionerReusePolicyType	getPreconditionerPolicy (bool advanceReuseCounter=true)
	Evaluates the preconditioner policy at the current state.
virtual void	reset (Teuchos::ParameterList &linearSolverParams)
	Reset the linear solver parameters.
virtual Teuchos::RCP< NOX::Epetra::Scaling >	getScaling ()
	Get the scaling object.
void	resetScaling (const Teuchos::RCP< NOX::Epetra::Scaling > &s)
	Sets the diagonal scaling vector(s) used in scaling the linear system. See NOX::Epetra::Scaling for details on how to specify scaling of the linear system.
virtual bool	computeJacobian (const NOX::Epetra::Vector &x)
	Compute the Jacobian.
virtual Teuchos::RCP< const NOX::Epetra::Interface::Jacobian >	getJacobianInterface () const
	NOX::Interface::Jacobian accessor.
virtual Teuchos::RCP< const NOX::Epetra::Interface::Preconditioner >	getPrecInterface () const
	NOX::Interface::Preconditioiner accessor.
virtual bool	isPreconditionerConstructed () const
	Indicates whether a preconditioner has been constructed.
virtual bool	hasPreconditioner () const
	Indicates whether the linear system has a preconditioner.
virtual Teuchos::RCP< const Epetra_Operator >	getJacobianOperator () const
	Jacobian Epetra_Operator accessor.
virtual Teuchos::RCP< Epetra_Operator >	getJacobianOperator ()
	Jacobian Epetra_Operator accessor.
virtual Teuchos::RCP< const Epetra_Operator >	getPrecOperator () const
	Preconditioner Epetra_Operator accessor (only the base matrix if using an internal preconditioner - aztecoo or ifpack).
virtual Teuchos::RCP< const Epetra_Operator >	getGeneratedPrecOperator () const
	Return preconditioner operator generated and stored in AztecOO.
virtual Teuchos::RCP< Epetra_Operator >	getGeneratedPrecOperator ()
	Return preconditioner operator generated and stored in AztecOO.
double	getTimeCreatePreconditioner () const
	Returns the total time (sec.) spent in createPreconditioner().
double	getTimeApplyJacobianInverse () const
	Returns the total time (sec.) spent in applyJacobianInverse().
virtual void	setJacobianOperatorForSolve (const Teuchos::RCP< const Epetra_Operator > &solveJacOp)
	Set Jacobian operator for solve.
virtual void	setPrecOperatorForSolve (const Teuchos::RCP< const Epetra_Operator > &solvePrecOp)
	Set preconditioner operator for solve.
Protected Types
	EpetraOperator
	An Epetra_Operator derived object.
	EpetraRowMatrix
	An Epetra_RowMatrix derived object.
	EpetraVbrMatrix
	An Epetra_VbrMatrix object.
	EpetraCrsMatrix
	An Epetra_CrsMatrix object.
	UseJacobian
	SeparateMatrix
	None_
	AztecOO_
	Ifpack_
	NewIfpack_
	ML_
	UserDefined_
enum	OperatorType { EpetraOperator, EpetraRowMatrix, EpetraVbrMatrix, EpetraCrsMatrix }
	List of types of epetra objects that can be used for the Jacobian and/or Preconditioner. More...
enum	PreconditionerMatrixSourceType { UseJacobian, SeparateMatrix }
	Source of the RowMatrix if using an AztecOO native preconditioner.
enum	PreconditionerType { None_, AztecOO_, Ifpack_, NewIfpack_, ML_, UserDefined_ }
Protected Member Functions
virtual void	setAztecOptions (Teuchos::ParameterList &lsParams, AztecOO &aztec) const
	Parse the parameter list and set the corresponding options in the AztecOO solver onject.
virtual bool	createJacobianOperator (Teuchos::ParameterList &printParams, Teuchos::ParameterList &lsParams, const Teuchos::RCP< NOX::Epetra::Interface::Required > &iReq, const NOX::Epetra::Vector &cloneVector)
	Creates an internally owned Epetra_Operator for the Jacobian.
virtual bool	createPrecOperator (Teuchos::ParameterList &printParams, Teuchos::ParameterList &lsParams, const Teuchos::RCP< NOX::Epetra::Interface::Required > &iReq, const NOX::Epetra::Vector &cloneVector)
	Creates an internally owned Epetra_Operator for the Preconditioner.
virtual bool	checkPreconditionerValidity ()
	Checks to make sure that the supplied operators are valid for the requested preconditioning options set in the parameter list.
virtual bool	createIfpackPreconditioner (Teuchos::ParameterList &p) const
	Allocates the objects required for using ifpack preconditioners (NOX::Epetra::Group::ifpackGraph and NOX::Epetra::Group::ifpackPreconditioner). This is called from NOX::Epetra::Group::computePreconditioner().
virtual bool	createNewIfpackPreconditioner (Teuchos::ParameterList &p) const
	Allocates the objects required for using the new version of ifpack preconditioners via the Ifpack Create factory. This is called from NOX::Epetra::Group::computePreconditioner().
virtual OperatorType	getOperatorType (const Epetra_Operator &o)
	Returns the type of operator that is passed into the group constructors.
virtual void	setAztecOOJacobian () const
	Sets the epetra Jacobian operator in the AztecOO object.
virtual void	setAztecOOPreconditioner () const
	Sets the epetra Preconditioner operator in the AztecOO object.
virtual void	throwError (const string &functionName, const string &errorMsg) const
virtual void	precError (int error_code, const std::string &nox_function, const std::string &prec_type, const std::string &prec_function) const
	Prints a warning for ifpack preconditioner failures (error_code != 0).
Protected Attributes
NOX::Utils	utils
	Printing Utilities object.
Teuchos::RCP< NOX::Epetra::Interface::Jacobian >	jacInterfacePtr
	Reference to the user supplied Jacobian interface functions.
OperatorType	jacType
	Type of operator for the Jacobian.
Teuchos::RCP< Epetra_Operator >	jacPtr
	Pointer to the Jacobian operator.
Teuchos::RCP< NOX::Epetra::Interface::Preconditioner >	precInterfacePtr
	Reference to the user supplied preconditioner interface functions.
OperatorType	precType
	Type of operator for the preconditioner.
Teuchos::RCP< Epetra_Operator >	precPtr
	Pointer to the preconditioner operator.
PreconditionerMatrixSourceType	precMatrixSource
PreconditionerType	precAlgorithm
Teuchos::RCP< AztecOO >	aztecSolverPtr
	Aztec solver object.
Teuchos::RCP< Ifpack_IlukGraph >	ifpackGraphPtr
	Stores the ifpack graph. Mutable since the applyRightPreconditioner() is a const method.
Teuchos::RCP< Ifpack_CrsRiluk >	ifpackPreconditionerPtr
	Stores the ifpack preconditioner. Mutable since the applyRightPreconditioner() is a const method.
Teuchos::RCP< Ifpack_Preconditioner >	newIfpackPreconditionerPtr
	Stores the new ifpack preconditioner. Mutable since the applyRightPreconditioner() is a const method.
Teuchos::RCP< NOX::Epetra::Scaling >	scaling
	Scaling object supplied by the user.
Teuchos::RCP< NOX::Epetra::Vector >	tmpVectorPtr
	An extra temporary vector, only allocated if needed.
double	conditionNumberEstimate
bool	isPrecConstructed
	True if the preconditioner has been computed.
bool	outputSolveDetails
	If set to true, solver information is printed to the "Output" sublist of the "Linear Solver" list.
bool	zeroInitialGuess
	Zero out the initial guess for linear solves performed through applyJacobianInverse calls (i.e. zero out the result vector before the linear solve).
bool	manualScaling
	Stores the parameter "Compute Scaling Manually".
PreconditionerReusePolicyType	precReusePolicy
	Policy for how to handle the preconditioner between nonlineaer iterations.
int	precQueryCounter
	Counter for number of times called since reset or construction.
int	maxAgeOfPrec
	Parameter to determine whether or not to recompute Preconditioner.
Epetra_Time	timer
	Epetra_Time object.
double	timeCreatePreconditioner
	Total time spent in createPreconditioner (sec.).
double	timeApplyJacbianInverse
	Total time spent in applyJacobianInverse (sec.).
Teuchos::RCP< Epetra_Operator >	solvePrecOpPtr
	Preconditioner operator that will be used in solves.
bool	throwErrorOnPrecFailure
	If true, any preconditioner error will cause a throw instead of a warning.

Detailed Description

Concrete implementation of NOX::Epetra::LinearSolver for AztecOO.

This solver provides the linear algebra services provided through the AztecOO parallel iterative linear solver.

The NOX::Epetra::LinearSystemAztecOO object provides a flexible and efficient way to interface an Epetra based application code to the Aztec linear solver. This class handles construction of both the preconditioners and AztecOO solver. All options are determined through parameter lists and the basic constructors.

Constructing a Linear System

There are four different constructors that can be used. The difference between constructors is based on whether the user supplies a Jacobian, a preconditioner, neither or both.

If a Jacobian is not supplied then this object can create an internally constructed Jacobian based on a Finite Difference or Matrif-Free object. The user can specify which type of object to use by setting the parameter "Jacobian Operator" in the parameter list. The choices are "Matrix-Free" or "Finite Difference".

The user can supply their own preconditioner as an Epetra_Operator, or they can supply their own matrix (an Epetra_RowMatrix derived object) that can be used by one of the internal preconditioner libraries (currently aztecoo or ifpack). If they supply their own preconditioner the object must implement the Epetra_Operator::ApplyInverse method. This is the method called during the linear solve to introduce preconditoning into aztecoo. If the user supplies a matrix to be used with an internal preconditioner, it must be derived from the Epetra_RowMatrix class and must implement all functionality in the Epetra_RowMatrix. If a Preconditioner is not supplied, then this object can create an internal preconditioner matrix by finite differencing or it can use the Jacobian operator if the Jacobian derives from the Epetra_RowMatrix class. The user can specify which type of object to use by setting the parameter "Preconditioner Operator" in the parameter list. The choices are "Use Jacobian" or "Finite Difference".

The Jacobian and preconditioner each require an interface to update the state of the operator with respect to the solution vector and any other parameters. There are three interfaces that can be implemented, NOX::Epetra::Interface::Required, NOX::Epetra::Interface::Jacobian, and NOX::Epetra::Interface::Preconditioner.

NOX::Epetra::Interface::Required supplies the computeF() function so codes can tell NOX what the nonlinear equations are. This is the minimum requirement to run nox through the epetra interface. LinearSolverAztecOO requires this in some constructors so that if a Jacobian or preconditoner is not supplied, it will use computeF from the Required interface to estimate the Jacobian or preconditioner via finite differences or directional derivatives.

NOX::Epetra::Interface::Jacobian is used for updating a user supplied Jacobian opertor with respect to the solution vector and any other parameters. It is required only in constructors in which a user supplies a Jacobian operator.

NOX::Epetra::Interface::Preconditioner is used for updating a user supplied preconditioner opertor/matrix with respect to the solution vector and any other parameters. It is required only in constructors in which a user supplies a preconditioner operator.

"Linear Solver" sublist parameters

A Teuchos::ParameterList called linearSolverParams is required in the various constructors and during some method calls such as applyJacobianInverse() and applyRightPreconditioning(). Typically, this list is the "Linear Solver" sublist found in the nox parameter list. The following parameters can be set in the linear solver sublist and are vaild for the NOX::Epetra::LinearSolverAztecOO object:

"Aztec Solver" - Determine the iterative technique used in the solve. The following options are valid:
- "GMRES" - Restarted generalized minimal residual (default).
- "CG" - Conjugate gradient.
- "CGS" - Conjugate gradient squared.
- "TFQMR" - Transpose-free quasi-minimal reasidual.
- "BiCGStab" - Bi-conjugate gradient with stabilization.
- "LU" - Sparse direct solve (single processor only).
"Size of Krylov Subspace" - When using restarted GMRES this sets the maximum size of the Krylov subspace (defaults to 300).
"Orthogonalization" - The orthogonalization routine used for the Gram-Schmidt orthogonalization procedure in Aztec. The following options are valid:
- "Classical" - (default).
- "Modified"
"Convergence Test" - Algorithm used to calculate the residual that is used for determining the convergence of the linear solver. See the Aztec 2.1 manual for more information. The following options are valid:
- "r0" - (default)
- "rhs"
- "norm"
- "no scaling"
- "sol"
"Tolerance" - Tolerance used by AztecOO to determine if an iterative linear solve has converged.
"Ill-Conditioning Threshold" - If the upper hessenberg matrix during GMRES generates a condition number greater than this parameter value, aztec will exit the linear solve returning the it's current solution. The default is 1.0e11.
"Preconditioner Iterations" - Number of iterations an AztecOO_Operator should take when solving the preconditioner. This is only used if an AztecOO preconditioner is used and the solver makes a call to NOX::Epetra::Group::applyRightPreconditioning(). This is NOT a recomended approach.
"Max Iterations" - maximum number of iterations in the linear solve. Default is 400.
"Zero Initial Guess" - boolean. Zero out the initial guess for linear solves performed through applyJacobianInverse calls (i.e. zero out the result vector before the linear solve). Defaults to false.
"Throw Error on Prec Failure" - boolean. If set to true, an exception will be thrown if the preconditioner fails to initialize or recompute/refactor. If set to false, a warning will br printed if the NOX::Utils::Warning is enabled in the printing utilities (NOX::Utils). Defaults to true.
"Output Frequency" - number of linear solve iterations between output of the linear solve residual. Takes an integer, or one of the AztecOO flags: AZ_none, AZ_last, or AZ_all as a value. Defaults to AZ_last.
"Jacobian Operator" - When a constructor does not require a Jacobian operator, the linear system will create a default operator using:
- "Matrix-Free" (default)
- "Finite Difference"
"Preconditioner" - Sets the choice of the preconditioner to use during linear solves. The validity of the choice of preconditioner will depend on the types of operators that are available for the Jacobian and preconditioner. NOTE: This flag will override any constructor details. For example, if you supply a preconditioner operator in the constructor, it will not be used if this flag is set to "None". If you supply an Epetra_Operator for the preconditioner but the "Preconditioner" flag is set to "AztecOO" (this requires an Epetra_RowMatrix for the preconditioner operator), this object will exit with a failure. The valid options and any requirements on the operator type are listed below:
- "None" - No preconditioning. (default)
- "AztecOO" - AztecOO internal preconditioner. This requires a preconditioner operator that derives from the Epetra_RowMatrix class.
- "Ifpack" - Ifpack internal preconditioner. This requires a preconditioner object that derives from the Epetra_RowMatrix class or it can use a Jacobian if the Jacobian derives from an Epetra_RowMatrix. This option is deprecated. Please use "New Ifpack".
- "New Ifpack" - Ifpack internal preconditioner. This requires a preconditioner object that derives from the Epetra_RowMatrix class or it can use a Jacobian if the Jacobian derives from an Epetra_RowMatrix.
- "User Defined" - The user supplies an Epetra_Operator derived class. Users must implement at a minimum the ApplyInverse() function of the Epetra_Operator class since preconditioning of vectors is accomplished through calls to this method.
"Jacobian Operator" - If a constructor is used that does not supply a Jacobian operator, nox will create an internal Jacobian operator. This flag is ONLY valid in such cases. This will determine which Operator is used:
- "Matrix-Free" - Create a NOX::Epetra::MatrixFree object.
- "Finite Difference" - Create a NOX::Epetra::FiniteDifference object.
"Preconditioner Operator" - If a constructor is used that does not supply a preconditioner operator, nox will create an internal preconditioner operator. This flag is ONLY valid in such cases. This will determine which Operator is used:
- "Use Jacobian" - Use the Jacobian Operator (it must be an Epetra_RowMatrix derived object).
- "Finite Difference" - Create a NOX::Epetra::FiniteDifference object.
"Aztec Preconditioner" - If the "Preconditioner" flag is set to "AztecOO" then the specific AztecOO preconditioner is specified with this flag. Currently supported preconditioners and their corresponding parameters that can be set are shown below (See the Aztec 2.1 manual for more information):
- "ilu" - ilu preconditioning. This choice allows the following additional parameters to be specified:
  - "Overlap" - defaults to 0
  - "Graph Fill" - defaults to 0
- "ilut" - ilut preconditioning. This choice allows the following additional parameters to be specified:
  - "Overlap" - defaults to 0
  - "Fill Factor" - defaults to 1.0
  - "Drop Tolerance" - defaults to 1.0e-12
- "Jacobi" - k step Jacobi where k is set by the "Steps" flag:
  - "Steps" - defaults to 3.
- "Symmetric Gauss-Siedel" - Non-overlapping domain decomposition k step symmetric Gauss-Siedel where k is set by the "Steps" flag:
  - "Steps" - defaults to 3.
- "Polynomial" - Neumann polynomial with order set by the parameter:
  - "Polynomial Order" - defaults to 3.
- "Least-squares Polynomial" - Least-squares polynomial with order set by the parameter:
  - "Polynomial Order" - defaults to 3.
"Ifpack" - If the "Preconditioner" flag is set to "New Ifpack" then any of the options supported by the Ifpack Create factory can be specified using a Teuchos::ParameterList containing the Ifpack options and then setting this as a parameter named "Ifpack" in the "Linear Solver" sublist.
"ML" - If the "Preconditioner" flag is set to "ML" then any of the options supported by the ML factory can be specified using a Teuchos::ParameterList containing the ML options and then setting this as a parameter named "ML" in the "Linear Solver" sublist.
"Preconditioner Reuse Policy" - (string) Allows the user to set how and when the preconditioner should be computed. This flag supports native Aztec, Ifpack and ML preconditioners. There are three options:
- "Rebuild" - The "Rebuild" option always completely destroys and then rebuilds the preconditioner each time a linear solve is requested.
- "Reuse" - The group/linear solver will not recompute the preconditioner even if the group's solution vector changes. It just blindly reuses what has been constructed. This turns off control of preconditioner recalculation. This is a dangerous condition but can really speed up the computations if the user knows what they are doing. We don't recommend users trying this.
- "Recompute" - Recomputes the preconditioner, but will try to efficiently reuse any objects that don't need to be destroyed. How efficient the "Recompute" option is depends on the type of preconditioner. For example if we are using ILU from the Ifpack library, we would like to not destroy and reallocate the graph each solve. With this option, we tell Ifpack to reuse the graph from last time - e.g the sparisty pattern has not changed between applications of the preconditioner.
"Max Age Of Prec" - (int) If the "Preconditioner Reuse Policy" is set to "Reuse", this integer tells the linear system how many times to reuse the preconditioner before rebuilding it. Defaults to 1.
"RCM Reordering" - Enables RCM reordering in conjunction with domain decomp incomplete factorization preconditioning. The following options are valid:
- "Disabled" - (default).
- "Enabled"
"Use Adaptive Linear Solve" - Enables the use of AztecOO's AdaptiveIterate() method instead of calling the Iterate() method. This causes the preconditioning matrix to be modified to make the linear solves easier. AztecOO will attempt to solve the linear system multiple times now and if the solves are failing it will modify the preconditioner and try again. Boolean value, defaults to false. NOTE: This only works for internal Aztec preconditioners! The "Preconditioning" parameter must be set to "AztecOO: Jacobian Matrix" or "AztecOO: User RowMatrix". (NOTE: This parameter is currently NOT supported)
"Max Adaptive Solve Iterations" - (integer) Maximum number of attempts that the linear solver will make when trying to solve a linear system. Defaults to 5. (NOTE: This parameter is currently NOT supported)
"Compute Scaling Manually" - (boolean) The linear system can be scaled if a NOX::Epetra::Scaling object is supplied to LinearSystemAztecOO. When to compute the scaling can be handled either manually by the user, or this object can automatically compute the scaling prior to a linear solve. By setting this flag to true, the user will call NOX::Epetra::Scaling::computeScaling() manually - on their own! Setting this to false means the LinearSystemAztecOO object will call the computeScaling function right before it applies the scaling to the matrix in the applyJacobianInverse function. Default is true (user will call compute scaling).
"Output Solver Details" - (boolean) Write the output sublist below to the parameter list after each linear solve. default is true.
"Write Linear System" - (boolean) If set to true, the linear system (Epetra_Map, Jacobian, LHS and RHS) is printed to a set of files in matrix market format. This option requires building nox with the flag --enable-nox-debug and building the EpetraExt library.
"Write Linear System File Prefix" - (string) If writing of the linear system is enabled (see above parameter) users can change the name of the output file prefix. The default is "NOX_LinSys". This option requires building nox with the flag --enable-nox-debug and building the EpetraExt library.

"Output" sublist

The parameter list passed in during calls to ApplyJacobianInverse() will have an "Output" sublist created that contains the following parameters if the flag "Output Solver Details" is set to true:

"Acheived Tolerance" - Actual tolerance achieved by the linear solver computed via the convergence test requested.
"Number of Linear Iterations" - Number of iterations used by the linear solver in the last call to applyJacobianInverse
"Total Number of Linear Iterations" - Total number of linear solve iterations performed by groups that have used this input list

Member Enumeration Documentation

enum NOX::Epetra::LinearSystemAztecOO::OperatorType [protected]

List of types of epetra objects that can be used for the Jacobian and/or Preconditioner.

Enumerator:

EpetraOperator	An Epetra_Operator derived object.
EpetraRowMatrix	An Epetra_RowMatrix derived object.
EpetraVbrMatrix	An Epetra_VbrMatrix object.
EpetraCrsMatrix	An Epetra_CrsMatrix object.

Constructor & Destructor Documentation

NOX::Epetra::LinearSystemAztecOO::LinearSystemAztecOO	(	Teuchos::ParameterList &	printingParams,
		Teuchos::ParameterList &	linearSolverParams,
		const Teuchos::RCP< NOX::Epetra::Interface::Required > &	iReq,
		const NOX::Epetra::Vector &	cloneVector,
		const Teuchos::RCP< NOX::Epetra::Scaling >	scalingObject = `Teuchos::null`
	)

Constructor with no Operators.

Jacobian Operator will be constructed internally based on the parameter "Jacobian Operator". Defaults to using a NOX::Epetra::MatrixFree object.

NOX::Epetra::LinearSystemAztecOO::LinearSystemAztecOO	(	Teuchos::ParameterList &	printingParams,
		Teuchos::ParameterList &	linearSolverParams,
		const Teuchos::RCP< NOX::Epetra::Interface::Required > &	iReq,
		const Teuchos::RCP< NOX::Epetra::Interface::Jacobian > &	iJac,
		const Teuchos::RCP< Epetra_Operator > &	J,
		const NOX::Epetra::Vector &	cloneVector,
		const Teuchos::RCP< NOX::Epetra::Scaling >	scalingObject = `Teuchos::null`
	)

Constructor with a user supplied Jacobian Operator only.

Either there is no preconditioning or the preconditioner will be used/created internally. The Jacobian (if derived from an Epetra_RowMatrix class can be used with an internal preconditioner. See the parameter key "Preconditioner Operator" for more details.

NOX::Epetra::LinearSystemAztecOO::LinearSystemAztecOO	(	Teuchos::ParameterList &	printingParams,
		Teuchos::ParameterList &	linearSolverParams,
		const Teuchos::RCP< NOX::Epetra::Interface::Required > &	i,
		const Teuchos::RCP< NOX::Epetra::Interface::Preconditioner > &	iPrec,
		const Teuchos::RCP< Epetra_Operator > &	M,
		const NOX::Epetra::Vector &	cloneVector,
		const Teuchos::RCP< NOX::Epetra::Scaling >	scalingObject = `Teuchos::null`
	)

Constructor with a user supplied Preconditioner Operator only.

Jacobian operator will be constructed internally based on the parameter "Jacobian Operator" in the parameter list. See the parameter key "Jacobian Operator" for more details. Defaults to using a NOX::Epetra::MatrixFree object.

NOX::Epetra::LinearSystemAztecOO::LinearSystemAztecOO	(	Teuchos::ParameterList &	printingParams,
		Teuchos::ParameterList &	linearSolverParams,
		const Teuchos::RCP< NOX::Epetra::Interface::Jacobian > &	iJac,
		const Teuchos::RCP< Epetra_Operator > &	J,
		const Teuchos::RCP< NOX::Epetra::Interface::Preconditioner > &	iPrec,
		const Teuchos::RCP< Epetra_Operator > &	M,
		const NOX::Epetra::Vector &	cloneVector,
		const Teuchos::RCP< NOX::Epetra::Scaling >	scalingObject = `Teuchos::null`
	)

Constructor with user supplied separate objects for the Jacobian (J) and Preconditioner (M). linearSolverParams is the "Linear Solver" sublist of parameter list.

Member Function Documentation

bool NOX::Epetra::LinearSystemAztecOO::applyJacobian	(	const NOX::Epetra::Vector &	input,
		NOX::Epetra::Vector &	result
	)			const `[virtual]`

Applies Jacobian to the given input vector and puts the answer in the result.

Computes

$v = J u,$

where $J$ is the Jacobian, $u$ is the input vector, and $v$ is the result vector. Returns true if successful.

Implements NOX::Epetra::LinearSystem.

bool NOX::Epetra::LinearSystemAztecOO::applyJacobianInverse	(	Teuchos::ParameterList &	linearSolverParams,
		const NOX::Epetra::Vector &	input,
		NOX::Epetra::Vector &	result
	)			`[virtual]`

Applies the inverse of the Jacobian matrix to the given input vector and puts the answer in result.

Computes

$v = J^{-1} u,$

where $J$ is the Jacobian, $u$ is the input vector, and $v$ is the result vector.

The parameter list contains the linear solver options.

Implements NOX::Epetra::LinearSystem.

bool NOX::Epetra::LinearSystemAztecOO::applyJacobianTranspose	(	const NOX::Epetra::Vector &	input,
		NOX::Epetra::Vector &	result
	)			const `[virtual]`

Applies Jacobian-Transpose to the given input vector and puts the answer in the result.

Computes

$v = J^T u,$

where $J$ is the Jacobian, $u$ is the input vector, and $v$ is the result vector. Returns true if successful.

Implements NOX::Epetra::LinearSystem.

bool NOX::Epetra::LinearSystemAztecOO::applyRightPreconditioning	(	bool	useTranspose,
		Teuchos::ParameterList &	linearSolverParams,
		const NOX::Epetra::Vector &	input,
		NOX::Epetra::Vector &	result
	)			const `[virtual]`

Apply right preconditiong to the given input vector.

Let $M$ be a right preconditioner for the Jacobian $J$ ; in other words, $M$ is a matrix such that

$JM \approx I.$

Compute

$u = M^{-1} v,$

where $u$ is the input vector and $v$ is the result vector.

If useTranspose is true, then the transpose of the preconditioner is applied:

$u = {M^{-1}}^T v,$

The transpose preconditioner is currently only required for Tensor methods.

The parameter list contains the linear solver options.

Implements NOX::Epetra::LinearSystem.

bool NOX::Epetra::LinearSystemAztecOO::createPreconditioner	(	const NOX::Epetra::Vector &	x,
		Teuchos::ParameterList &	linearSolverParams,
		bool	recomputeGraph
	)			const `[virtual]`

Explicitly constructs a preconditioner based on the solution vector x and the parameter list p.

The user has the option of recomputing the graph when a new preconditioner is created. The NOX::Epetra::Group controls the isValid flag for the preconditioner and will control when to call this.

Implements NOX::Epetra::LinearSystem.

Teuchos::RCP< const Epetra_Operator > NOX::Epetra::LinearSystemAztecOO::getGeneratedPrecOperator ( ) const [virtual]

Return preconditioner operator generated and stored in AztecOO.

Note: This should only be called if hasPreconditioner() returns true.

Implements NOX::Epetra::LinearSystem.

NOX::Epetra::LinearSystemAztecOO::OperatorType NOX::Epetra::LinearSystemAztecOO::getOperatorType ( const Epetra_Operator & o ) [protected, virtual]

Returns the type of operator that is passed into the group constructors.

Uses dynamic casting to identify the underlying object type.

NOX::Epetra::LinearSystem::PreconditionerReusePolicyType NOX::Epetra::LinearSystemAztecOO::getPreconditionerPolicy ( bool advanceReuseCounter = true ) [virtual]

Evaluates the preconditioner policy at the current state.

NOTE: This can change values between nonlienar iterations. It is not a static value.

Implements NOX::Epetra::LinearSystem.

bool NOX::Epetra::LinearSystemAztecOO::recomputePreconditioner	(	const NOX::Epetra::Vector &	x,
		Teuchos::ParameterList &	linearSolverParams
	)			const `[virtual]`

Recalculates the preconditioner using an already allocated graph.

Use this to compute a new preconditioner while using the same graph for the preconditioner. This avoids deleting and reallocating the memory required for the preconditioner and results in a big speed-up for large-scale jobs.

Implements NOX::Epetra::LinearSystem.

void NOX::Epetra::LinearSystemAztecOO::setAztecOOJacobian ( ) const [protected, virtual]

Sets the epetra Jacobian operator in the AztecOO object.

Makes a call to SetUserMatrix or SetUserOperator to set the Jacobian.

void NOX::Epetra::LinearSystemAztecOO::setAztecOOPreconditioner ( ) const [protected, virtual]

Sets the epetra Preconditioner operator in the AztecOO object.

Makes a call to SetUserOperator. This must be done AFTER the Jacobian matrix/operators is set by setAztecOOJacobian(), otherwise the aztec object may ignore this operation.

void NOX::Epetra::LinearSystemAztecOO::setPrecOperatorForSolve ( const Teuchos::RCP< const Epetra_Operator > & solvePrecOp ) [virtual]

Set preconditioner operator for solve.

Note: This should only be called if hasPreconditioner() returns true.

Implements NOX::Epetra::LinearSystem.

The documentation for this class was generated from the following files:

NOX_Epetra_LinearSystem_AztecOO.H
NOX_Epetra_LinearSystem_AztecOO.C

Generated on Wed May 12 21:26:27 2010 for NOX by

1.4.7

NOX::Epetra::LinearSystemAztecOO Class Reference

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation