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 C++ includes: NOX_Epetra_LinearSystem_AztecOO.H
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> iReq, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO __init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> iReq, Teuchos::RCP<(NOX::Epetra::Interface::Jacobian)> iJac, Teuchos::RCP<(Epetra_Operator)> J, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO __init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> i, Teuchos::RCP<(NOX::Epetra::Interface::Preconditioner)> iPrec, Teuchos::RCP<(Epetra_Operator)> M, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO __init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Jacobian)> iJac, Teuchos::RCP<(Epetra_Operator)> J, Teuchos::RCP<(NOX::Epetra::Interface::Preconditioner)> iPrec, Teuchos::RCP<(Epetra_Operator)> M, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> iReq, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO __init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> iReq, Teuchos::RCP<(NOX::Epetra::Interface::Jacobian)> iJac, Teuchos::RCP<(Epetra_Operator)> J, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO __init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Required)> i, Teuchos::RCP<(NOX::Epetra::Interface::Preconditioner)> iPrec, Teuchos::RCP<(Epetra_Operator)> M, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO __init__(self, ParameterList printingParams, ParameterList linearSolverParams, Teuchos::RCP<(NOX::Epetra::Interface::Jacobian)> iJac, Teuchos::RCP<(Epetra_Operator)> J, Teuchos::RCP<(NOX::Epetra::Interface::Preconditioner)> iPrec, Teuchos::RCP<(Epetra_Operator)> M, Vector cloneVector, Teuchos::RCP<(NOX::Epetra::Scaling)> scalingObject = Teuchos::null) -> LinearSystemAztecOO 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyJacobian | ( | self, | ||
args | ||||
) |
applyJacobian(self, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. Computes \\[ v = J u, \\] where $J$ is the Jacobian, $u$ is the input vector, and $v$ is the result vector. Returns true if successful.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyJacobian | ( | self, | ||
args | ||||
) |
applyJacobian(self, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. Computes \\[ v = J u, \\] where $J$ is the Jacobian, $u$ is the input vector, and $v$ is the result vector. Returns true if successful.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyJacobianInverse | ( | self, | ||
args | ||||
) |
applyJacobianInverse(self, ParameterList linearSolverParams, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyJacobianInverse | ( | self, | ||
args | ||||
) |
applyJacobianInverse(self, ParameterList linearSolverParams, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyJacobianTranspose | ( | self, | ||
args | ||||
) |
applyJacobianTranspose(self, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyJacobianTranspose | ( | self, | ||
args | ||||
) |
applyJacobianTranspose(self, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyRightPreconditioning | ( | self, | ||
args | ||||
) |
applyRightPreconditioning(self, bool useTranspose, ParameterList linearSolverParams, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::applyRightPreconditioning(bool useTranspose, Teuchos::ParameterList &linearSolverParams, const NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::applyRightPreconditioning | ( | self, | ||
args | ||||
) |
applyRightPreconditioning(self, bool useTranspose, ParameterList linearSolverParams, Vector input, Vector nox_result) -> bool bool NOX::Epetra::LinearSystemAztecOO::applyRightPreconditioning(bool useTranspose, Teuchos::ParameterList &linearSolverParams, const NOX::Epetra::Vector &input, NOX::Epetra::Vector &result) const 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::computeJacobian | ( | self, | ||
args | ||||
) |
computeJacobian(self, Vector x) -> bool bool NOX::Epetra::LinearSystemAztecOO::computeJacobian(const NOX::Epetra::Vector &x) Compute the Jacobian.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::computeJacobian | ( | self, | ||
args | ||||
) |
computeJacobian(self, Vector x) -> bool bool NOX::Epetra::LinearSystemAztecOO::computeJacobian(const NOX::Epetra::Vector &x) Compute the Jacobian.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::createPreconditioner | ( | self, | ||
args | ||||
) |
createPreconditioner(self, Vector x, ParameterList linearSolverParams, bool recomputeGraph) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::createPreconditioner | ( | self, | ||
args | ||||
) |
createPreconditioner(self, Vector x, ParameterList linearSolverParams, bool recomputeGraph) -> bool bool NOX::Epetra::LinearSystemAztecOO::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. 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::destroyPreconditioner | ( | self, | ||
args | ||||
) |
destroyPreconditioner(self) -> bool bool NOX::Epetra::LinearSystemAztecOO::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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::destroyPreconditioner | ( | self, | ||
args | ||||
) |
destroyPreconditioner(self) -> bool bool NOX::Epetra::LinearSystemAztecOO::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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getGeneratedPrecOperator | ( | self, | ||
args | ||||
) |
getGeneratedPrecOperator(self) -> Teuchos::RCP<(q(const).Epetra_Operator)> getGeneratedPrecOperator(self) -> Teuchos::RCP<(Epetra_Operator)> Teuchos::RCP< Epetra_Operator > NOX::Epetra::LinearSystemAztecOO::getGeneratedPrecOperator() Return preconditioner operator generated and stored in AztecOO.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getGeneratedPrecOperator | ( | self, | ||
args | ||||
) |
getGeneratedPrecOperator(self) -> Teuchos::RCP<(q(const).Epetra_Operator)> getGeneratedPrecOperator(self) -> Teuchos::RCP<(Epetra_Operator)> Teuchos::RCP< Epetra_Operator > NOX::Epetra::LinearSystemAztecOO::getGeneratedPrecOperator() Return preconditioner operator generated and stored in AztecOO.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getJacobianInterface | ( | self, | ||
args | ||||
) |
getJacobianInterface(self) -> Teuchos::RCP<(q(const).NOX::Epetra::Interface::Jacobian)> Teuchos::RCP< const NOX::Epetra::Interface::Jacobian > NOX::Epetra::LinearSystemAztecOO::getJacobianInterface() const NOX::Interface::Jacobian accessor.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getJacobianInterface | ( | self, | ||
args | ||||
) |
getJacobianInterface(self) -> Teuchos::RCP<(q(const).NOX::Epetra::Interface::Jacobian)> Teuchos::RCP< const NOX::Epetra::Interface::Jacobian > NOX::Epetra::LinearSystemAztecOO::getJacobianInterface() const NOX::Interface::Jacobian accessor.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getJacobianOperator | ( | self, | ||
args | ||||
) |
getJacobianOperator(self) -> Teuchos::RCP<(q(const).Epetra_Operator)> getJacobianOperator(self) -> Teuchos::RCP<(Epetra_Operator)> Teuchos::RCP< Epetra_Operator > NOX::Epetra::LinearSystemAztecOO::getJacobianOperator() Jacobian Epetra_Operator accessor.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getJacobianOperator | ( | self, | ||
args | ||||
) |
getJacobianOperator(self) -> Teuchos::RCP<(q(const).Epetra_Operator)> getJacobianOperator(self) -> Teuchos::RCP<(Epetra_Operator)> Teuchos::RCP< Epetra_Operator > NOX::Epetra::LinearSystemAztecOO::getJacobianOperator() Jacobian Epetra_Operator accessor.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getPrecInterface | ( | self, | ||
args | ||||
) |
getPrecInterface(self) -> Teuchos::RCP<(q(const).NOX::Epetra::Interface::Preconditioner)> Teuchos::RCP< const NOX::Epetra::Interface::Preconditioner > NOX::Epetra::LinearSystemAztecOO::getPrecInterface() const NOX::Interface::Preconditioiner accessor.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getPrecInterface | ( | self, | ||
args | ||||
) |
getPrecInterface(self) -> Teuchos::RCP<(q(const).NOX::Epetra::Interface::Preconditioner)> Teuchos::RCP< const NOX::Epetra::Interface::Preconditioner > NOX::Epetra::LinearSystemAztecOO::getPrecInterface() const NOX::Interface::Preconditioiner accessor.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getPreconditionerPolicy | ( | self, | ||
args | ||||
) |
getPreconditionerPolicy(self, bool advanceReuseCounter = True) -> PreconditionerReusePolicyType NOX::Epetra::LinearSystem::PreconditionerReusePolicyType NOX::Epetra::LinearSystemAztecOO::getPreconditionerPolicy(bool advanceReuseCounter=true) Evaluates the preconditioner policy at the current state. NOTE: This can change values between nonlienar iterations. It is not a static value.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getPreconditionerPolicy | ( | self, | ||
args | ||||
) |
getPreconditionerPolicy(self, bool advanceReuseCounter = True) -> PreconditionerReusePolicyType NOX::Epetra::LinearSystem::PreconditionerReusePolicyType NOX::Epetra::LinearSystemAztecOO::getPreconditionerPolicy(bool advanceReuseCounter=true) Evaluates the preconditioner policy at the current state. NOTE: This can change values between nonlienar iterations. It is not a static value.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getPrecOperator | ( | self, | ||
args | ||||
) |
getPrecOperator(self) -> Teuchos::RCP<(q(const).Epetra_Operator)> Teuchos::RCP< const Epetra_Operator > NOX::Epetra::LinearSystemAztecOO::getPrecOperator() const Preconditioner Epetra_Operator accessor (only the base matrix if using an internal preconditioner - aztecoo or ifpack).
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getPrecOperator | ( | self, | ||
args | ||||
) |
getPrecOperator(self) -> Teuchos::RCP<(q(const).Epetra_Operator)> Teuchos::RCP< const Epetra_Operator > NOX::Epetra::LinearSystemAztecOO::getPrecOperator() const Preconditioner Epetra_Operator accessor (only the base matrix if using an internal preconditioner - aztecoo or ifpack).
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getScaling | ( | self, | ||
args | ||||
) |
getScaling(self) -> Teuchos::RCP<(NOX::Epetra::Scaling)> Teuchos::RCP< NOX::Epetra::Scaling > NOX::Epetra::LinearSystemAztecOO::getScaling() Get the scaling object.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getScaling | ( | self, | ||
args | ||||
) |
getScaling(self) -> Teuchos::RCP<(NOX::Epetra::Scaling)> Teuchos::RCP< NOX::Epetra::Scaling > NOX::Epetra::LinearSystemAztecOO::getScaling() Get the scaling object.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getTimeApplyJacobianInverse | ( | self, | ||
args | ||||
) |
getTimeApplyJacobianInverse(self) -> double double NOX::Epetra::LinearSystemAztecOO::getTimeApplyJacobianInverse() const Returns the total time (sec.) spent in applyJacobianInverse().
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getTimeApplyJacobianInverse | ( | self, | ||
args | ||||
) |
getTimeApplyJacobianInverse(self) -> double double NOX::Epetra::LinearSystemAztecOO::getTimeApplyJacobianInverse() const Returns the total time (sec.) spent in applyJacobianInverse().
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getTimeCreatePreconditioner | ( | self, | ||
args | ||||
) |
getTimeCreatePreconditioner(self) -> double double NOX::Epetra::LinearSystemAztecOO::getTimeCreatePreconditioner() const Returns the total time (sec.) spent in createPreconditioner().
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::getTimeCreatePreconditioner | ( | self, | ||
args | ||||
) |
getTimeCreatePreconditioner(self) -> double double NOX::Epetra::LinearSystemAztecOO::getTimeCreatePreconditioner() const Returns the total time (sec.) spent in createPreconditioner().
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::hasPreconditioner | ( | self, | ||
args | ||||
) |
hasPreconditioner(self) -> bool bool NOX::Epetra::LinearSystemAztecOO::hasPreconditioner() const Indicates whether the linear system has a preconditioner.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::hasPreconditioner | ( | self, | ||
args | ||||
) |
hasPreconditioner(self) -> bool bool NOX::Epetra::LinearSystemAztecOO::hasPreconditioner() const Indicates whether the linear system has a preconditioner.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::isPreconditionerConstructed | ( | self, | ||
args | ||||
) |
isPreconditionerConstructed(self) -> bool bool NOX::Epetra::LinearSystemAztecOO::isPreconditionerConstructed() const Indicates whether a preconditioner has been constructed.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::isPreconditionerConstructed | ( | self, | ||
args | ||||
) |
isPreconditionerConstructed(self) -> bool bool NOX::Epetra::LinearSystemAztecOO::isPreconditionerConstructed() const Indicates whether a preconditioner has been constructed.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::recomputePreconditioner | ( | self, | ||
args | ||||
) |
recomputePreconditioner(self, Vector x, ParameterList linearSolverParams) -> bool bool NOX::Epetra::LinearSystemAztecOO::recomputePreconditioner(const NOX::Epetra::Vector &x, Teuchos::ParameterList &linearSolverParams) const 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::recomputePreconditioner | ( | self, | ||
args | ||||
) |
recomputePreconditioner(self, Vector x, ParameterList linearSolverParams) -> bool bool NOX::Epetra::LinearSystemAztecOO::recomputePreconditioner(const NOX::Epetra::Vector &x, Teuchos::ParameterList &linearSolverParams) const 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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::reset | ( | self, | ||
args | ||||
) |
reset(self, ParameterList linearSolverParams) void NOX::Epetra::LinearSystemAztecOO::reset(Teuchos::ParameterList &linearSolverParams) Reset the linear solver parameters.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::reset | ( | self, | ||
args | ||||
) |
reset(self, ParameterList linearSolverParams) void NOX::Epetra::LinearSystemAztecOO::reset(Teuchos::ParameterList &linearSolverParams) Reset the linear solver parameters.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::resetScaling | ( | self, | ||
args | ||||
) |
resetScaling(self, Teuchos::RCP<(NOX::Epetra::Scaling)> s) void NOX::Epetra::LinearSystemAztecOO::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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::resetScaling | ( | self, | ||
args | ||||
) |
resetScaling(self, Teuchos::RCP<(NOX::Epetra::Scaling)> s) void NOX::Epetra::LinearSystemAztecOO::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.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::setJacobianOperatorForSolve | ( | self, | ||
args | ||||
) |
setJacobianOperatorForSolve(self, Teuchos::RCP<(q(const).Epetra_Operator)> solveJacOp) void NOX::Epetra::LinearSystemAztecOO::setJacobianOperatorForSolve(const Teuchos::RCP< const Epetra_Operator > &solveJacOp) Set Jacobian operator for solve.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::setJacobianOperatorForSolve | ( | self, | ||
args | ||||
) |
setJacobianOperatorForSolve(self, Teuchos::RCP<(q(const).Epetra_Operator)> solveJacOp) void NOX::Epetra::LinearSystemAztecOO::setJacobianOperatorForSolve(const Teuchos::RCP< const Epetra_Operator > &solveJacOp) Set Jacobian operator for solve.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::setPrecOperatorForSolve | ( | self, | ||
args | ||||
) |
setPrecOperatorForSolve(self, Teuchos::RCP<(q(const).Epetra_Operator)> solvePrecOp) void NOX::Epetra::LinearSystemAztecOO::setPrecOperatorForSolve(const Teuchos::RCP< const Epetra_Operator > &solvePrecOp) Set preconditioner operator for solve. Note: This should only be called if hasPreconditioner() returns true.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.
def PyTrilinos::NOX::Epetra::LinearSystemAztecOO::setPrecOperatorForSolve | ( | self, | ||
args | ||||
) |
setPrecOperatorForSolve(self, Teuchos::RCP<(q(const).Epetra_Operator)> solvePrecOp) void NOX::Epetra::LinearSystemAztecOO::setPrecOperatorForSolve(const Teuchos::RCP< const Epetra_Operator > &solvePrecOp) Set preconditioner operator for solve. Note: This should only be called if hasPreconditioner() returns true.
Reimplemented from PyTrilinos::NOX::Epetra::LinearSystem.