|
PyTrilinos
Development
|
Public Member Functions | |
| def | __init__ |
| def | Label |
| def | PrintUnused |
| def | GetList |
| def | GetOutputList |
| def | PrintList |
| def | SetParameterList |
| def | Apply |
| def | ApplyInverse |
| def | ComputePreconditioner |
| def | ReComputePreconditioner |
| def | ComputeAdaptivePreconditioner |
| def | IsPreconditionerComputed |
| def | SetOwnership |
| def | SetUseTranspose |
| def | NormInf |
| def | UseTranspose |
| def | HasNormInf |
| def | Comm |
| def | OperatorDomainMap |
| def | OperatorRangeMap |
| def | DestroyPreconditioner |
| def | RowMatrix |
| def | Map |
| def | NumGlobalRows |
| def | NumGlobalCols |
| def | NumMyRows |
| def | NumMyCols |
| def | PrintStencil2D |
| def | AnalyzeHierarchy |
| def | AnalyzeSmoothers |
| def | AnalyzeCoarse |
| def | AnalyzeCycle |
| def | TestSmoothers |
| def | GetML |
| def | GetML_Aggregate |
| def | Visualize |
| def | VisualizeAggregates |
| def | VisualizeSmoothers |
| def | VisualizeCycle |
| def | CreateLabel |
| def | ReportTime |
| def | SetParameterListAndNullSpace |
Public Attributes | |
| this | |
ML black-box preconditioner for Epetra_RowMatrix derived classes. C++ includes: ml_MultiLevelPreconditioner.h
| def PyTrilinos.ML.MultiLevelPreconditioner.__init__ | ( | self, | |
| args | |||
| ) |
__init__(ML_Epetra::MultiLevelPreconditioner self, RowMatrix RowMatrix, bool const ComputePrec=True) -> MultiLevelPreconditioner
__init__(ML_Epetra::MultiLevelPreconditioner self, RowMatrix RowMatrix, ParameterList List, bool const ComputePrec=True) -> MultiLevelPreconditioner
__init__(ML_Epetra::MultiLevelPreconditioner self, ML_Operator * Operator, ParameterList List, bool const ComputePrec=True) -> MultiLevelPreconditioner
__init__(ML_Epetra::MultiLevelPreconditioner self, ML_Operator * Operator, ParameterList List, Epetra_RowMatrix ** DiagOperators, ParameterList DiagLists,
int NBlocks=1, bool const ComputePrec=True) -> MultiLevelPreconditioner
__init__(ML_Epetra::MultiLevelPreconditioner self, RowMatrix EdgeMatrix, RowMatrix GradMatrix, RowMatrix NodeMatrix, ParameterList List,
bool const ComputePrec=True, bool const UseNodeMatrixForSmoother=False) -> MultiLevelPreconditioner
__init__(ML_Epetra::MultiLevelPreconditioner self, RowMatrix CurlCurlMatrix, RowMatrix MassMatrix, RowMatrix TMatrix, RowMatrix NodeMatrix,
ParameterList List, bool const ComputePrec=True) -> MultiLevelPreconditioner
__init__(ML_Epetra::MultiLevelPreconditioner self, Epetra_MsrMatrix const & EdgeMatrix, ML_Operator * GradMatrix, AZ_MATRIX * NodeMatrix,
int * proc_config, ParameterList List, bool const ComputePrec=True) -> MultiLevelPreconditioner
ML black-box preconditioner for Epetra_RowMatrix derived classes.
C++ includes: ml_MultiLevelPreconditioner.h
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.AnalyzeCoarse | ( | self, | |
| args | |||
| ) |
AnalyzeCoarse(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.AnalyzeCycle | ( | self, | |
| args | |||
| ) |
AnalyzeCycle(MultiLevelPreconditioner self, int const NumCycles=1) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.AnalyzeHierarchy | ( | self, | |
| args | |||
| ) |
AnalyzeHierarchy(MultiLevelPreconditioner self, bool const AnalyzeMatrices, int const PreCycles, int const PostCycles, int const MLCycles) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.AnalyzeSmoothers | ( | self, | |
| args | |||
| ) |
AnalyzeSmoothers(MultiLevelPreconditioner self, int const NumPreCycles=1, int const NumPostCycles=1) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.Apply | ( | self, | |
| args | |||
| ) |
Apply(self, MultiVector x, MultiVector y) -> int
In C++, the Apply() method is pure virtual, thus intended to be
overridden by derived classes. In python, cross-language polymorphism
is supported, and you are expected to derive classes from this base
class and redefine the Apply() method. C++ code (e.g., AztecOO
solvers) can call back to your Apply() method as needed. You must
support two arguments, labeled here MultiVector x and MultiVector y.
These will be converted from Epetra_MultiVector C++ objects to
numpy-hybrid Epetra.MultiVector objects before they are passed to you.
Thus, it is legal to use slice indexing and other numpy features to
compute y from x.
If application of your operator is successful, return 0; else return
some non-zero error code.
It is strongly suggested that you prevent Apply() from raising any
exceptions. Accidental errors can be prevented by wrapping your code
in a try block:
try:
# Your code goes here...
except Exception, e:
print 'A python exception was raised by method Apply:'
print e
return -1
By returning a -1, you inform the calling routine that Apply() was
unsuccessful.
virtual int
Epetra_Operator::Apply(const Epetra_MultiVector &X, Epetra_MultiVector
&Y) const =0
Returns the result of a Epetra_Operator applied to a
Epetra_MultiVector X in Y.
Parameters:
-----------
In: X - A Epetra_MultiVector of dimension NumVectors to multiply with
matrix.
Out: Y -A Epetra_MultiVector of dimension NumVectors containing
result.
Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.ApplyInverse | ( | self, | |
| args | |||
| ) |
ApplyInverse(self, MultiVector x, MultiVector y) -> int
In C++, the ApplyInverse() method is pure virtual, thus intended to be
overridden by derived classes. In python, cross-language polymorphism
is supported, and you are expected to derive classes from this base
class and redefine the ApplyInverse() method. C++ code (e.g., AztecOO
solvers) can call back to your ApplyInverse() method as needed. You
must support two arguments, labeled here MultiVector x and MultiVector
y. These will be converted from Epetra_MultiVector C++ objects to
numpy-hybrid Epetra.MultiVector objects before they are passed to you.
Thus, it is legal to use slice indexing and other numpy features to
compute y from x.
If application of your operator is successful, return 0; else return
some non-zero error code.
It is strongly suggested that you prevent ApplyInverse() from raising
any exceptions. Accidental errors can be prevented by wrapping your
code in a try block:
try:
# Your code goes here...
except Exception, e:
print 'A python exception was raised by method ApplyInverse:'
print e
return -1
By returning a -1, you inform the calling routine that ApplyInverse()
was unsuccessful.
virtual int
Epetra_Operator::ApplyInverse(const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const =0
Returns the result of a Epetra_Operator inverse applied to an
Epetra_MultiVector X in Y.
Parameters:
-----------
In: X - A Epetra_MultiVector of dimension NumVectors to solve for.
Out: Y -A Epetra_MultiVector of dimension NumVectors containing
result.
Integer error code, set to 0 if successful.
WARNING: In order to work with AztecOO, any implementation of this
method must support the case where X and Y are the same object.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.Comm | ( | self, | |
| args | |||
| ) |
Comm(MultiLevelPreconditioner self) -> Comm virtual const Epetra_Comm& Epetra_Operator::Comm() const =0 Returns a pointer to the Epetra_Comm communicator associated with this operator.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.ComputeAdaptivePreconditioner | ( | self, | |
| args | |||
| ) |
ComputeAdaptivePreconditioner(MultiLevelPreconditioner self, int TentativeNullSpaceSize, double * TentativeNullSpace) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.ComputePreconditioner | ( | self, | |
| args | |||
| ) |
ComputePreconditioner(MultiLevelPreconditioner self, bool const CheckFiltering=False) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.CreateLabel | ( | self, | |
| args | |||
| ) |
CreateLabel(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.DestroyPreconditioner | ( | self, | |
| args | |||
| ) |
DestroyPreconditioner(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.GetList | ( | self, | |
| args | |||
| ) |
GetList(MultiLevelPreconditioner self) -> ParameterList
| def PyTrilinos.ML.MultiLevelPreconditioner.GetML | ( | self, | |
| args | |||
| ) |
GetML(MultiLevelPreconditioner self, int const WhichML=-1) -> ML const *
| def PyTrilinos.ML.MultiLevelPreconditioner.GetML_Aggregate | ( | self, | |
| args | |||
| ) |
GetML_Aggregate(MultiLevelPreconditioner self) -> ML_Aggregate const *
| def PyTrilinos.ML.MultiLevelPreconditioner.GetOutputList | ( | self, | |
| args | |||
| ) |
GetOutputList(MultiLevelPreconditioner self) -> ParameterList
| def PyTrilinos.ML.MultiLevelPreconditioner.HasNormInf | ( | self, | |
| args | |||
| ) |
HasNormInf(MultiLevelPreconditioner self) -> bool virtual bool Epetra_Operator::HasNormInf() const =0 Returns true if the this object can provide an approximate Inf-norm, false otherwise.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.IsPreconditionerComputed | ( | self, | |
| args | |||
| ) |
IsPreconditionerComputed(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.Label | ( | self, | |
| args | |||
| ) |
Label(MultiLevelPreconditioner self) -> char const * virtual const char* Epetra_Operator::Label() const =0 Returns a character string describing the operator.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.Map | ( | self, | |
| args | |||
| ) |
Map(MultiLevelPreconditioner self) -> BlockMap
| def PyTrilinos.ML.MultiLevelPreconditioner.NormInf | ( | self, | |
| args | |||
| ) |
NormInf(MultiLevelPreconditioner self) -> double virtual double Epetra_Operator::NormInf() const =0 Returns the infinity norm of the global matrix.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.NumGlobalCols | ( | self, | |
| args | |||
| ) |
NumGlobalCols(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.NumGlobalRows | ( | self, | |
| args | |||
| ) |
NumGlobalRows(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.NumMyCols | ( | self, | |
| args | |||
| ) |
NumMyCols(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.NumMyRows | ( | self, | |
| args | |||
| ) |
NumMyRows(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.OperatorDomainMap | ( | self, | |
| args | |||
| ) |
OperatorDomainMap(MultiLevelPreconditioner self) -> Map virtual const Epetra_Map& Epetra_Operator::OperatorDomainMap() const =0 Returns the Epetra_Map object associated with the domain of this operator.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.OperatorRangeMap | ( | self, | |
| args | |||
| ) |
OperatorRangeMap(MultiLevelPreconditioner self) -> Map virtual const Epetra_Map& Epetra_Operator::OperatorRangeMap() const =0 Returns the Epetra_Map object associated with the range of this operator.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.PrintList | ( | self, | |
| args | |||
| ) |
PrintList(MultiLevelPreconditioner self)
| def PyTrilinos.ML.MultiLevelPreconditioner.PrintStencil2D | ( | self, | |
| args | |||
| ) |
PrintStencil2D(MultiLevelPreconditioner self, int const nx, int const ny, int NodeID=-1, int const EquationID=0) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.PrintUnused | ( | self, | |
| args | |||
| ) |
PrintUnused(MultiLevelPreconditioner self) PrintUnused(MultiLevelPreconditioner self, std::ostream & os) PrintUnused(MultiLevelPreconditioner self, int const MyPID)
| def PyTrilinos.ML.MultiLevelPreconditioner.ReComputePreconditioner | ( | self, | |
| args | |||
| ) |
ReComputePreconditioner(MultiLevelPreconditioner self, bool keepFineLevelSmoother=False) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.ReportTime | ( | self, | |
| args | |||
| ) |
ReportTime(MultiLevelPreconditioner self)
| def PyTrilinos.ML.MultiLevelPreconditioner.RowMatrix | ( | self, | |
| args | |||
| ) |
RowMatrix(MultiLevelPreconditioner self) -> RowMatrix
| def PyTrilinos.ML.MultiLevelPreconditioner.SetOwnership | ( | self, | |
| args | |||
| ) |
SetOwnership(MultiLevelPreconditioner self, bool ownership) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.SetParameterList | ( | self, | |
| args | |||
| ) |
SetParameterList(MultiLevelPreconditioner self, ParameterList List) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.SetParameterListAndNullSpace | ( | self, | |
| args | |||
| ) |
SetParameterListAndNullSpace(MultiLevelPreconditioner self, PyObject * obj, Epetra_MultiVector NullSpace) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.SetUseTranspose | ( | self, | |
| args | |||
| ) |
SetUseTranspose(MultiLevelPreconditioner self, bool useTranspose) -> int virtual int Epetra_Operator::SetUseTranspose(bool UseTranspose)=0 If set true, transpose of this operator will be applied. This flag allows the transpose of the given operator to be used implicitly. Setting this flag affects only the Apply() and ApplyInverse() methods. If the implementation of this interface does not support transpose use, this method should return a value of -1. Parameters: ----------- In: UseTranspose -If true, multiply by the transpose of operator, otherwise just use operator. Integer error code, set to 0 if successful. Set to -1 if this implementation does not support transpose.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.TestSmoothers | ( | self, | |
| args | |||
| ) |
TestSmoothers(MultiLevelPreconditioner self, ParameterList InputList, bool const IsSymmetric=False) -> int TestSmoothers(MultiLevelPreconditioner self, bool const IsSymmetric=False) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.UseTranspose | ( | self, | |
| args | |||
| ) |
UseTranspose(MultiLevelPreconditioner self) -> bool virtual bool Epetra_Operator::UseTranspose() const =0 Returns the current UseTranspose setting.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.ML.MultiLevelPreconditioner.Visualize | ( | self, | |
| args | |||
| ) |
Visualize(MultiLevelPreconditioner self, bool VizAggre, bool VizPreSmoother, bool VizPostSmoother, bool VizCycle, int NumApplPreSmoother,
int NumApplPostSmoother, int NumCycleSmoother) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.VisualizeAggregates | ( | self, | |
| args | |||
| ) |
VisualizeAggregates(MultiLevelPreconditioner self) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.VisualizeCycle | ( | self, | |
| args | |||
| ) |
VisualizeCycle(MultiLevelPreconditioner self, int NumCycles=1) -> int
| def PyTrilinos.ML.MultiLevelPreconditioner.VisualizeSmoothers | ( | self, | |
| args | |||
| ) |
VisualizeSmoothers(MultiLevelPreconditioner self, int NumPrecCycles=1, int NumPostCycles=1) -> int
1.7.6.1