Public Member Functions | |
def | __init__ |
def | ReplaceGlobalValue |
def | SumIntoGlobalValue |
def | ReplaceMyValue |
def | SumIntoMyValue |
def | PutScalar |
def | Random |
def | Abs |
def | Reciprocal |
def | Scale |
def | Update |
def | Multiply |
def | ReciprocalMultiply |
def | SetSeed |
def | Seed |
def | __call__ |
def | NumVectors |
def | MyLength |
def | GlobalLength |
def | Stride |
def | ConstantStride |
def | ReplaceMap |
def | Values |
def | Reduce |
def | __init__ |
def | ReplaceGlobalValue |
def | SumIntoGlobalValue |
def | ReplaceMyValue |
def | SumIntoMyValue |
def | PutScalar |
def | Random |
def | Abs |
def | Reciprocal |
def | Scale |
def | Update |
def | Multiply |
def | ReciprocalMultiply |
def | SetSeed |
def | Seed |
def | __call__ |
def | NumVectors |
def | MyLength |
def | GlobalLength |
def | Stride |
def | ConstantStride |
def | ReplaceMap |
def | Values |
def | Reduce |
Public Attributes | |
this |
Epetra_MultiVector: A class for constructing and using dense multi- vectors, vectors and matrices in parallel. The Epetra_MultiVector class enables the construction and use of real- valued, double- precision dense vectors, multi-vectors, and matrices in a distributed memory environment. The dimensions and distribution of the dense multi-vectors is determined in part by a Epetra_Comm object, a Epetra_Map (or Epetra_LocalMap or Epetra_BlockMap) and the number of vectors passed to the constructors described below. There are several concepts that important for understanding the Epetra_MultiVector class: Multi-vectors, Vectors and Matrices. Vector - A list of real-valued, double-precision numbers. Also a multi-vector with one vector. Multi-Vector - A collection of one or more vectors, all having the same length and distribution. (Dense) Matrix - A special form of multi-vector such that stride in memory between any two consecutive vectors in the multi-vector is the same for all vectors. This is identical to a two-dimensional array in Fortran and plays an important part in high performance computations. Distributed Global vs. Replicated Local. Distributed Global Multi- vectors - In most instances, a multi-vector will be partitioned across multiple memory images associated with multiple processors. In this case, there is a unique copy of each element and elements are spread across all processors specified by the Epetra_Comm communicator. Replicated Local Multi-vectors - Some algorithms use multi-vectors that are too small to be distributed across all processors, the Hessenberg matrix in a GMRES computation. In other cases, such as with block iterative methods, block dot product functions produce small dense matrices that are required by all processors. Replicated local multi-vectors handle these types of situation. Multi-vector Functions vs. Dense Matrix Functions. Multi-vector functions - These functions operate simultaneously but independently on each vector in the multi-vector and produce individual results for each vector. Dense matrix functions - These functions operate on the multi-vector as a matrix, providing access to selected dense BLAS and LAPACK operations. Constructing Epetra_MultiVectors Except for the basic constructor and copy constructor, Epetra_MultiVector constructors have two data access modes: Copy mode - Allocates memory and makes a copy of the user-provided data. In this case, the user data is not needed after construction. View mode - Creates a "view" of the user data. In this case, the user data is required to remain intact for the life of the multi- vector. WARNING: View mode is extremely dangerous from a data hiding perspective. Therefore, we strongly encourage users to develop code using Copy mode first and only use the View mode in a secondary optimization phase. All Epetra_MultiVector constructors require a map argument that describes the layout of elements on the parallel machine. Specifically, map is a Epetra_Map, Epetra_LocalMap or Epetra_BlockMap object describing the desired memory layout for the multi-vector. There are six different Epetra_MultiVector constructors: Basic - All values are zero. Copy - Copy an existing multi-vector. Copy from or make view of two-dimensional Fortran style array. Copy from or make view of an array of pointers. Copy or make view of a list of vectors from another Epetra_MultiVector object. Copy or make view of a range of vectors from another Epetra_MultiVector object. Extracting Data from Epetra_MultiVectors Once a Epetra_MultiVector is constructed, it is possible to extract a copy of the values or create a view of them. WARNING: ExtractView functions are extremely dangerous from a data hiding perspective. For both ExtractView fuctions, there is a corresponding ExtractCopy function. We strongly encourage users to develop code using ExtractCopy functions first and only use the ExtractView functions in a secondary optimization phase. There are four Extract functions: ExtractCopy - Copy values into a user-provided two-dimensional array. ExtractCopy - Copy values into a user-provided array of pointers. ExtractView - Set user-provided two-dimensional array parameters to point to Epetra_MultiVector data. ExtractView - Set user-provided array of pointer parameters to point to Epetra_MultiVector data. Vector, Matrix and Utility Functions Once a Epetra_MultiVector is constructed, a variety of mathematical functions can be applied to the individual vectors. Specifically: Dot Products. Vector Updates. p Norms. Weighted Norms. Minimum, Maximum and Average Values. In addition, a matrix-matrix multiply function supports a variety of operations on any viable combination of global distributed and local replicated multi-vectors using calls to DGEMM, a high performance kernel for matrix operations. In the near future we will add support for calls to other selected BLAS and LAPACK functions. Counting Floating Point Operations Each Epetra_MultiVector object keep track of the number of serial floating point operations performed using the specified object as the this argument to the function. The Flops() function returns this number as a double precision number. Using this information, in conjunction with the Epetra_Time class, one can get accurate parallel performance numbers. The ResetFlops() function resets the floating point counter. WARNING: A Epetra_Map, Epetra_LocalMap or Epetra_BlockMap object is required for all Epetra_MultiVector constructors. C++ includes: Epetra_MultiVector.h
def PyTrilinos::Epetra::Epetra_MultiVector::__call__ | ( | self, | ||
args | ||||
) |
__call__(self, int i) -> Epetra_Vector
def PyTrilinos::Epetra::Epetra_MultiVector::__call__ | ( | self, | ||
args | ||||
) |
__call__(self, int i) -> Epetra_Vector
def PyTrilinos::Epetra::Epetra_MultiVector::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, BlockMap Map, int NumVectors, bool zeroOut = True) -> Epetra_MultiVector __init__(self, Epetra_MultiVector Source) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, BlockMap Map, double A, int MyLDA, int NumVectors) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, BlockMap Map, double ArrayOfPointers, int NumVectors) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, Epetra_MultiVector Source, int Indices, int NumVectors) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, Epetra_MultiVector Source, int StartIndex, int NumVectors) -> Epetra_MultiVector Epetra_MultiVector::Epetra_MultiVector(Epetra_DataAccess CV, const Epetra_MultiVector &Source, int StartIndex, int NumVectors) Set multi-vector values from range of vectors in an existing Epetra_MultiVector. Parameters: ----------- In: Epetra_DataAccess - Enumerated type set to Copy or View. In: Source - An existing fully constructed Epetra_MultiVector. In: StartIndex - First of the vectors to copy. In: NumVectors - Number of vectors in multi-vector. Integer error code, set to 0 if successful. See Detailed Description section for further discussion.
Reimplemented from PyTrilinos::Epetra::CompObject.
Reimplemented in PyTrilinos::Anasazi::EpetraMultiVec, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::Epetra_Vector, PyTrilinos::Epetra::FEVector, PyTrilinos::Epetra::Epetra_FEVector, PyTrilinos::Epetra::NumPyMultiVector, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::NumPyVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::NumPyFEVector, PyTrilinos::Epetra::FEVector, PyTrilinos::Anasazi::EpetraMultiVec, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::Epetra_Vector, PyTrilinos::Epetra::FEVector, PyTrilinos::Epetra::Epetra_FEVector, PyTrilinos::Epetra::NumPyMultiVector, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::NumPyVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::NumPyFEVector, and PyTrilinos::Epetra::FEVector.
def PyTrilinos::Epetra::Epetra_MultiVector::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, BlockMap Map, int NumVectors, bool zeroOut = True) -> Epetra_MultiVector __init__(self, Epetra_MultiVector Source) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, BlockMap Map, double A, int MyLDA, int NumVectors) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, BlockMap Map, double ArrayOfPointers, int NumVectors) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, Epetra_MultiVector Source, int Indices, int NumVectors) -> Epetra_MultiVector __init__(self, Epetra_DataAccess CV, Epetra_MultiVector Source, int StartIndex, int NumVectors) -> Epetra_MultiVector Epetra_MultiVector::Epetra_MultiVector(Epetra_DataAccess CV, const Epetra_MultiVector &Source, int StartIndex, int NumVectors) Set multi-vector values from range of vectors in an existing Epetra_MultiVector. Parameters: ----------- In: Epetra_DataAccess - Enumerated type set to Copy or View. In: Source - An existing fully constructed Epetra_MultiVector. In: StartIndex - First of the vectors to copy. In: NumVectors - Number of vectors in multi-vector. Integer error code, set to 0 if successful. See Detailed Description section for further discussion.
Reimplemented from PyTrilinos::Epetra::CompObject.
Reimplemented in PyTrilinos::Anasazi::EpetraMultiVec, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::Epetra_Vector, PyTrilinos::Epetra::FEVector, PyTrilinos::Epetra::Epetra_FEVector, PyTrilinos::Epetra::NumPyMultiVector, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::NumPyVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::NumPyFEVector, PyTrilinos::Epetra::FEVector, PyTrilinos::Anasazi::EpetraMultiVec, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::Epetra_Vector, PyTrilinos::Epetra::FEVector, PyTrilinos::Epetra::Epetra_FEVector, PyTrilinos::Epetra::NumPyMultiVector, PyTrilinos::Epetra::MultiVector, PyTrilinos::Epetra::NumPyVector, PyTrilinos::Epetra::Vector, PyTrilinos::Epetra::NumPyFEVector, and PyTrilinos::Epetra::FEVector.
def PyTrilinos::Epetra::Epetra_MultiVector::Abs | ( | self, | ||
args | ||||
) |
Abs(self, Epetra_MultiVector A) -> int int Epetra_MultiVector::Abs(const Epetra_MultiVector &A) Puts element-wise absolute values of input Multi-vector in target. Parameters: ----------- In: A - Input Multi-vector. Out: this will contain the absolute values of the entries of A. Integer error code, set to 0 if successful. Note: It is possible to use the same argument for A and this.
def PyTrilinos::Epetra::Epetra_MultiVector::Abs | ( | self, | ||
args | ||||
) |
Abs(self, Epetra_MultiVector A) -> int int Epetra_MultiVector::Abs(const Epetra_MultiVector &A) Puts element-wise absolute values of input Multi-vector in target. Parameters: ----------- In: A - Input Multi-vector. Out: this will contain the absolute values of the entries of A. Integer error code, set to 0 if successful. Note: It is possible to use the same argument for A and this.
def PyTrilinos::Epetra::Epetra_MultiVector::ConstantStride | ( | self, | ||
args | ||||
) |
ConstantStride(self) -> bool bool Epetra_MultiVector::ConstantStride() const Returns true if this multi-vector has constant stride between vectors.
def PyTrilinos::Epetra::Epetra_MultiVector::ConstantStride | ( | self, | ||
args | ||||
) |
ConstantStride(self) -> bool bool Epetra_MultiVector::ConstantStride() const Returns true if this multi-vector has constant stride between vectors.
def PyTrilinos::Epetra::Epetra_MultiVector::GlobalLength | ( | self, | ||
args | ||||
) |
GlobalLength(self) -> int int Epetra_MultiVector::GlobalLength() const Returns the global vector length of vectors in the multi-vector.
def PyTrilinos::Epetra::Epetra_MultiVector::GlobalLength | ( | self, | ||
args | ||||
) |
GlobalLength(self) -> int int Epetra_MultiVector::GlobalLength() const Returns the global vector length of vectors in the multi-vector.
def PyTrilinos::Epetra::Epetra_MultiVector::Multiply | ( | self, | ||
args | ||||
) |
Multiply(self, char TransA, char TransB, double ScalarAB, Epetra_MultiVector A, Epetra_MultiVector B, double ScalarThis) -> int Multiply(self, double ScalarAB, Epetra_MultiVector A, Epetra_MultiVector B, double ScalarThis) -> int int Epetra_MultiVector::Multiply(double ScalarAB, const Epetra_MultiVector &A, const Epetra_MultiVector &B, double ScalarThis) Multiply a Epetra_MultiVector with another, element-by-element. This function supports diagonal matrix multiply. A is usually a single vector while B and this may have one or more columns. Note that B and this must have the same shape. A can be one vector or have the same shape as B. The actual computation is this = ScalarThis * this + ScalarAB * B @ A where @ denotes element-wise multiplication.
def PyTrilinos::Epetra::Epetra_MultiVector::Multiply | ( | self, | ||
args | ||||
) |
Multiply(self, char TransA, char TransB, double ScalarAB, Epetra_MultiVector A, Epetra_MultiVector B, double ScalarThis) -> int Multiply(self, double ScalarAB, Epetra_MultiVector A, Epetra_MultiVector B, double ScalarThis) -> int int Epetra_MultiVector::Multiply(double ScalarAB, const Epetra_MultiVector &A, const Epetra_MultiVector &B, double ScalarThis) Multiply a Epetra_MultiVector with another, element-by-element. This function supports diagonal matrix multiply. A is usually a single vector while B and this may have one or more columns. Note that B and this must have the same shape. A can be one vector or have the same shape as B. The actual computation is this = ScalarThis * this + ScalarAB * B @ A where @ denotes element-wise multiplication.
def PyTrilinos::Epetra::Epetra_MultiVector::MyLength | ( | self, | ||
args | ||||
) |
MyLength(self) -> int int Epetra_MultiVector::MyLength() const Returns the local vector length on the calling processor of vectors in the multi-vector.
def PyTrilinos::Epetra::Epetra_MultiVector::MyLength | ( | self, | ||
args | ||||
) |
MyLength(self) -> int int Epetra_MultiVector::MyLength() const Returns the local vector length on the calling processor of vectors in the multi-vector.
def PyTrilinos::Epetra::Epetra_MultiVector::NumVectors | ( | self, | ||
args | ||||
) |
NumVectors(self) -> int int Epetra_MultiVector::NumVectors() const Returns the number of vectors in the multi-vector.
def PyTrilinos::Epetra::Epetra_MultiVector::NumVectors | ( | self, | ||
args | ||||
) |
NumVectors(self) -> int int Epetra_MultiVector::NumVectors() const Returns the number of vectors in the multi-vector.
def PyTrilinos::Epetra::Epetra_MultiVector::PutScalar | ( | self, | ||
args | ||||
) |
PutScalar(self, double ScalarConstant) -> int int Epetra_MultiVector::PutScalar(double ScalarConstant) Initialize all values in a multi-vector with constant value. Parameters: ----------- In: ScalarConstant - Value to use. Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::PutScalar | ( | self, | ||
args | ||||
) |
PutScalar(self, double ScalarConstant) -> int int Epetra_MultiVector::PutScalar(double ScalarConstant) Initialize all values in a multi-vector with constant value. Parameters: ----------- In: ScalarConstant - Value to use. Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Random | ( | self, | ||
args | ||||
) |
Random(self) -> int int Epetra_MultiVector::Random() Set multi-vector values to random numbers. MultiVector uses the random number generator provided by Epetra_Util. The multi-vector values will be set to random values on the interval (-1.0, 1.0). Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Random | ( | self, | ||
args | ||||
) |
Random(self) -> int int Epetra_MultiVector::Random() Set multi-vector values to random numbers. MultiVector uses the random number generator provided by Epetra_Util. The multi-vector values will be set to random values on the interval (-1.0, 1.0). Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Reciprocal | ( | self, | ||
args | ||||
) |
Reciprocal(self, Epetra_MultiVector A) -> int int Epetra_MultiVector::Reciprocal(const Epetra_MultiVector &A) Puts element-wise reciprocal values of input Multi-vector in target. Parameters: ----------- In: A - Input Multi-vector. Out: this will contain the element-wise reciprocal values of the entries of A. Integer error code, set to 0 if successful. Returns 2 if some entry is too small, but not zero. Returns 1 if some entry is zero. Note: It is possible to use the same argument for A and this. Also, if a given value of A is smaller than Epetra_DoubleMin (defined in Epetra_Epetra.h), but nonzero, then the return code is 2. If an entry is zero, the return code is 1. However, in all cases the reciprocal value is still used, even if a NaN is the result.
def PyTrilinos::Epetra::Epetra_MultiVector::Reciprocal | ( | self, | ||
args | ||||
) |
Reciprocal(self, Epetra_MultiVector A) -> int int Epetra_MultiVector::Reciprocal(const Epetra_MultiVector &A) Puts element-wise reciprocal values of input Multi-vector in target. Parameters: ----------- In: A - Input Multi-vector. Out: this will contain the element-wise reciprocal values of the entries of A. Integer error code, set to 0 if successful. Returns 2 if some entry is too small, but not zero. Returns 1 if some entry is zero. Note: It is possible to use the same argument for A and this. Also, if a given value of A is smaller than Epetra_DoubleMin (defined in Epetra_Epetra.h), but nonzero, then the return code is 2. If an entry is zero, the return code is 1. However, in all cases the reciprocal value is still used, even if a NaN is the result.
def PyTrilinos::Epetra::Epetra_MultiVector::ReciprocalMultiply | ( | self, | ||
args | ||||
) |
ReciprocalMultiply(self, double ScalarAB, Epetra_MultiVector A, Epetra_MultiVector B, double ScalarThis) -> int int Epetra_MultiVector::ReciprocalMultiply(double ScalarAB, const Epetra_MultiVector &A, const Epetra_MultiVector &B, double ScalarThis) Multiply a Epetra_MultiVector by the reciprocal of another, element- by-element. This function supports diagonal matrix scaling. A is usually a single vector while B and this may have one or more columns. Note that B and this must have the same shape. A can be one vector or have the same shape as B. The actual computation is this = ScalarThis * this + ScalarAB * B @ A where @ denotes element-wise division.
def PyTrilinos::Epetra::Epetra_MultiVector::ReciprocalMultiply | ( | self, | ||
args | ||||
) |
ReciprocalMultiply(self, double ScalarAB, Epetra_MultiVector A, Epetra_MultiVector B, double ScalarThis) -> int int Epetra_MultiVector::ReciprocalMultiply(double ScalarAB, const Epetra_MultiVector &A, const Epetra_MultiVector &B, double ScalarThis) Multiply a Epetra_MultiVector by the reciprocal of another, element- by-element. This function supports diagonal matrix scaling. A is usually a single vector while B and this may have one or more columns. Note that B and this must have the same shape. A can be one vector or have the same shape as B. The actual computation is this = ScalarThis * this + ScalarAB * B @ A where @ denotes element-wise division.
def PyTrilinos::Epetra::Epetra_MultiVector::Reduce | ( | self, | ||
args | ||||
) |
Reduce(self) -> int int Epetra_MultiVector::Reduce()
def PyTrilinos::Epetra::Epetra_MultiVector::Reduce | ( | self, | ||
args | ||||
) |
Reduce(self) -> int int Epetra_MultiVector::Reduce()
def PyTrilinos::Epetra::Epetra_MultiVector::ReplaceGlobalValue | ( | self, | ||
args | ||||
) |
ReplaceGlobalValue(self, int GlobalRow, int VectorIndex, double ScalarValue) -> int ReplaceGlobalValue(self, int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::ReplaceGlobalValue(int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Replace current value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue. Replaces the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication. Parameters: ----------- In: GlobalBlockRow - BlockRow of Multivector to modify in global index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::ReplaceGlobalValue | ( | self, | ||
args | ||||
) |
ReplaceGlobalValue(self, int GlobalRow, int VectorIndex, double ScalarValue) -> int ReplaceGlobalValue(self, int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::ReplaceGlobalValue(int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Replace current value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue. Replaces the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication. Parameters: ----------- In: GlobalBlockRow - BlockRow of Multivector to modify in global index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::ReplaceMap | ( | self, | ||
args | ||||
) |
ReplaceMap(self, BlockMap map) -> int int Epetra_MultiVector::ReplaceMap(const Epetra_BlockMap &map) Replace map, only if new map has same point-structure as current map. return 0 if map is replaced, -1 if not.
def PyTrilinos::Epetra::Epetra_MultiVector::ReplaceMap | ( | self, | ||
args | ||||
) |
ReplaceMap(self, BlockMap map) -> int int Epetra_MultiVector::ReplaceMap(const Epetra_BlockMap &map) Replace map, only if new map has same point-structure as current map. return 0 if map is replaced, -1 if not.
def PyTrilinos::Epetra::Epetra_MultiVector::ReplaceMyValue | ( | self, | ||
args | ||||
) |
ReplaceMyValue(self, int MyRow, int VectorIndex, double ScalarValue) -> int ReplaceMyValue(self, int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::ReplaceMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Replace current value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue. Replaces the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication. Parameters: ----------- In: MyBlockRow - BlockRow of Multivector to modify in local index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::ReplaceMyValue | ( | self, | ||
args | ||||
) |
ReplaceMyValue(self, int MyRow, int VectorIndex, double ScalarValue) -> int ReplaceMyValue(self, int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::ReplaceMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Replace current value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue. Replaces the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication. Parameters: ----------- In: MyBlockRow - BlockRow of Multivector to modify in local index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::Scale | ( | self, | ||
args | ||||
) |
Scale(self, double ScalarValue) -> int Scale(self, double ScalarA, Epetra_MultiVector A) -> int int Epetra_MultiVector::Scale(double ScalarA, const Epetra_MultiVector &A) Replace multi-vector values with scaled values of A, this = ScalarA*A. Parameters: ----------- In: ScalarA - Scale value. In: A - Multi-vector to copy. Out: This - Multi-vector with values overwritten by scaled values of A. Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Scale | ( | self, | ||
args | ||||
) |
Scale(self, double ScalarValue) -> int Scale(self, double ScalarA, Epetra_MultiVector A) -> int int Epetra_MultiVector::Scale(double ScalarA, const Epetra_MultiVector &A) Replace multi-vector values with scaled values of A, this = ScalarA*A. Parameters: ----------- In: ScalarA - Scale value. In: A - Multi-vector to copy. Out: This - Multi-vector with values overwritten by scaled values of A. Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Seed | ( | self, | ||
args | ||||
) |
Seed(self) -> unsigned int unsigned int Epetra_MultiVector::Seed() Get seed from Random function. Current random number seed.
def PyTrilinos::Epetra::Epetra_MultiVector::Seed | ( | self, | ||
args | ||||
) |
Seed(self) -> unsigned int unsigned int Epetra_MultiVector::Seed() Get seed from Random function. Current random number seed.
def PyTrilinos::Epetra::Epetra_MultiVector::SetSeed | ( | self, | ||
args | ||||
) |
SetSeed(self, unsigned int Seed_in) -> int int Epetra_MultiVector::SetSeed(unsigned int Seed_in) Set seed for Random function. Parameters: ----------- In: Seed - Should be an integer on the interval (0, 2^31-1). Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::SetSeed | ( | self, | ||
args | ||||
) |
SetSeed(self, unsigned int Seed_in) -> int int Epetra_MultiVector::SetSeed(unsigned int Seed_in) Set seed for Random function. Parameters: ----------- In: Seed - Should be an integer on the interval (0, 2^31-1). Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Stride | ( | self, | ||
args | ||||
) |
Stride(self) -> int int Epetra_MultiVector::Stride() const Returns the stride between vectors in the multi-vector (only meaningful if ConstantStride() is true).
def PyTrilinos::Epetra::Epetra_MultiVector::Stride | ( | self, | ||
args | ||||
) |
Stride(self) -> int int Epetra_MultiVector::Stride() const Returns the stride between vectors in the multi-vector (only meaningful if ConstantStride() is true).
def PyTrilinos::Epetra::Epetra_MultiVector::SumIntoGlobalValue | ( | self, | ||
args | ||||
) |
SumIntoGlobalValue(self, int GlobalRow, int VectorIndex, double ScalarValue) -> int SumIntoGlobalValue(self, int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::SumIntoGlobalValue(int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Adds ScalarValue to existing value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location. Sums the given value into the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross- processor communication. Parameters: ----------- In: GlobalBlockRow - BlockRow of Multivector to modify in global index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::SumIntoGlobalValue | ( | self, | ||
args | ||||
) |
SumIntoGlobalValue(self, int GlobalRow, int VectorIndex, double ScalarValue) -> int SumIntoGlobalValue(self, int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::SumIntoGlobalValue(int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Adds ScalarValue to existing value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location. Sums the given value into the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross- processor communication. Parameters: ----------- In: GlobalBlockRow - BlockRow of Multivector to modify in global index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::SumIntoMyValue | ( | self, | ||
args | ||||
) |
SumIntoMyValue(self, int MyRow, int VectorIndex, double ScalarValue) -> int SumIntoMyValue(self, int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::SumIntoMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Adds ScalarValue to existing value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location. Sums the given value into the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross- processor communication. Parameters: ----------- In: MyBlockRow - BlockRow of Multivector to modify in local index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::SumIntoMyValue | ( | self, | ||
args | ||||
) |
SumIntoMyValue(self, int MyRow, int VectorIndex, double ScalarValue) -> int SumIntoMyValue(self, int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) -> int int Epetra_MultiVector::SumIntoMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue) Adds ScalarValue to existing value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location. Sums the given value into the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross- processor communication. Parameters: ----------- In: MyBlockRow - BlockRow of Multivector to modify in local index space. In: BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space. In: VectorIndex - Vector within MultiVector that should to modify. In: ScalarValue - Value to add to existing value. Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.
def PyTrilinos::Epetra::Epetra_MultiVector::Update | ( | self, | ||
args | ||||
) |
Update(self, double ScalarA, Epetra_MultiVector A, double ScalarThis) -> int Update(self, double ScalarA, Epetra_MultiVector A, double ScalarB, Epetra_MultiVector B, double ScalarThis) -> int int Epetra_MultiVector::Update(double ScalarA, const Epetra_MultiVector &A, double ScalarB, const Epetra_MultiVector &B, double ScalarThis) Update multi-vector with scaled values of A and B, this = ScalarThis* this + ScalarA*A + ScalarB*B. Parameters: ----------- In: ScalarA - Scale value for A. In: A - Multi-vector to add. In: ScalarB - Scale value for B. In: B - Multi-vector to add. In: ScalarThis - Scale value for this. Out: This - Multi-vector with updatede values. Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Update | ( | self, | ||
args | ||||
) |
Update(self, double ScalarA, Epetra_MultiVector A, double ScalarThis) -> int Update(self, double ScalarA, Epetra_MultiVector A, double ScalarB, Epetra_MultiVector B, double ScalarThis) -> int int Epetra_MultiVector::Update(double ScalarA, const Epetra_MultiVector &A, double ScalarB, const Epetra_MultiVector &B, double ScalarThis) Update multi-vector with scaled values of A and B, this = ScalarThis* this + ScalarA*A + ScalarB*B. Parameters: ----------- In: ScalarA - Scale value for A. In: A - Multi-vector to add. In: ScalarB - Scale value for B. In: B - Multi-vector to add. In: ScalarThis - Scale value for this. Out: This - Multi-vector with updatede values. Integer error code, set to 0 if successful.
def PyTrilinos::Epetra::Epetra_MultiVector::Values | ( | self, | ||
args | ||||
) |
Values(self) -> double double* Epetra_MultiVector::Values() const Get pointer to MultiVector values.
def PyTrilinos::Epetra::Epetra_MultiVector::Values | ( | self, | ||
args | ||||
) |
Values(self) -> double double* Epetra_MultiVector::Values() const Get pointer to MultiVector values.