Home       Trees       Index       Help   
Package esys :: Package escript :: Module linearPDEs :: Class LinearPDE
[show private | hide private]
[frames | no frames]

Type LinearPDE

object --+
         |
        LinearPDE

Known Subclasses:
AdvectivePDE, Helmholtz, LameEquation, Poisson

This class is used to define a general linear, steady, second order PDE for an unknown function u on a given domain defined through a Domain object.

For a single PDE with a solution with a single component the linear PDE is defined in the following form:

-grad(A[j,l]*grad(u)[l]+B[j]u)[j]+C[l]*grad(u)[l]+D*u =-grad(X)[j,j]+Y

where grad(F) denotes the spatial derivative of F. Einstein's summation convention, ie. summation over indexes appearing twice in a term of a sum is performed, is used. The coefficients A, B, C, D, X and Y have to be specified through Data objects in the Function on the PDE or objects that can be converted into such Data objects. A is a rank two, B, C and X are rank one and D and Y are scalar.

The following natural boundary conditions are considered:

n[j]*(A[i,j]*grad(u)[l]+B[j]*u)+d*u=n[j]*X[j]+y

where n is the outer normal field calculated by getNormal of FunctionOnBoundary. Notice that the coefficients A, B and X are defined in the PDE. The coefficients d and y are each a scalar in the FunctionOnBoundary.

Constraints for the solution prescribing the value of the solution at certain locations in the domain. They have the form

u=r where q>0

r and q are each scalar where q is the characteristic function defining where the constraint is applied. The constraints override any other condition set by the PDE or the boundary condition.

The PDE is symmetrical if

A[i,j]=A[j,i] and B[j]=C[j]

For a system of PDEs and a solution with several components the PDE has the form

-grad(A[i,j,k,l]*grad(u[k])[l]+B[i,j,k]*u[k])[j]+C[i,k,l]*grad(u[k])[l]+D[i,k]*u[k] =-grad(X[i,j])[j]+Y[i]

A is a ramk four, B and C are each a rank three, D and X are each a rank two and Y is a rank one. The natural boundary conditions take the form:

n[j]*(A[i,j,k,l]*grad(u[k])[l]+B[i,j,k]*u[k])+d[i,k]*u[k]=n[j]*X[i,j]+y[i]

The coefficient d is a rank two and y is a rank one both in the FunctionOnBoundary. Constraints take the form

u[i]=r[i] where q[i]>0

r and q are each rank one. Notice that at some locations not necessarily all components must have a constraint.

The system of PDEs is symmetrical if

LinearPDE also supports solution discontinuities over a contact region in the domain. To specify the conditions across the discontinuity we are using the generalised flux J which is in the case of a systems of PDEs and several components of the solution defined as

J[i,j]=A[i,j,k,l]*grad(u[k])[l]+B[i,j,k]*u[k]-X[i,j]

For the case of single solution component and single PDE J is defined

J_{j}=A[i,j]*grad(u)[j]+B[i]*u-X[i]

In the context of discontinuities n denotes the normal on the discontinuity pointing from side 0 towards side 1 calculated from getNormal of FunctionOnContactZero. For a system of PDEs the contact condition takes the form

n[j]*J0[i,j]=n[j]*J1[i,j]=y_contact[i]- d_contact[i,k]*jump(u)[k]

where J0 and J1 are the fluxes on side 0 and side 1 of the discontinuity, respectively. jump(u), which is the difference of the solution at side 1 and at side 0, denotes the jump of u across discontinuity along the normal calcualted by jump. The coefficient d_contact is a rank two and y_contact is a rank one both in the FunctionOnContactZero or FunctionOnContactOne. In case of a single PDE and a single component solution the contact condition takes the form

n[j]*J0_{j}=n[j]*J1_{j}=y_contact-d_contact*jump(u)

In this case the the coefficient d_contact and y_contact are eaach scalar both in the FunctionOnContactZero or FunctionOnContactOne.
Method Summary
  __init__(self, domain, numEquations, numSolutions, debug)
initializes a new linear PDE
str __str__(self)
returns string representation of the PDE
  alteredCoefficient(self, name)
announce that coefficient name has been changed
Data applyOperator(self, u)
applies the operator of the PDE to a given u or the solution of PDE if u is not present.
Data checkSymmetry(self, verbose)
test the PDE for symmetry.
Data copyConstraint(self, u)
copies the constraint into u and returns u.
Data createCoefficient(self, name)
create a Data object corresponding to coefficient name
Data createCoefficientOfGeneralPDE(self, name)
returns a new instance of a coefficient for coefficient name of the general PDE
Data getCoefficient(self, name)
returns the value of the coefficient name
Data getCoefficientOfGeneralPDE(self, name)
return the value of the coefficient name of the general PDE.
int getDim(self)
returns the spatial dimension of the PDE
Domain getDomain(self)
returns the domain of the PDE
Data getFlux(self, u)
returns the flux J for a given u
FunctionSpace getFunctionSpaceForCoefficient(self, name)
return the FunctionSpace to be used for coefficient name
FunctionSpace getFunctionSpaceForCoefficientOfGeneralPDE(self, name)
return the FunctionSpace to be used for coefficient name of the general PDE
FunctionSpace getFunctionSpaceForEquation(self)
returns the FunctionSpace used to discretize the equation
FunctionSpace getFunctionSpaceForSolution(self)
returns the FunctionSpace used to represent the solution
int getNumEquations(self)
returns the number of equations
int getNumSolutions(self)
returns the number of unknowns
Operator getOperator(self)
provides access to the operator of the PDE
Data getResidual(self, u)
return the residual of u or the current solution if u is not present.
Data getRightHandSide(self)
provides access to the right hand side of the PDE
tuple of int getShapeOfCoefficient(self, name)
return the shape of the coefficient name
tuple of int getShapeOfCoefficientOfGeneralPDE(self, name)
return the shape of the coefficient name of the general PDE
Data getSolution(self, **options)
returns the solution of the PDE.
int getSolverMethod(self)
returns the solver method
string getSolverMethodName(self)
returns the name of the solver currently used
int getSolverPackage(self)
returns the package of the solver
tuple of Operator, and Data. getSystem(self)
return the operator and right hand side of the PDE
float getTolerance(self)
returns the tolerance set for the solution
bool hasCoefficient(self, name)
return True if name is the name of a coefficient
bool hasCoefficientOfGeneralPDE(self, name)
checks if name is a the name of a coefficient of the general PDE.
bool isSymmetric(self)
checks if symmetry is indicated.
bool isUsingLumping(self)
checks if matrix lumping is used a solver method
bool reduceEquationOrder(self)
return status for order reduction for equation
bool reduceSolutionOrder(self)
return status for order reduction for the solution
  resetCoefficients(self)
resets all coefficients to there default values.
  setDebugOff(self)
switches off debugging
  setDebugOn(self)
switches on debugging
  setReducedOrderForEquationOff(self)
switches off reduced order for equation representation
  setReducedOrderForEquationOn(self)
switches on reduced order for equation representation
  setReducedOrderForEquationTo(self, flag)
sets order for test functions according to flag
  setReducedOrderForSolutionOff(self)
switches off reduced order for solution representation
  setReducedOrderForSolutionOn(self)
switches on reduced order for solution representation
  setReducedOrderForSolutionTo(self, flag)
sets order for test functions according to flag
  setReducedOrderOff(self)
switches off reduced order for solution and equation representation
  setReducedOrderOn(self)
switches on reduced order for solution and equation representation
  setReducedOrderTo(self, flag)
sets order reduction for both solution and equation representation according to flag.
  setSolverMethod(self, solver, preconditioner)
sets a new solver
  setSolverPackage(self, package)
sets a new solver package
  setSymmetryOff(self)
removes the symmetry flag.
  setSymmetryOn(self)
sets the symmetry flag.
  setSymmetryTo(self, flag)
sets the symmetry flag to flag
  setTolerance(self, tol)
resets the tolerance for the solver method to tol where for an appropriate norm |.|
  setValue(self, **coefficients)
sets new values to coefficients
  trace(self, text)
print the text message if debugging is swiched on.
    Inherited from object
  __delattr__(...)
x.__delattr__('name') <==> del x.name
  __getattribute__(...)
x.__getattribute__('name') <==> x.name
  __hash__(x)
x.__hash__() <==> hash(x)
  __new__(T, S, ...)
T.__new__(S, ...) -> a new object with type S, a subtype of T
  __reduce__(...)
helper for pickle
  __reduce_ex__(...)
helper for pickle
  __repr__(x)
x.__repr__() <==> repr(x)
  __setattr__(...)
x.__setattr__('name', value) <==> x.name = value

Class Variable Summary
int AMG: algebraic multi grid
int BICGSTAB: The stabilized BiConjugate Gradient method.
int CGS: The conjugate gardient square method
int CHOLEVSKY: The direct solver based on LDLt factorization (can only be applied for symmetric PDEs)
int CR: The conjugate residual method
int DEFAULT: The default method used to solve the system of linear equations
int DIRECT: The direct solver based on LDU factorization
int GMRES: The Gram-Schmidt minimum residual method
int ILU0: The incomplete LU factorization preconditioner with no fill in
int ILUT: The incomplete LU factorization preconditioner with will in
int ITERATIVE: The default iterative solver
int JACOBI: The Jacobi preconditioner
int LUMPING: Matrix lumping.
int MINIMUM_FILL_IN: Reorder matrix to reduce fill-in during factorization
int MKL: Intel's MKL solver library
int NESTED_DISSECTION: Reorder matrix to improve load balancing during factorization
int NO_REORDERING: No matrix reordering allowed
int PASO: PASO solver package
int PCG: The preconditioned conjugate gradient method (can only be applied for symmetric PDEs)
int PRES20: Special GMRES with restart after 20 steps and truncation after 5 residuals
int RILU: recursive ILU
int SCSL: SGI SCSL solver library
float SMALL_TOLERANCE = 1e-13                                                                 
int SSOR: The symmetric overrealaxtion method
int UMFPACK: the UMFPACK library

Method Details

__init__(self, domain, numEquations=None, numSolutions=None, debug=False)
(Constructor)

initializes a new linear PDE
Parameters:
domain - domain of the PDE
           (type=Domain)
numEquations - number of equations. If numEquations==None the number of equations is exracted from the PDE coefficients.
numSolutions - number of solution components. If numSolutions==None the number of solution components is exracted from the PDE coefficients.
debug - if True debug informations are printed.
Overrides:
__builtin__.object.__init__

__str__(self)
(Informal representation operator)

returns string representation of the PDE
Returns:
a simple representation of the PDE
           (type=str)
Overrides:
__builtin__.object.__str__

alteredCoefficient(self, name)

announce that coefficient name has been changed
Parameters:
name - name of the coefficient enquired.
           (type=string)
Raises:
IllegalCoefficient - if name is not a coefficient of the PDE.

Note: if name is q or r, the method will not trigger a rebuilt of the system as constraints are applied to the solved system.

applyOperator(self, u=None)

applies the operator of the PDE to a given u or the solution of PDE if u is not present.
Parameters:
u - argument of the operator. It must be representable in elf.getFunctionSpaceForSolution(). If u is not present or equals None the current solution is used.
           (type=Data or None)
Returns:
image of u
           (type=Data)

checkSymmetry(self, verbose=True)

test the PDE for symmetry.
Parameters:
verbose - if equal to True or not present a report on coefficients which are breaking the symmetry is printed.
           (type=bool)
Returns:
True if the PDE is symmetric.
           (type=Data)

Note: This is a very expensive operation. It should be used for degugging only! The symmetry flag is not altered.

copyConstraint(self, u)

copies the constraint into u and returns u.
Parameters:
u - a function of rank 0 is a single PDE is solved and of shape (numSolution,) for a system of PDEs
           (type=Data)
Returns:
the input u modified by the constraints.
           (type=Data)

Warning: u is altered if it has the appropriate FunctionSpace

createCoefficient(self, name)

create a Data object corresponding to coefficient name
Returns:
a coefficient name initialized to 0.
           (type=Data)
Raises:
IllegalCoefficient - if name is not a coefficient of the PDE.

createCoefficientOfGeneralPDE(self, name)

returns a new instance of a coefficient for coefficient name of the general PDE
Parameters:
name - name of the coefficient requested.
           (type=string)
Returns:
a coefficient name initialized to 0.
           (type=Data)
Raises:
IllegalCoefficient - if name is not one of coefficients A, B, C, D, X, Y, d, y, d_contact, y_contact, r or q.

getCoefficient(self, name)

returns the value of the coefficient name
Parameters:
name - name of the coefficient requested.
           (type=string)
Returns:
the value of the coefficient name
           (type=Data)
Raises:
IllegalCoefficient - if name is not a coefficient of the PDE.

getCoefficientOfGeneralPDE(self, name)

return the value of the coefficient name of the general PDE.
Parameters:
name - name of the coefficient requested.
           (type=string)
Returns:
the value of the coefficient name
           (type=Data)
Raises:
IllegalCoefficient - if name is not one of coefficients A, B, C, D, X, Y, d, y, d_contact, y_contact, r or q.

Note: This method is called by the assembling routine it can be overwritten to map coefficients of a particular PDE to the general PDE.

getDim(self)

returns the spatial dimension of the PDE
Returns:
the spatial dimension of the PDE domain
           (type=int)

getDomain(self)

returns the domain of the PDE
Returns:
the domain of the PDE
           (type=Domain)

getFlux(self, u=None)

returns the flux J for a given u

J[i,j]=A[i,j,k,l]*grad(u[k])[l]+B[i,j,k]u[k]-X[i,j]

or

J[j]=A[i,j]*grad(u)[l]+B[j]u-X[j]
Parameters:
u - argument in the flux. If u is not present or equals None the current solution is used.
           (type=Data or None)
Returns:
flux
           (type=Data)

getFunctionSpaceForCoefficient(self, name)

return the FunctionSpace to be used for coefficient name
Parameters:
name - name of the coefficient enquired.
           (type=string)
Returns:
the function space to be used for coefficient name
           (type=FunctionSpace)
Raises:
IllegalCoefficient - if name is not a coefficient of the PDE.

getFunctionSpaceForCoefficientOfGeneralPDE(self, name)

return the FunctionSpace to be used for coefficient name of the general PDE
Parameters:
name - name of the coefficient enquired.
           (type=string)
Returns:
the function space to be used for coefficient name
           (type=FunctionSpace)
Raises:
IllegalCoefficient - if name is not one of coefficients A, B, C, D, X, Y, d, y, d_contact, y_contact, r or q.

getFunctionSpaceForEquation(self)

returns the FunctionSpace used to discretize the equation
Returns:
representation space of equation
           (type=FunctionSpace)

getFunctionSpaceForSolution(self)

returns the FunctionSpace used to represent the solution
Returns:
representation space of solution
           (type=FunctionSpace)

getNumEquations(self)

returns the number of equations
Returns:
the number of equations
           (type=int)
Raises:
UndefinedPDEError - if the number of equations is not be specified yet.

getNumSolutions(self)

returns the number of unknowns
Returns:
the number of unknowns
           (type=int)
Raises:
UndefinedPDEError - if the number of unknowns is not be specified yet.

getOperator(self)

provides access to the operator of the PDE
Returns:
the operator of the PDE
           (type=Operator)

getResidual(self, u=None)

return the residual of u or the current solution if u is not present.
Parameters:
u - argument in the residual calculation. It must be representable in elf.getFunctionSpaceForSolution(). If u is not present or equals None the current solution is used.
           (type=Data or None)
Returns:
residual of u
           (type=Data)

getRightHandSide(self)

provides access to the right hand side of the PDE
Returns:
the right hand side of the PDE
           (type=Data)

getShapeOfCoefficient(self, name)

return the shape of the coefficient name
Parameters:
name - name of the coefficient enquired.
           (type=string)
Returns:
the shape of the coefficient name
           (type=tuple of int)
Raises:
IllegalCoefficient - if name is not a coefficient of the PDE.

getShapeOfCoefficientOfGeneralPDE(self, name)

return the shape of the coefficient name of the general PDE
Parameters:
name - name of the coefficient enquired.
           (type=string)
Returns:
the shape of the coefficient name
           (type=tuple of int)
Raises:
IllegalCoefficient - if name is not one of coefficients A, B, C, D, X, Y, d, y, d_contact, y_contact, r or q.

getSolution(self, **options)

returns the solution of the PDE. If the solution is not valid the PDE is solved.
Parameters:
options - solver options
Keyword Parameters:
verbose - True to get some information during PDE solution
           (type=bool)
reordering - reordering scheme to be used during elimination. Allowed values are NO_REORDERING, MINIMUM_FILL_IN, NESTED_DISSECTION
iter_max - maximum number of iteration steps allowed.
drop_tolerance - threshold for drupping in ILUT
drop_storage - maximum of allowed memory in ILUT
truncation - maximum number of residuals in GMRES
restart - restart cycle length in GMRES
Returns:
the solution
           (type=Data)

getSolverMethod(self)

returns the solver method
Returns:
the solver method currently be used.
           (type=int)

getSolverMethodName(self)

returns the name of the solver currently used
Returns:
the name of the solver currently used.
           (type=string)

getSolverPackage(self)

returns the package of the solver
Returns:
the solver package currently being used.
           (type=int)

getSystem(self)

return the operator and right hand side of the PDE
Returns:
the discrete version of the PDE
           (type=tuple of Operator, and Data.)

getTolerance(self)

returns the tolerance set for the solution
Returns:
tolerance currently used.
           (type=float)

hasCoefficient(self, name)

return True if name is the name of a coefficient
Parameters:
name - name of the coefficient enquired.
           (type=string)
Returns:
True if name is the name of a coefficient of the general PDE. Otherwise False.
           (type=bool)

hasCoefficientOfGeneralPDE(self, name)

checks if name is a the name of a coefficient of the general PDE.
Parameters:
name - name of the coefficient enquired.
           (type=string)
Returns:
True if name is the name of a coefficient of the general PDE. Otherwise False.
           (type=bool)

isSymmetric(self)

checks if symmetry is indicated.
Returns:
True is a symmetric PDE is indicated, otherwise False is returned
           (type=bool)

isUsingLumping(self)

checks if matrix lumping is used a solver method
Returns:
True is lumping is currently used a solver method.
           (type=bool)

reduceEquationOrder(self)

return status for order reduction for equation
Returns:
return True is reduced interpolation order is used for the represenation of the equation
           (type=bool)

reduceSolutionOrder(self)

return status for order reduction for the solution
Returns:
return True is reduced interpolation order is used for the represenation of the solution
           (type=bool)

resetCoefficients(self)

resets all coefficients to there default values.

setDebugOff(self)

switches off debugging

setDebugOn(self)

switches on debugging

setReducedOrderForEquationOff(self)

switches off reduced order for equation representation
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderForEquationOn(self)

switches on reduced order for equation representation
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderForEquationTo(self, flag=False)

sets order for test functions according to flag
Parameters:
flag - if flag is True, the order reduction is switched on for equation representation, otherwise or if flag is not present order reduction is switched off
           (type=bool)
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderForSolutionOff(self)

switches off reduced order for solution representation
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderForSolutionOn(self)

switches on reduced order for solution representation
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderForSolutionTo(self, flag=False)

sets order for test functions according to flag
Parameters:
flag - if flag is True, the order reduction is switched on for solution representation, otherwise or if flag is not present order reduction is switched off
           (type=bool)
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderOff(self)

switches off reduced order for solution and equation representation
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderOn(self)

switches on reduced order for solution and equation representation
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setReducedOrderTo(self, flag=False)

sets order reduction for both solution and equation representation according to flag.
Parameters:
flag - if flag is True, the order reduction is switched on for both solution and equation representation, otherwise or if flag is not present order reduction is switched off
           (type=bool)
Raises:
RuntimeError - if order reduction is altered after a coefficient has been set.

setSolverMethod(self, solver=None, preconditioner=None)

sets a new solver
Parameters:
solver - sets a new solver method.
           (type=one of DEFAULT, ITERATIVE DIRECT, CHOLEVSKY, PCG, CR, CGS, BICGSTAB, SSOR, GMRES, PRES20, LUMPING, AMG)
preconditioner - sets a new solver method.
           (type=one of DEFAULT, JACOBI ILU0, ILUT,SSOR, RILU)

setSolverPackage(self, package=None)

sets a new solver package

setSymmetryOff(self)

removes the symmetry flag.

setSymmetryOn(self)

sets the symmetry flag.

setSymmetryTo(self, flag=False)

sets the symmetry flag to flag
Parameters:
flag - If flag, the symmetry flag is set otherwise the symmetry flag is released.
           (type=bool)

setTolerance(self, tol=1e-08)

resets the tolerance for the solver method to tol where for an appropriate norm |.|

|getResidual()|<tol*|getRightHandSide()|

defines the stopping criterion.
Parameters:
tol - new tolerance for the solver. If the tol is lower then the current tolerence the system will be resolved.
           (type=positive float)
Raises:
ValueException - if tolerance is not positive.

setValue(self, **coefficients)

sets new values to coefficients
Parameters:
coefficients - new values assigned to coefficients
Keyword Parameters:
A - value for coefficient A.
           (type=any type that can be casted to Data object on Function.)
B - value for coefficient B
           (type=any type that can be casted to Data object on Function.)
C - value for coefficient C
           (type=any type that can be casted to Data object on Function.)
D - value for coefficient D
           (type=any type that can be casted to Data object on Function.)
X - value for coefficient X
           (type=any type that can be casted to Data object on Function.)
Y - value for coefficient Y
           (type=any type that can be casted to Data object on Function.)
d - value for coefficient d
           (type=any type that can be casted to Data object on FunctionOnBoundary.)
y - value for coefficient y
           (type=any type that can be casted to Data object on FunctionOnBoundary.)
d_contact - value for coefficient d_contact
           (type=any type that can be casted to Data object on FunctionOnContactOne. or FunctionOnContactZero.)
y_contact - value for coefficient y_contact
           (type=any type that can be casted to Data object on FunctionOnContactOne. or FunctionOnContactZero.)
r - values prescribed to the solution at the locations of constraints
           (type=any type that can be casted to Data object on Solution or ReducedSolution depending of reduced order is used for the solution.)
q - mask for location of constraints
           (type=any type that can be casted to Data object on Solution or ReducedSolution depending of reduced order is used for the representation of the equation.)
Raises:
IllegalCoefficient - if an unknown coefficient keyword is used.

trace(self, text)

print the text message if debugging is swiched on.
Parameters:
text - message
           (type=string)

Class Variable Details

AMG

algebraic multi grid
Type:
int
Value:
22                                                                    

BICGSTAB

The stabilized BiConjugate Gradient method.
Type:
int
Value:
6                                                                     

CGS

The conjugate gardient square method
Type:
int
Value:
5                                                                     

CHOLEVSKY

The direct solver based on LDLt factorization (can only be applied for symmetric PDEs)
Type:
int
Value:
2                                                                     

CR

The conjugate residual method
Type:
int
Value:
4                                                                     

DEFAULT

The default method used to solve the system of linear equations
Type:
int
Value:
0                                                                     

DIRECT

The direct solver based on LDU factorization
Type:
int
Value:
1                                                                     

GMRES

The Gram-Schmidt minimum residual method
Type:
int
Value:
11                                                                    

ILU0

The incomplete LU factorization preconditioner with no fill in
Type:
int
Value:
8                                                                     

ILUT

The incomplete LU factorization preconditioner with will in
Type:
int
Value:
9                                                                     

ITERATIVE

The default iterative solver
Type:
int
Value:
20                                                                    

JACOBI

The Jacobi preconditioner
Type:
int
Value:
10                                                                    

LUMPING

Matrix lumping.
Type:
int
Value:
13                                                                    

MINIMUM_FILL_IN

Reorder matrix to reduce fill-in during factorization
Type:
int
Value:
18                                                                    

MKL

Intel's MKL solver library
Type:
int
Value:
15                                                                    

NESTED_DISSECTION

Reorder matrix to improve load balancing during factorization
Type:
int
Value:
19                                                                    

NO_REORDERING

No matrix reordering allowed
Type:
int
Value:
17                                                                    

PASO

PASO solver package
Type:
int
Value:
21                                                                    

PCG

The preconditioned conjugate gradient method (can only be applied for symmetric PDEs)
Type:
int
Value:
3                                                                     

PRES20

Special GMRES with restart after 20 steps and truncation after 5 residuals
Type:
int
Value:
12                                                                    

RILU

recursive ILU
Type:
int
Value:
23                                                                    

SCSL

SGI SCSL solver library
Type:
int
Value:
14                                                                    

SMALL_TOLERANCE

Type:
float
Value:
1e-13                                                                 

SSOR

The symmetric overrealaxtion method
Type:
int
Value:
7                                                                     

UMFPACK

the UMFPACK library
Type:
int
Value:
16                                                                    

   Home       Trees       Index       Help   
Generated by Epydoc 2.1 on Thu Apr 27 11:16:23 2006 http://epydoc.sf.net