Mat - Low-level Interface

MatAIJGetLocalMat(petsclib::PetscLibType,A::PetscMat, A_loc::PetscMat)

Creates a MATSEQAIJ from a MATAIJ matrix.

Not Collective

Input Parameter:

• A - the matrix

Output Parameter:

• A_loc - the local sequential matrix generated

Level: developer

-seealso: , Mat, MatMPIAIJGetLocalMat()

External Links

• PETSc Manual: Mat/MatAIJGetLocalMat

MatAXPY(petsclib::PetscLibType,Y::PetscMat, a::PetscScalar, X::PetscMat, str::MatStructure)

Computes Y = a*X + Y.

Logically Collective

Input Parameters:

• a - the scalar multiplier
• X - the first matrix
• Y - the second matrix
• str - either SAME_NONZERO_PATTERN, DIFFERENT_NONZERO_PATTERN, UNKNOWN_NONZERO_PATTERN, or SUBSET_NONZERO_PATTERN (nonzeros of X is a subset of Y's)

Level: intermediate

-seealso: , Mat, MatAYPX()

External Links

• PETSc Manual: Mat/MatAXPY

MatAYPX(petsclib::PetscLibType,Y::PetscMat, a::PetscScalar, X::PetscMat, str::MatStructure)

Computes Y = a*Y + X.

Logically Collective

Input Parameters:

• a - the PetscScalar multiplier
• Y - the first matrix
• X - the second matrix
• str - either SAME_NONZERO_PATTERN, DIFFERENT_NONZERO_PATTERN, UNKNOWN_NONZERO_PATTERN, or SUBSET_NONZERO_PATTERN (nonzeros of X is a subset of Y's)

Level: intermediate

-seealso: , Mat, MatAXPY()

External Links

• PETSc Manual: Mat/MatAYPX

MatAppendOptionsPrefix(petsclib::PetscLibType,A::PetscMat, prefix::Vector{Cchar})

Appends to the prefix used for searching for all matrix options in the database.

Logically Collective

Input Parameters:

• A - the matrix
• prefix - the prefix to prepend to all option names

Level: advanced

-seealso: , Mat, MatGetOptionsPrefix(), MatAppendOptionsPrefixFactor(), MatSetOptionsPrefix()

External Links

• PETSc Manual: Mat/MatAppendOptionsPrefix

MatAppendOptionsPrefixFactor(petsclib::PetscLibType,A::PetscMat, prefix::Vector{Cchar})

Appends to the prefix used for searching for all matrix factor options in the database for for matrices created with MatGetFactor()

Logically Collective

Input Parameters:

• A - the matrix
• prefix - the prefix to prepend to all option names for the factored matrix

Level: developer

-seealso: , Mat, Matrix Factorization, MatGetFactor(), PetscOptionsCreate(), PetscOptionsDestroy(), PetscObjectSetOptionsPrefix(), PetscObjectPrependOptionsPrefix(), PetscObjectGetOptionsPrefix(), TSAppendOptionsPrefix(), SNESAppendOptionsPrefix(), KSPAppendOptionsPrefix(), MatSetOptionsPrefixFactor(), MatSetOptionsPrefix()

External Links

• PETSc Manual: Mat/MatAppendOptionsPrefixFactor

assembled::PetscBool = MatAssembled(petsclib::PetscLibType,mat::PetscMat)

Indicates if a matrix has been assembled and is ready for use; for example, in matrix-vector product.

Not Collective

Input Parameter:

• mat - the matrix

Output Parameter:

• assembled - PETSC_TRUE or PETSC_FALSE

Level: advanced

-seealso: , Mat, MatAssemblyEnd(), MatSetValues(), MatAssemblyBegin()

External Links

• PETSc Manual: Mat/MatAssembled

MatAssemblyBegin(petsclib::PetscLibType,mat::PetscMat, type::MatAssemblyType)

Begins assembling the matrix. This routine should be called after completing all calls to MatSetValues().

Collective

Input Parameters:

• mat - the matrix
• type - type of assembly, either MAT_FLUSH_ASSEMBLY or MAT_FINAL_ASSEMBLY

Level: beginner

-seealso: , Mat, MatAssemblyEnd(), MatSetValues(), MatAssembled()

External Links

• PETSc Manual: Mat/MatAssemblyBegin

MatAssemblyEnd(petsclib::PetscLibType,mat::PetscMat, type::MatAssemblyType)

Completes assembling the matrix. This routine should be called after MatAssemblyBegin().

Collective

Input Parameters:

• mat - the matrix
• type - type of assembly, either MAT_FLUSH_ASSEMBLY or MAT_FINAL_ASSEMBLY

Options Database Keys:

• -mat_view ::ascii_info - Prints info on matrix at conclusion of MatAssemblyEnd()
• -mat_view ::ascii_info_detail - Prints more detailed info
• -mat_view - Prints matrix in ASCII format
• -mat_view ::ascii_matlab - Prints matrix in MATLAB format
• -mat_view draw - draws nonzero structure of matrix, using MatView() and PetscDrawOpenX().
• -display <name> - Sets display name (default is host)
• -draw_pause <sec> - Sets number of seconds to pause after display
• -mat_view socket - Sends matrix to socket, can be accessed from MATLAB (See Using MATLAB with PETSc)
• -viewer_socket_machine <machine> - Machine to use for socket
• -viewer_socket_port <port> - Port number to use for socket
• -mat_view binary:filename[:append] - Save matrix to file in binary format

Level: beginner

-seealso: , Mat, MatAssemblyBegin(), MatSetValues(), PetscDrawOpenX(), PetscDrawCreate(), MatView(), MatAssembled(), PetscViewerSocketOpen()

External Links

• PETSc Manual: Mat/MatAssemblyEnd

MatBackwardSolve(petsclib::PetscLibType,mat::PetscMat, b::PetscVec, x::PetscVec)

Solves U x = b, given a factored matrix, A = LU. D^(1/2) U x = b, given a factored symmetric matrix, A = U^TDU,

Neighbor-wise Collective

Input Parameters:

• mat - the factored matrix
• b - the right-hand-side vector

Output Parameter:

• x - the result vector

Level: developer

-seealso: , Mat, MatForwardSolve(), MatGetFactor(), MatSolve()

External Links

• PETSc Manual: Mat/MatBackwardSolve

MatBindToCPU(petsclib::PetscLibType,A::PetscMat, flg::PetscBool)

marks a matrix to temporarily stay on the CPU and perform computations on the CPU

Logically Collective

Input Parameters:

• A - the matrix
• flg - bind to the CPU if value of PETSC_TRUE

Level: intermediate

-seealso: , Mat, MatBoundToCPU()

External Links

• PETSc Manual: Mat/MatBindToCPU

MatBlockMatSetPreallocation(petsclib::PetscLibType,B::PetscMat, bs::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

For good matrix assembly performance the user should preallocate the matrix storage by setting the parameter nz (or the array nnz). By setting these parameters accurately, performance during matrix assembly can be increased by more than a factor of 50.

Collective

Input Parameters:

• B - The matrix
• bs - size of each block in matrix
• nz - number of nonzeros per block row (same for all rows)
• nnz - array containing the number of nonzeros in the various block rows

(possibly different for each row) or NULL

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateBlockMat(), MatSetValues()

External Links

• PETSc Manual: Mat/MatBlockMatSetPreallocation

flg::PetscBool = MatBoundToCPU(petsclib::PetscLibType,A::PetscMat)

query if a matrix is bound to the CPU

Input Parameter:

• A - the matrix

Output Parameter:

• flg - the logical flag

Level: intermediate

-seealso: , Mat, MatBindToCPU()

External Links

• PETSc Manual: Mat/MatBoundToCPU

MatCholeskyFactor(petsclib::PetscLibType,mat::PetscMat, perm::IS, info::MatFactorInfo)

Performs in symmetric matrix.

Collective

Input Parameters:

• mat - the matrix
• perm - row and column permutations
• info - expected fill as ratio of original fill

Level: developer

-seealso: , Mat, Matrix Factorization, MatGetFactor(), MatFactorInfo, MatLUFactor(), MatCholeskyFactorSymbolic(), MatCholeskyFactorNumeric() MatGetOrdering()

External Links

• PETSc Manual: Mat/MatCholeskyFactor

MatCholeskyFactorNumeric(petsclib::PetscLibType,fact::PetscMat, mat::PetscMat, info::MatFactorInfo)

Performs numeric Cholesky factorization of a symmetric matrix. Call this routine after first calling MatGetFactor() and MatCholeskyFactorSymbolic().

Collective

Input Parameters:

• fact - the factor matrix obtained with MatGetFactor(), where the factored values are stored
• mat - the initial matrix that is to be factored
• info - options for factorization

Level: developer

-seealso: , Mat, Matrix Factorization, MatFactorInfo, MatGetFactor(), MatCholeskyFactorSymbolic(), MatCholeskyFactor(), MatLUFactorNumeric()

External Links

• PETSc Manual: Mat/MatCholeskyFactorNumeric

MatCholeskyFactorSymbolic(petsclib::PetscLibType,fact::PetscMat, mat::PetscMat, perm::IS, info::MatFactorInfo)

Performs symbolic Cholesky factorization of a symmetric matrix.

Collective

Input Parameters:

• fact - the factor matrix obtained with MatGetFactor()
• mat - the matrix
• perm - row and column permutations
• info - options for factorization, includes

-seealso: , Mat, Matrix Factorization, MatFactorInfo, MatGetFactor(), MatLUFactorSymbolic(), MatCholeskyFactor(), MatCholeskyFactorNumeric() MatGetOrdering()

External Links

• PETSc Manual: Mat/MatCholeskyFactorSymbolic

MatCompositeAddMat(petsclib::PetscLibType,mat::PetscMat, smat::PetscMat)

Add another matrix to a composite matrix.

Collective

Input Parameters:

• mat - the composite matrix
• smat - the partial matrix

Level: advanced

-seealso: , Mat, MatCreateComposite(), MatCompositeGetMat(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeAddMat

MatCompositeGetMat(petsclib::PetscLibType,mat::PetscMat, i::PetscInt, Ai::PetscMat)

Returns the ith matrix from the composite matrix.

Logically Collective

Input Parameters:

• mat - the composite matrix
• i - the number of requested matrix

Output Parameter:

• Ai - ith matrix in composite

Level: advanced

-seealso: , Mat, MatCreateComposite(), MatCompositeGetNumberMat(), MatCompositeAddMat(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeGetMat

MatCompositeGetMatStructure(petsclib::PetscLibType,mat::PetscMat, str::MatStructure)

Returns the structure of matrices in the composite matrix.

Not Collective

Input Parameter:

• mat - the composite matrix

Output Parameter:

• str - structure of the matrices

Level: advanced

-seealso: , Mat, MatCreateComposite(), MatCompositeSetMatStructure(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeGetMatStructure

nmat::PetscInt = MatCompositeGetNumberMat(petsclib::PetscLibType,mat::PetscMat)

Returns the number of matrices in the composite matrix.

Not Collective

Input Parameter:

• mat - the composite matrix

Output Parameter:

• nmat - number of matrices in the composite matrix

Level: advanced

-seealso: , Mat, MatCreateComposite(), MatCompositeGetMat(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeGetNumberMat

type::MatCompositeType = MatCompositeGetType(petsclib::PetscLibType,mat::PetscMat)

Returns type of composite.

Not Collective

Input Parameter:

• mat - the composite matrix

Output Parameter:

• type - type of composite

Level: advanced

-seealso: , Mat, MatCreateComposite(), MatCompositeSetType(), MATCOMPOSITE, MatCompositeType

External Links

• PETSc Manual: Mat/MatCompositeGetType

MatCompositeMerge(petsclib::PetscLibType,mat::PetscMat)

Given a composite matrix, replaces it with a "regular" matrix by summing or computing the product of all the matrices inside the composite matrix.

Collective

Input Parameter:

• mat - the composite matrix

Options Database Keys:

• -mat_composite_merge - merge in MatAssemblyEnd()
• -mat_composite_merge_type - set merge direction

Level: advanced

-seealso: , Mat, MatDestroy(), MatMult(), MatCompositeAddMat(), MatCreateComposite(), MatCompositeSetMatStructure(), MatCompositeSetMergeType(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeMerge

MatCompositeSetMatStructure(petsclib::PetscLibType,mat::PetscMat, str::MatStructure)

Indicates structure of matrices in the composite matrix.

Not Collective

Input Parameters:

• mat - the composite matrix
• str - either SAME_NONZERO_PATTERN, DIFFERENT_NONZERO_PATTERN (default) or SUBSET_NONZERO_PATTERN

Level: advanced

-seealso: , Mat, MatAXPY(), MatCreateComposite(), MatCompositeMerge() MatCompositeGetMatStructure(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeSetMatStructure

MatCompositeSetMergeType(petsclib::PetscLibType,mat::PetscMat, type::MatCompositeMergeType)

Sets order of MatCompositeMerge().

Logically Collective

Input Parameters:

• mat - the composite matrix
• type - MAT_COMPOSITE_MERGE RIGHT (default) to start merge from right with the first added matrix (mat[0]),

MAT_COMPOSITE_MERGE_LEFT to start merge from left with the last added matrix (mat[nmat-1])

Level: advanced

-seealso: , Mat, MatCreateComposite(), MatCompositeMerge(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeSetMergeType

scalings::PetscScalar = MatCompositeSetScalings(petsclib::PetscLibType,mat::PetscMat)

Sets separate scaling factors for component matrices.

Logically Collective

Input Parameters:

• mat - the composite matrix
• scalings - array of scaling factors with scalings[i] being factor of i-th matrix, for i in [0, nmat)

Level: advanced

-seealso: , Mat, MatScale(), MatDiagonalScale(), MATCOMPOSITE

External Links

• PETSc Manual: Mat/MatCompositeSetScalings

MatCompositeSetType(petsclib::PetscLibType,mat::PetscMat, type::MatCompositeType)

Indicates if the matrix is defined as the sum of a set of matrices or the product.

Logically Collective

Input Parameters:

• mat - the composite matrix
• type - the MatCompositeType to use for the matrix

Level: advanced

-seealso: , Mat, MatDestroy(), MatMult(), MatCompositeAddMat(), MatCreateComposite(), MatCompositeGetType(), MATCOMPOSITE, MatCompositeType

External Links

• PETSc Manual: Mat/MatCompositeSetType

bw::PetscInt = MatComputeBandwidth(petsclib::PetscLibType,A::PetscMat, fraction::PetscReal)

Calculate the full bandwidth of the matrix, meaning the width 2k+1 where k diagonals on either side are sufficient to contain all the matrix nonzeros.

Collective

Input Parameters:

• A - The Mat
• fraction - An optional percentage of the Frobenius norm of the matrix that the bandwidth should enclose

Output Parameter:

• bw - The matrix bandwidth

Level: beginner

-seealso: DMPlexCreate(), DMPlexSetConeSize(), DMPlexSetChart()

External Links

• PETSc Manual: Mat/MatComputeBandwidth

MatComputeOperator(petsclib::PetscLibType,inmat::PetscMat, mattype::MatType, mat::PetscMat)

Computes the explicit matrix

Collective

Input Parameters:

• inmat - the matrix
• mattype - the matrix type for the explicit operator

Output Parameter:

• mat - the explicit operator

Level: advanced

-seealso: , Mat, MatConvert(), MatMult(), MatComputeOperatorTranspose()

External Links

• PETSc Manual: Mat/MatComputeOperator

MatComputeOperatorTranspose(petsclib::PetscLibType,inmat::PetscMat, mattype::MatType, mat::PetscMat)

Computes the explicit matrix representation of a give matrix that can apply MatMultTranspose()

Collective

Input Parameters:

• inmat - the matrix
• mattype - the matrix type for the explicit operator

Output Parameter:

• mat - the explicit operator transposed

Level: advanced

-seealso: , Mat, MatConvert(), MatMult(), MatComputeOperator()

External Links

• PETSc Manual: Mat/MatComputeOperatorTranspose

MatComputeVariableBlockEnvelope(petsclib::PetscLibType,mat::PetscMat)

Given a matrix whose nonzeros are in blocks along the diagonal this computes and stores the sizes of these blocks in the matrix. An individual block may lie over several processes.

Collective

Input Parameter:

• mat - the matrix

Level: intermediate

-seealso: , Mat, MatInvertVariableBlockEnvelope(), MatSetVariableBlockSizes()

External Links

• PETSc Manual: Mat/MatComputeVariableBlockEnvelope

MatConjugate(petsclib::PetscLibType,mat::PetscMat)

replaces the matrix values with their complex conjugates

Logically Collective

Input Parameter:

• mat - the matrix

Level: advanced

-seealso: , Mat, MatRealPart(), MatImaginaryPart(), VecConjugate(), MatTranspose()

External Links

• PETSc Manual: Mat/MatConjugate

value::PetscScalar = MatConstantDiagonalGetConstant(petsclib::PetscLibType,mat::PetscMat)

Get the scalar constant of a constant diagonal matrix

Not collective

Input Parameter:

• mat - a MATCONSTANTDIAGONAL

Output Parameter:

• value - the scalar value

Level: developer

-seealso: , Mat, MatDestroy(), MATCONSTANTDIAGONAL

External Links

• PETSc Manual: Mat/MatConstantDiagonalGetConstant

MatConvert(petsclib::PetscLibType,mat::PetscMat, newtype::MatType, reuse::MatReuse, M::PetscMat)

Converts a matrix to another matrix, either of the same or different type.

Collective

Input Parameters:

• mat - the matrix
• newtype - new matrix type. Use MATSAME to create a new matrix of the

same type as the original matrix.

• reuse - denotes if the destination matrix is to be created or reused.

Use MAT_INPLACE_MATRIX for inplace conversion (that is when you want the input Mat to be changed to contain the matrix in the new format), otherwise use MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX (can only be used after the first call was made with MAT_INITIAL_MATRIX, causes the matrix space in M to be reused).

Output Parameter:

• M - pointer to place new matrix

Level: intermediate

-seealso: , Mat, MatCopy(), MatDuplicate(), MAT_INITIAL_MATRIX, MAT_REUSE_MATRIX, MAT_INPLACE_MATRIX

External Links

• PETSc Manual: Mat/MatConvert

MatCopy(petsclib::PetscLibType,A::PetscMat, B::PetscMat, str::MatStructure)

Copies a matrix to another matrix.

Collective

Input Parameters:

• A - the matrix
• str - SAME_NONZERO_PATTERN or DIFFERENT_NONZERO_PATTERN

Output Parameter:

• B - where the copy is put

Level: intermediate

-seealso: , Mat, MatConvert(), MatDuplicate()

External Links

• PETSc Manual: Mat/MatCopy

MatCopyHashToXAIJ(petsclib::PetscLibType,A::PetscMat, B::PetscMat)

copy hash table entries into an XAIJ matrix type

Logically Collective

Input Parameter:

• A - A matrix in unassembled, hash table form

Output Parameter:

• B - The XAIJ matrix. This can either be A or some matrix of equivalent size, e.g. obtained from A via MatDuplicate()

Example: -seealso: , Mat, MAT_USE_HASH_TABLE

External Links

• PETSc Manual: Mat/MatCopyHashToXAIJ

A::PetscMat = MatCreate(petsclib::PetscLibType,comm::MPI_Comm)

Creates a matrix where the type is determined from either a call to MatSetType() or from the options database with a call to MatSetFromOptions().

Collective

Input Parameter:

• comm - MPI communicator

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_type seqaij - MATSEQAIJ type, uses MatCreateSeqAIJ()
• -mat_type mpiaij - MATMPIAIJ type, uses MatCreateAIJ()
• -mat_type seqdense - MATSEQDENSE, uses MatCreateSeqDense()
• -mat_type mpidense - MATMPIDENSE type, uses MatCreateDense()
• -mat_type seqbaij - MATSEQBAIJ type, uses MatCreateSeqBAIJ()
• -mat_type mpibaij - MATMPIBAIJ type, uses MatCreateBAIJ()

See the manpages for particular formats (e.g., MATSEQAIJ) for additional format-specific options.

Level: beginner

-seealso: , Mat, MatCreateSeqAIJ(), MatCreateAIJ(), MatCreateSeqDense(), MatCreateDense(), MatCreateSeqBAIJ(), MatCreateBAIJ(), MatCreateSeqSBAIJ(), MatCreateSBAIJ(), MatConvert()

External Links

• PETSc Manual: Mat/MatCreate

A::PetscMat = MatCreateAIJ(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

Creates a sparse parallel matrix in MATAIJ format (the default parallel PETSc format). For good matrix assembly performance the user should preallocate the matrix storage by setting the parameters d_nz (or d_nnz) and o_nz (or o_nnz).

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given). This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• n - This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_nz - number of nonzeros per row in DIAGONAL portion of local submatrix (same value is used for all local rows)
• d_nnz - array containing the number of nonzeros in the various rows of the DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if d_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e 'm'.
• o_nz - number of nonzeros per row in the OFF-DIAGONAL portion of local submatrix (same value is used for all local rows).
• o_nnz - array containing the number of nonzeros in the various rows of the OFF-DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if o_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e 'm'.

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_no_inode - Do not use inodes
• -mat_inode_limit <limit> - Sets inode limit (max limit=5)
• -matmult_vecscatter_view <viewer> - View the vecscatter (i.e., communication pattern) used in MatMult() of sparse parallel matrices.

See viewer types in manual of MatView(). Of them, ascii_matlab, draw or binary cause the VecScatter to be viewed as a matrix. Entry (i,j) is the size of message (in bytes) rank i sends to rank j in one MatMult() call.

Level: intermediate

-seealso: , Mat, Sparse Matrix Creation, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatMPIAIJSetPreallocation(), MatMPIAIJSetPreallocationCSR(), MATMPIAIJ, MatCreateMPIAIJWithArrays(), MatGetOwnershipRange(), MatGetOwnershipRanges(), MatGetOwnershipRangeColumn(), MatGetOwnershipRangesColumn(), PetscLayout

External Links

• PETSc Manual: Mat/MatCreateAIJ

A::PetscMat = MatCreateAIJKokkos(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

External Links

• PETSc Manual: Mat/MatCreateAIJKokkos

A::PetscMat = MatCreateAIJViennaCL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

External Links

• PETSc Manual: Mat/MatCreateAIJViennaCL

A::PetscMat = MatCreateBAIJ(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Union{Ptr,Vector{PetscInt}}, o_nz::PetscInt, o_nnz::Union{Ptr,Vector{PetscInt}})

Creates a sparse parallel matrix in MATBAIJ format (block compressed row).

Collective

Input Parameters:

• comm - MPI communicator
• bs - size of block, the blocks are ALWAYS square. One can use MatSetBlockSizes() to set a different row and column blocksize but the row blocksize always defines the size of the blocks. The column blocksize sets the blocksize of the vectors obtained with MatCreateVecs()
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given). This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• n - number of local columns (or PETSC_DECIDE to have calculated if N is given). This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_nz - number of nonzero blocks per block row in diagonal portion of local submatrix (same for all local rows)
• d_nnz - array containing the number of nonzero blocks in the various block rows of the in diagonal portion of the local (possibly different for each block row) or NULL. If you plan to factor the matrix you must leave room for the diagonal entry and set it even if it is zero.
• o_nz - number of nonzero blocks per block row in the off-diagonal portion of local submatrix (same for all local rows).
• o_nnz - array containing the number of nonzero blocks in the various block rows of the off-diagonal portion of the local submatrix (possibly different for each block row) or NULL.

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_block_size - size of the blocks to use
• -mat_use_hash_table <fact> - set hash table factor

Level: intermediate

-seealso: Mat, MatCreate(), MatCreateSeqBAIJ(), MatSetValues(), MatMPIBAIJSetPreallocation(), MatMPIBAIJSetPreallocationCSR(), MatGetOwnershipRange(), MatGetOwnershipRanges(), MatGetOwnershipRangeColumn(), MatGetOwnershipRangesColumn(), PetscLayout

External Links

• PETSc Manual: Mat/MatCreateBAIJ

A::PetscMat = MatCreateBAIJMKL(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

Creates a sparse parallel matrix in MATBAIJMKL format (block compressed row).

Collective

Input Parameters:

• comm - MPI communicator
• bs - size of block, the blocks are ALWAYS square. One can use MatSetBlockSizes() to set a different row and column blocksize but the row blocksize always defines the size of the blocks. The column blocksize sets the blocksize of the vectors obtained with MatCreateVecs()
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given) This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• n - number of local columns (or PETSC_DECIDE to have calculated if N is given) This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_nz - number of nonzero blocks per block row in diagonal portion of local submatrix (same for all local rows)
• d_nnz - array containing the number of nonzero blocks in the various block rows of the in diagonal portion of the local (possibly different for each block row) or NULL. If you plan to factor the matrix you must leave room for the diagonal entry and set it even if it is zero.
• o_nz - number of nonzero blocks per block row in the off-diagonal portion of local submatrix (same for all local rows).
• o_nnz - array containing the number of nonzero blocks in the various block rows of the off-diagonal portion of the local submatrix (possibly different for each block row) or NULL.

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_block_size - size of the blocks to use
• -mat_use_hash_table <fact> - set hash table factor

Level: intermediate

-seealso: , Mat, MATBAIJMKL, MATBAIJ, MatCreate(), MatCreateSeqBAIJMKL(), MatSetValues(), MatMPIBAIJSetPreallocation(), MatMPIBAIJSetPreallocationCSR()

External Links

• PETSc Manual: Mat/MatCreateBAIJMKL

A::PetscMat = MatCreateBlockMat(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, bs::PetscInt, nz::PetscInt, nnz::Union{Ptr,Vector{PetscInt}})

Creates a new matrix in which each block contains a uniform

Collective

Input Parameters:

• comm - MPI communicator
• m - number of rows
• n - number of columns
• bs - size of each submatrix
• nz - expected maximum number of nonzero blocks in row (use PETSC_DEFAULT if not known)
• nnz - expected number of nonzers per block row if known (use NULL otherwise)

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, MATBLOCKMAT, MatCreateNest()

External Links

• PETSc Manual: Mat/MatCreateBlockMat

C::PetscMat = MatCreateCentering(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a new matrix object that implements the (symmetric and idempotent) centering matrix, I

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows (or PETSC_DECIDE to have calculated if N is given) This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• N - number of global rows (or PETSC_DETERMINE to have calculated if n is given)

Output Parameter:

• C - the matrix

-seealso: , Mat, MatCreateLRC(), MatCreateComposite()

External Links

• PETSc Manual: Mat/MatCreateCentering

mats::PetscMat,mat::PetscMat = MatCreateComposite(petsclib::PetscLibType,comm::MPI_Comm, nmat::PetscInt)

Creates a matrix as the sum or product of one or more matrices

Collective

Input Parameters:

• comm - MPI communicator
• nmat - number of matrices to put in
• mats - the matrices

Output Parameter:

• mat - the matrix

Options Database Keys:

• -mat_composite_merge - merge in MatAssemblyEnd()
• -mat_composite_merge_mvctx - merge Mvctx of component matrices to optimize communication in MatMult() for ADDITIVE matrices
• -mat_composite_merge_type - set merge direction

Level: advanced

-seealso: , Mat, MatDestroy(), MatMult(), MatCompositeAddMat(), MatCompositeGetMat(), MatCompositeMerge(), MatCompositeSetType(), MATCOMPOSITE, MatCompositeType

External Links

• PETSc Manual: Mat/MatCreateComposite

J::PetscMat = MatCreateConstantDiagonal(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, diag::PetscScalar)

Creates a matrix with a uniform value along the diagonal

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given). This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• n - This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• diag - the diagonal value

Output Parameter:

• J - the diagonal matrix

Level: advanced

-seealso: , Mat, MatDestroy(), MATCONSTANTDIAGONAL, MatScale(), MatShift(), MatMult(), MatGetDiagonal(), MatGetFactor(), MatSolve()

External Links

• PETSc Manual: Mat/MatCreateConstantDiagonal

A::PetscMat = MatCreateDense(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, data::Union{Ptr,Vector{PetscScalar}})

Creates a matrix in MATDENSE format.

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given)
• n - number of local columns (or PETSC_DECIDE to have calculated if N is given)
• M - number of global rows (or PETSC_DECIDE to have calculated if m is given)
• N - number of global columns (or PETSC_DECIDE to have calculated if n is given)
• data - optional location of matrix data. Set data to NULL (PETSC_NULL_SCALAR_ARRAY for Fortran users) for PETSc to control all matrix memory allocation.

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, MATDENSE, MatCreate(), MatCreateSeqDense(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateDense

data::PetscScalar,A::PetscMat = MatCreateDenseFromVecType(petsclib::PetscLibType,comm::MPI_Comm, vtype::VecType, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, lda::PetscInt)

Create a matrix that matches the type of a Vec.

Collective

Input Parameters:

• comm - the communicator
• vtype - the vector type
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given)
• n - number of local columns (or PETSC_DECIDE to have calculated if N is given)
• M - number of global rows (or PETSC_DECIDE to have calculated if m is given)
• N - number of global columns (or PETSC_DECIDE to have calculated if n is given)
• lda - optional leading dimension. Pass any non-positive number to use the default.
• data - optional location of matrix data, which should have the same memory type as the vector. Pass NULL to have PETSc take care of matrix memory allocation.

Output Parameter:

• A - the dense matrix

Level: advanced

-seealso: , Mat, MatCreateDense(), MatCreateDenseCUDA(), MatCreateDenseHIP(), PetscMemType

External Links

• PETSc Manual: Mat/MatCreateDenseFromVecType

J::PetscMat = MatCreateDiagonal(petsclib::PetscLibType,diag::PetscVec)

Creates a matrix defined by a given vector along its diagonal.

Collective

Input Parameter:

• diag - vector for the diagonal

Output Parameter:

• J - the diagonal matrix

Level: advanced

-seealso: , Mat, MatDestroy(), MATCONSTANTDIAGONAL, MatScale(), MatShift(), MatMult(), MatGetDiagonal(), MatSolve() MatDiagonalRestoreInverseDiagonal(), MatDiagonalGetDiagonal(), MatDiagonalRestoreDiagonal(), MatDiagonalGetInverseDiagonal()

External Links

• PETSc Manual: Mat/MatCreateDiagonal

A::PetscMat = MatCreateFFT(petsclib::PetscLibType,comm::MPI_Comm, ndim::PetscInt, dim::Vector{PetscInt}, mattype::MatType)

Creates a matrix object that provides FFT via an external package

Collective

Input Parameters:

• comm - MPI communicator
• ndim - the ndim-dimensional transform
• dim - array of size ndim, dim[i] contains the vector length in the i-dimension
• mattype - package type, e.g., MATFFTW or MATSEQCUFFT

Output Parameter:

• A - the matrix

Options Database Key:

• -mat_fft_type - set FFT type fft or seqcufft

Level: intermediate

-seealso: , Mat, MATFFTW, MATSEQCUFFT, MatCreateVecsFFTW()

External Links

• PETSc Manual: Mat/MatCreateFFT

A::PetscMat = MatCreateFromOptions(petsclib::PetscLibType,comm::MPI_Comm, prefix::Vector{Cchar}, bs::PetscInt, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt)

Creates a matrix whose type is set from the options database

Collective

Input Parameters:

• comm - MPI communicator
• prefix - [optional] prefix for the options database
• bs - the blocksize (commonly 1)
• m - the local number of rows (or PETSC_DECIDE)
• n - the local number of columns (or PETSC_DECIDE or PETSC_DETERMINE)
• M - the global number of rows (or PETSC_DETERMINE)
• N - the global number of columns (or PETSC_DETERMINE)

Output Parameter:

• A - the matrix

Options Database Key:

• -mat_type - see MatType, for example aij, aijcusparse, baij, sbaij, dense, defaults to aij

Level: beginner

-seealso: , Mat, MatCreateSeqAIJ(), MatCreateAIJ(), MatCreateSeqDense(), MatCreateDense(), MatCreateSeqBAIJ(), MatCreateBAIJ(), MatCreateSeqSBAIJ(), MatCreateSBAIJ(), MatConvert(), MatCreate()

External Links

• PETSc Manual: Mat/MatCreateFromOptions

graph::PetscMat = MatCreateGraph(petsclib::PetscLibType,A::PetscMat, sym::PetscBool, scale::PetscBool, filter::PetscReal, num_idx::PetscInt, index::Vector{PetscInt})

create a scalar matrix (that is a matrix with one vertex for each block vertex in the original matrix), for use in graph algorithms and possibly removes small values from the graph structure.

Collective

Input Parameters:

• A - the matrix
• sym - PETSC_TRUE indicates that the graph should be symmetrized
• scale - PETSC_TRUE indicates that the graph edge weights should be symmetrically scaled with the diagonal entry
• filter - filter value - < 0: does nothing; == 0: removes only 0.0 entries; otherwise: removes entries with abs(entries) <= value
• num_idx - size of 'index' array
• index - array of block indices to use for graph strength of connection weight

Output Parameter:

• graph - the resulting graph

Level: advanced

-seealso: , Mat, MatCreate(), PCGAMG

External Links

• PETSc Manual: Mat/MatCreateGraph

N::PetscMat = MatCreateHermitianTranspose(petsclib::PetscLibType,A::PetscMat)

Creates a new matrix object of MatType MATHERMITIANTRANSPOSEVIRTUAL that behaves like A'*

Collective

Input Parameter:

• A - the (possibly rectangular) matrix

Output Parameter:

• N - the matrix that represents A'*

Level: intermediate

-seealso: , Mat, MatCreateNormal(), MatMult(), MatMultHermitianTranspose(), MatCreate(), MATTRANSPOSEVIRTUAL, MatCreateTranspose(), MatHermitianTransposeGetMat(), MATNORMAL, MATNORMALHERMITIAN

External Links

• PETSc Manual: Mat/MatCreateHermitianTranspose

kernel::MatHtoolKernelFn,kernelctx::Cvoid,B::PetscMat = MatCreateHtoolFromKernel(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, spacedim::PetscInt, coords_target::Vector{PetscReal}, coords_source::Vector{PetscReal})

External Links

• PETSc Manual: Mat/MatCreateHtoolFromKernel

A::PetscMat = MatCreateIS(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, rmap::ISLocalToGlobalMapping, cmap::ISLocalToGlobalMapping)

Creates a "process" unassembled matrix.

Collective.

Input Parameters:

• comm - MPI communicator that will share the matrix
• bs - block size of the matrix
• m - local size of left vector used in matrix vector products
• n - local size of right vector used in matrix vector products
• M - global size of left vector used in matrix vector products
• N - global size of right vector used in matrix vector products
• rmap - local to global map for rows
• cmap - local to global map for cols

Output Parameter:

• A - the resulting matrix

Level: intermediate

-seealso: , Mat, MATIS, MatSetLocalToGlobalMapping()

External Links

• PETSc Manual: Mat/MatCreateIS

kaij::PetscMat = MatCreateKAIJ(petsclib::PetscLibType,A::PetscMat, p::PetscInt, q::PetscInt, S::Vector{PetscScalar}, T::Vector{PetscScalar})

Creates a matrix of type MATKAIJ.

Collective

Input Parameters:

• A - the MATAIJ matrix
• p - number of rows in S and T
• q - number of columns in S and T
• S - the S matrix (can be NULL), stored as a PetscScalar array (column-major)
• T - the T matrix (can be NULL), stored as a PetscScalar array (column-major)

Output Parameter:

• kaij - the new MATKAIJ matrix

Level: advanced

-seealso: , Mat, MatKAIJSetAIJ(), MatKAIJSetS(), MatKAIJSetT(), MatKAIJGetAIJ(), MatKAIJGetS(), MatKAIJGetT(), MATKAIJ

External Links

• PETSc Manual: Mat/MatCreateKAIJ

B::PetscMat = MatCreateLMVMBFGS(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a limited matrix used for approximating Jacobians. L-BFGS is symmetric positive-definite by construction, and is commonly used to approximate Hessians in optimization problems.

To use the L-BFGS matrix with other vector types, the matrix must be created using MatCreate() and MatSetType(), followed by MatLMVMAllocate(). This ensures that the internal storage and work vectors are duplicated from the correct type of vector.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_scale_type - (developer) type of scaling applied to J0 (none, scalar, diagonal)
• -mat_lmvm_theta - (developer) convex ratio between BFGS and DFP components of the diagonal J0 scaling
• -mat_lmvm_rho - (developer) update limiter for the J0 scaling
• -mat_lmvm_alpha - (developer) coefficient factor for the quadratic subproblem in J0 scaling
• -mat_lmvm_beta - (developer) exponential factor for the diagonal J0 scaling
• -mat_lmvm_sigma_hist - (developer) number of past updates to use in J0 scaling

Level: intermediate

-seealso: , MatCreate(), MATLMVM, MATLMVMBFGS, MatCreateLMVMDFP(), MatCreateLMVMSR1(), MatCreateLMVMBroyden(), MatCreateLMVMBadBroyden(), MatCreateLMVMSymBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMBFGS

B::PetscMat = MatCreateLMVMBadBroyden(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a limited approximation matrix used for a Jacobian. L-BadBrdn is not guaranteed to be symmetric or positive-definite.

To use the L-BadBrdn matrix with other vector types, the matrix must be created using MatCreate() and MatSetType(), followed by MatLMVMAllocate(). This ensures that the internal storage and work vectors are duplicated from the correct type of vector.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_hist_size - the number of history vectors to keep
• -mat_lmvm_mult_algorithm - the algorithm to use for multiplication (recursive, dense, compact_dense)
• -mat_lmvm_cache_J0_products - whether products between the base Jacobian J0 and history vectors should be cached or recomputed
• -mat_lmvm_debug - (developer) perform internal debugging checks

Level: intermediate

-seealso: , MatCreate(), MATLMVM, MATLMVMBADBRDN, MatCreateLMVMDFP(), MatCreateLMVMSR1(), MatCreateLMVMBFGS(), MatCreateLMVMBroyden(), MatCreateLMVMSymBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMBadBroyden

B::PetscMat = MatCreateLMVMBroyden(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a limited matrix used for a Jacobian. L-Brdn is not guaranteed to be symmetric or positive-definite.

To use the L-Brdn matrix with other vector types, the matrix must be created using MatCreate() and MatSetType(), followed by MatLMVMAllocate(). This ensures that the internal storage and work vectors are duplicated from the correct type of vector.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_hist_size - the number of history vectors to keep
• -mat_lmvm_mult_algorithm - the algorithm to use for multiplication (recursive, dense, compact_dense)
• -mat_lmvm_cache_J0_products - whether products between the base Jacobian J0 and history vectors should be cached or recomputed
• -mat_lmvm_debug - (developer) perform internal debugging checks

Level: intermediate

-seealso: , MatCreate(), MATLMVM, MATLMVMBRDN, MatCreateLMVMDFP(), MatCreateLMVMSR1(), MatCreateLMVMBFGS(), MatCreateLMVMBadBroyden(), MatCreateLMVMSymBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMBroyden

B::PetscMat = MatCreateLMVMDBFGS(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a dense representation of the limited Broyden-Fletcher-Goldfarb-Shanno (BFGS) approximation to a Hessian.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Level: advanced

-seealso: MatCreate(), MATLMVM, MATLMVMDBFGS, MatCreateLMVMBFGS()

External Links

• PETSc Manual: Ksp/MatCreateLMVMDBFGS

B::PetscMat = MatCreateLMVMDDFP(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a dense representation of the limited Davidon-Fletcher-Powell (DFP) approximation to a Hessian.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Level: advanced

-seealso: MatCreate(), MATLMVM, MATLMVMDDFP, MatCreateLMVMDFP()

External Links

• PETSc Manual: Ksp/MatCreateLMVMDDFP

B::PetscMat = MatCreateLMVMDFP(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a limited used for approximating Jacobians. L-DFP is symmetric positive-definite by construction, and is the dual of L-BFGS where Y and S vectors swap roles.

To use the L-DFP matrix with other vector types, the matrix must be created using MatCreate() and MatSetType(), followed by MatLMVMAllocate(). This ensures that the internal storage and work vectors are duplicated from the correct type of vector.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_scale_type - (developer) type of scaling applied to J0 (none, scalar, diagonal)
• -mat_lmvm_theta - (developer) convex ratio between BFGS and DFP components of the diagonal J0 scaling
• -mat_lmvm_rho - (developer) update limiter for the J0 scaling
• -mat_lmvm_alpha - (developer) coefficient factor for the quadratic subproblem in J0 scaling
• -mat_lmvm_beta - (developer) exponential factor for the diagonal J0 scaling
• -mat_lmvm_sigma_hist - (developer) number of past updates to use in J0 scaling

Level: intermediate

-seealso: , MatCreate(), MATLMVM, MATLMVMDFP, MatCreateLMVMBFGS(), MatCreateLMVMSR1(), MatCreateLMVMBroyden(), MatCreateLMVMBadBroyden(), MatCreateLMVMSymBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMDFP

B::PetscMat = MatCreateLMVMDQN(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a dense representation of the limited Quasi-Newton approximation to a Hessian.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Level: advanced

-seealso: MatCreate(), MATLMVM, MATLMVMDBFGS, MATLMVMDDFP, MatCreateLMVMDDFP(), MatCreateLMVMDBFGS()

External Links

• PETSc Manual: Ksp/MatCreateLMVMDQN

B::PetscMat = MatCreateLMVMDiagBroyden(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

DiagBrdn creates a symmetric Broyden for approximating Hessians.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_theta - (developer) convex ratio between BFGS and DFP components of the diagonal J0 scaling
• -mat_lmvm_rho - (developer) update limiter for the J0 scaling
• -mat_lmvm_alpha - (developer) coefficient factor for the quadratic subproblem in J0 scaling
• -mat_lmvm_beta - (developer) exponential factor for the diagonal J0 scaling
• -mat_lmvm_sigma_hist - (developer) number of past updates to use in J0 scaling.
• -mat_lmvm_tol - (developer) tolerance for bounding the denominator of the rescaling away from 0.
• -mat_lmvm_forward - (developer) whether or not to use the forward or backward Broyden update to the diagonal

Level: intermediate

-seealso: , MatCreate(), MATLMVM, MATLMVMDIAGBRDN, MatCreateLMVMDFP(), MatCreateLMVMSR1(), MatCreateLMVMBFGS(), MatCreateLMVMBroyden(), MatCreateLMVMSymBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMDiagBroyden

B::PetscMat = MatCreateLMVMSR1(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a limited matrix used for a Jacobian. L-SR1 is symmetric by construction, but is not guaranteed to be positive-definite.

To use the L-SR1 matrix with other vector types, the matrix must be created using MatCreate() and MatSetType(), followed by MatLMVMAllocate(). This ensures that the internal storage and work vectors are duplicated from the correct type of vector.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_hist_size - the number of history vectors to keep
• -mat_lmvm_mult_algorithm - the algorithm to use for multiplication (recursive, dense, compact_dense)
• -mat_lmvm_cache_J0_products - whether products between the base Jacobian J0 and history vectors should be cached or recomputed
• -mat_lmvm_eps - (developer) numerical zero tolerance for testing when an update should be skipped
• -mat_lmvm_debug - (developer) perform internal debugging checks

Level: intermediate

-seealso: , MatCreate(), MATLMVM, MATLMVMSR1, MatCreateLMVMBFGS(), MatCreateLMVMDFP(), MatCreateLMVMBroyden(), MatCreateLMVMBadBroyden(), MatCreateLMVMSymBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMSR1

B::PetscMat = MatCreateLMVMSymBadBroyden(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a limited for approximating Jacobians.

Collective

Input Parameters:

• comm - MPI communicator
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_hist_size - the number of history vectors to keep
• -mat_lmvm_psi - convex ratio between BFGS and DFP components of the update
• -mat_lmvm_scale_type - type of scaling applied to J0 (none, scalar, diagonal)
• -mat_lmvm_mult_algorithm - the algorithm to use for multiplication (recursive, dense, compact_dense)
• -mat_lmvm_cache_J0_products - whether products between the base Jacobian J0 and history vectors should be cached or recomputed
• -mat_lmvm_eps - (developer) numerical zero tolerance for testing when an update should be skipped
• -mat_lmvm_debug - (developer) perform internal debugging checks
• -mat_lmvm_theta - (developer) convex ratio between BFGS and DFP components of the diagonal J0 scaling
• -mat_lmvm_rho - (developer) update limiter for the J0 scaling
• -mat_lmvm_alpha - (developer) coefficient factor for the quadratic subproblem in J0 scaling
• -mat_lmvm_beta - (developer) exponential factor for the diagonal J0 scaling
• -mat_lmvm_sigma_hist - (developer) number of past updates to use in J0 scaling

Level: intermediate

-seealso: , LMVM Matrices, MatCreate(), MATLMVM, MATLMVMSYMBROYDEN, MatCreateLMVMDFP(), MatCreateLMVMSR1(), MatCreateLMVMBFGS(), MatCreateLMVMBroyden(), MatCreateLMVMBadBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMSymBadBroyden

B::PetscMat = MatCreateLMVMSymBroyden(petsclib::PetscLibType,comm::MPI_Comm, n::PetscInt, N::PetscInt)

Creates a limited for approximating Jacobians.

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• n - number of local rows for storage vectors
• N - global size of the storage vectors

Output Parameter:

• B - the matrix

Options Database Keys:

• -mat_lmvm_hist_size - the number of history vectors to keep
• -mat_lmvm_phi - convex ratio between BFGS and DFP components of the update
• -mat_lmvm_scale_type - type of scaling applied to J0 (none, scalar, diagonal)
• -mat_lmvm_mult_algorithm - the algorithm to use for multiplication (recursive, dense, compact_dense)
• -mat_lmvm_cache_J0_products - whether products between the base Jacobian J0 and history vectors should be cached or recomputed
• -mat_lmvm_eps - (developer) numerical zero tolerance for testing when an update should be skipped
• -mat_lmvm_debug - (developer) perform internal debugging checks
• -mat_lmvm_theta - (developer) convex ratio between BFGS and DFP components of the diagonal J0 scaling
• -mat_lmvm_rho - (developer) update limiter for the J0 scaling
• -mat_lmvm_alpha - (developer) coefficient factor for the quadratic subproblem in J0 scaling
• -mat_lmvm_beta - (developer) exponential factor for the diagonal J0 scaling
• -mat_lmvm_sigma_hist - (developer) number of past updates to use in J0 scaling

Level: intermediate

-seealso: , MatCreate(), MATLMVM, MATLMVMSYMBROYDEN, MatCreateLMVMDFP(), MatCreateLMVMSR1(), MatCreateLMVMBFGS(), MatCreateLMVMBroyden(), MatCreateLMVMBadBroyden()

External Links

• PETSc Manual: Ksp/MatCreateLMVMSymBroyden

N::PetscMat = MatCreateLRC(petsclib::PetscLibType,A::PetscMat, U::PetscMat, c::PetscVec, V::PetscMat)

Creates a new matrix object that behaves like A + UCV' of type MATLRC

Collective

Input Parameters:

• A - the (sparse) matrix (can be NULL)
• U - dense rectangular (tall and skinny) matrix
• V - dense rectangular (tall and skinny) matrix
• c - a vector containing the diagonal of C (can be NULL)

Output Parameter:

• N - the matrix that represents A + UCV'

Level: intermediate

-seealso: , Mat, MATLRC, MatLRCGetMats()

External Links

• PETSc Manual: Mat/MatCreateLRC

L::PetscMat = MatCreateLaplacian(petsclib::PetscLibType,A::PetscMat, tol::PetscReal, weighted::PetscBool)

Create the matrix Laplacian, with all values in the matrix less than the tolerance set to zero

Input Parameters:

• A - The matrix
• tol - The zero tolerance
• weighted - Flag for using edge weights

Output Parameter:

• L - The graph Laplacian matrix

Level: intermediate

-seealso: MatFilter(), MatGetGraph()

External Links

• PETSc Manual: Mat/MatCreateLaplacian

newmat::PetscMat = MatCreateLocalRef(petsclib::PetscLibType,A::PetscMat, isrow::IS, iscol::IS)

Gets a logical reference to a local submatrix, for use in assembly, that is to set values into the matrix

Not Collective

Input Parameters:

• A - full matrix, generally parallel
• isrow - Local index set for the rows
• iscol - Local index set for the columns

Output Parameter:

• newmat - new serial Mat

Level: developer

-seealso: , Mat, MATSUBMATRIX, MatCreateSubMatrixVirtual(), MatSetValuesLocal(), MatSetValuesBlockedLocal(), MatGetLocalSubMatrix(), MatCreateSubMatrix()

External Links

• PETSc Manual: Mat/MatCreateLocalRef

maij::PetscMat = MatCreateMAIJ(petsclib::PetscLibType,A::PetscMat, dof::PetscInt)

Creates a matrix type providing restriction and interpolation operations for multicomponent problems. It interpolates each component the same way independently. The matrix type is based on MATSEQAIJ for sequential matrices, and MATMPIAIJ for distributed matrices.

Collective

Input Parameters:

• A - the MATAIJ matrix describing the action on blocks
• dof - the block size (number of components per node)

Output Parameter:

• maij - the new MATMAIJ matrix

Level: advanced

-seealso: , Mat, MATAIJ, MATMAIJ, MatMAIJGetAIJ(), MatMAIJRedimension()

External Links

• PETSc Manual: Mat/MatCreateMAIJ

J::PetscMat = MatCreateMFFD(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt)

Creates a matrix approximately multiply a vector by the matrix (Jacobian) . See also MatCreateSNESMF()

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given). This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• n - This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)

Output Parameter:

• J - the matrix-free matrix

Options Database Keys:

• -mat_mffd_type - wp or ds (see MATMFFD_WP or MATMFFD_DS)
• -mat_mffd_err - square root of estimated relative error in function evaluation
• -mat_mffd_period - how often h is recomputed, defaults to 1, every time
• -mat_mffd_check_positivity - possibly decrease h until U + h*a has only positive values
• -mat_mffd_umin <umin> - Sets umin (for default PETSc routine that computes h only)
• -mat_mffd_complex - use the Lyness trick with complex numbers to compute the matrix-vector product instead of differencing (requires real valued functions but that PETSc be configured for complex numbers)
• -snes_mf - use the finite difference based matrix-free matrix with SNESSolve() and no preconditioner
• -snes_mf_operator - use the finite difference based matrix-free matrix with SNESSolve() but construct a preconditioner

using the matrix passed as pmat to SNESSetJacobian().

Level: advanced

-seealso: , Mat, MATMFFD, MatDestroy(), MatMFFDSetFunctionError(), MatMFFDDSSetUmin(), MatMFFDSetFunction() MatMFFDSetHHistory(), MatMFFDResetHHistory(), MatCreateSNESMF(), MatCreateShell(), MATSHELL, MatMFFDGetH(), MatMFFDRegister(), MatMFFDComputeJacobian()

External Links

• PETSc Manual: Mat/MatCreateMFFD

A::PetscMat = MatCreateMPIAIJCRL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt}, onz::PetscInt, onnz::Vector{PetscInt})

Creates a sparse matrix of type MATMPIAIJCRL.

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• nz - number of nonzeros per row (same for all rows), for the "diagonal" submatrix
• nnz - array containing the number of nonzeros in the various rows (possibly different for each row) or NULL, for the "diagonal" submatrix
• onz - number of nonzeros per row (same for all rows), for the "off-diagonal" submatrix
• onnz - array containing the number of nonzeros in the various rows (possibly different for each row) or NULL, for the "off-diagonal" submatrix

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, Sparse Matrix Creation, MATAIJ, MATAIJSELL, MATAIJPERM, MATAIJMKL, MatCreate(), MatCreateMPIAIJPERM(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateMPIAIJCRL

A::PetscMat = MatCreateMPIAIJMKL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

Creates a sparse parallel matrix whose local portions are stored as MATSEQAIJMKL matrices (a matrix class that inherits from MATSEQAIJ but uses some operations provided by Intel MKL).

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given)

This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.

• n - This value should be the same as the local size used in creating the

x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.

• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_nz - number of nonzeros per row in DIAGONAL portion of local submatrix

(same value is used for all local rows)

• d_nnz - array containing the number of nonzeros in the various rows of the

DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if d_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m. For matrices you plan to factor you must leave room for the diagonal entry and put in the entry even if it is zero.

• o_nz - number of nonzeros per row in the OFF-DIAGONAL portion of local

submatrix (same value is used for all local rows).

• o_nnz - array containing the number of nonzeros in the various rows of the

OFF-DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if o_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m.

Output Parameter:

• A - the matrix

Options Database Key:

• -mat_aijmkl_no_spmv2 - disables use of the SpMV2 inspector-executor routines

Level: intermediate

-seealso: , Mat, Sparse Matrix Creation, MATMPIAIJMKL, MatCreate(), MatCreateSeqAIJMKL(), MatSetValues(), MatGetOwnershipRange(), MatGetOwnershipRanges(), MatGetOwnershipRangeColumn(), MatGetOwnershipRangesColumn(), PetscLayout

External Links

• PETSc Manual: Mat/MatCreateMPIAIJMKL

A::PetscMat = MatCreateMPIAIJPERM(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

Creates a sparse parallel matrix whose local portions are stored as MATSEQAIJPERM matrices (a matrix class that inherits from SEQAIJ but includes some optimizations to allow more effective vectorization).

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given)

This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.

• n - This value should be the same as the local size used in creating the

x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.

• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_nz - number of nonzeros per row in DIAGONAL portion of local submatrix

(same value is used for all local rows)

• d_nnz - array containing the number of nonzeros in the various rows of the

DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if d_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m. For matrices you plan to factor you must leave room for the diagonal entry and put in the entry even if it is zero.

• o_nz - number of nonzeros per row in the OFF-DIAGONAL portion of local

submatrix (same value is used for all local rows).

• o_nnz - array containing the number of nonzeros in the various rows of the

OFF-DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if o_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m.

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_no_inode - Do not use inodes
• -mat_inode_limit <limit> - Sets inode limit (max limit=5)

Level: intermediate

-seealso: , Mat, Sparse Matrix Creation, MATMPIAIJPERM, MatCreate(), MatCreateSeqAIJPERM(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateMPIAIJPERM

A::PetscMat = MatCreateMPIAIJSELL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

Creates a sparse parallel matrix whose local portions are stored as MATSEQAIJSELL matrices (a matrix class that inherits from SEQAIJ but performs some operations in SELL format).

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given)

This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.

• n - This value should be the same as the local size used in creating the

x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.

• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_nz - number of nonzeros per row in DIAGONAL portion of local submatrix

(same value is used for all local rows)

• d_nnz - array containing the number of nonzeros in the various rows of the

DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if d_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m. For matrices you plan to factor you must leave room for the diagonal entry and put in the entry even if it is zero.

• o_nz - number of nonzeros per row in the OFF-DIAGONAL portion of local

submatrix (same value is used for all local rows).

• o_nnz - array containing the number of nonzeros in the various rows of the

OFF-DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if o_nz is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m.

Output Parameter:

• A - the matrix

Options Database Key:

• -mat_aijsell_eager_shadow - Construct shadow matrix upon matrix assembly; default is to take a "lazy" approach, performing this step the first

time the matrix is applied

Level: intermediate

-seealso: , Mat, Sparse Matrix Creation, MATSEQAIJSELL, MATMPIAIJSELL, MATAIJSELL, MatCreate(), MatCreateSeqAIJSELL(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateMPIAIJSELL

mpimat::PetscMat = MatCreateMPIAIJSumSeqAIJ(petsclib::PetscLibType,comm::MPI_Comm, seqmat::PetscMat, m::PetscInt, n::PetscInt, scall::MatReuse)

Creates a MATMPIAIJ matrix by adding sequential matrices from each processor

Collective

Input Parameters:

• comm - the communicators the parallel matrix will live on
• seqmat - the input sequential matrices
• m - number of local rows (or PETSC_DECIDE)
• n - number of local columns (or PETSC_DECIDE)
• scall - either MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX

Output Parameter:

• mpimat - the parallel matrix generated

Level: advanced

-seealso: , Mat, MatCreateAIJ()

External Links

• PETSc Manual: Mat/MatCreateMPIAIJSumSeqAIJ

MatCreateMPIAIJSumSeqAIJNumeric(petsclib::PetscLibType,seqmat::PetscMat, mpimat::PetscMat)

External Links

• PETSc Manual: Mat/MatCreateMPIAIJSumSeqAIJNumeric

mpimat::PetscMat = MatCreateMPIAIJSumSeqAIJSymbolic(petsclib::PetscLibType,comm::MPI_Comm, seqmat::PetscMat, m::PetscInt, n::PetscInt)

External Links

• PETSc Manual: Mat/MatCreateMPIAIJSumSeqAIJSymbolic

mat::PetscMat = MatCreateMPIAIJWithArrays(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar})

creates a MATMPIAIJ matrix using arrays that contain in standard CSR format for the local rows.

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (Cannot be PETSC_DECIDE)
• n - This value should be the same as the local size used in creating the

x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.

• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• i - row indices (of length m+1); that is i[0] = 0, i[row] = i[row-1] + number of elements in that row of the matrix
• j - global column indices
• a - optional matrix values

Output Parameter:

• mat - the matrix

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatMPIAIJSetPreallocation(), MatMPIAIJSetPreallocationCSR(), MATMPIAIJ, MatCreateAIJ(), MatCreateMPIAIJWithSplitArrays(), MatUpdateMPIAIJWithArray(), MatSetPreallocationCOO(), MatSetValuesCOO()

External Links

• PETSc Manual: Mat/MatCreateMPIAIJWithArrays

garray::PetscInt,mat::PetscMat = MatCreateMPIAIJWithSeqAIJ(petsclib::PetscLibType,comm::MPI_Comm, M::PetscInt, N::PetscInt, A::PetscMat, B::PetscMat)

creates a MATMPIAIJ matrix using MATSEQAIJ matrices that contain the "diagonal" and "off-diagonal" part of the matrix in CSR format.

Collective

Input Parameters:

• comm - MPI communicator
• M - the global row size
• N - the global column size
• A - "diagonal" portion of matrix
• B - if garray is NULL, B should be the offdiag matrix using global col ids and of size N - if garray is not NULL, B should be the offdiag matrix using local col ids and of size garray
• garray - either NULL or the global index of B columns. If not NULL, it should be allocated by PetscMalloc1() and will be owned by mat thereafter.

Output Parameter:

• mat - the matrix, with input A as its local diagonal matrix

Level: advanced

-seealso: , Mat, MATMPIAIJ, MATSEQAIJ, MatCreateMPIAIJWithSplitArrays()

External Links

• PETSc Manual: Mat/MatCreateMPIAIJWithSeqAIJ

mat::PetscMat = MatCreateMPIAIJWithSplitArrays(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar}, oi::Vector{PetscInt}, oj::Vector{PetscInt}, oa::Vector{PetscScalar})

creates a MATMPIAIJ matrix using arrays that contain the "diagonal" and "off-diagonal" part of the matrix in CSR format.

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (Cannot be PETSC_DECIDE)
• n - This value should be the same as the local size used in creating the

x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.

• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• i - row indices for "diagonal" portion of matrix; that is i[0] = 0, i[row] = i[row-1] + number of elements in that row of the matrix
• j - column indices, which must be local, i.e., based off the start column of the diagonal portion
• a - matrix values
• oi - row indices for "off-diagonal" portion of matrix; that is oi[0] = 0, oi[row] = oi[row-1] + number of elements in that row of the matrix
• oj - column indices, which must be global, representing global columns in the MATMPIAIJ matrix
• oa - matrix values

Output Parameter:

• mat - the matrix

Level: advanced

-seealso: , Mat, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatMPIAIJSetPreallocation(), MatMPIAIJSetPreallocationCSR(), MATMPIAIJ, MatCreateAIJ(), MatCreateMPIAIJWithArrays()

External Links

• PETSc Manual: Mat/MatCreateMPIAIJWithSplitArrays

A::PetscMat = MatCreateMPIAdj(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, N::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, values::Vector{PetscInt})

Creates a sparse matrix representing an adjacency list. The matrix need not have numerical values associated with it, it is intended for ordering (to reduce bandwidth etc) and partitioning.

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows
• N - number of global columns
• i - the indices into j for the start of each row
• j - the column indices for each row (sorted for each row).
• values - the values, optional, use NULL if not provided

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, MatCreate(), MatConvert(), MatGetOrdering(), MATMPIADJ, MatMPIAdjSetPreallocation()

External Links

• PETSc Manual: Mat/MatCreateMPIAdj

mat::PetscMat = MatCreateMPIBAIJWithArrays(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar})

creates a MATMPIBAIJ matrix using arrays that contain in standard block CSR format for the local rows.

Collective

Input Parameters:

• comm - MPI communicator
• bs - the block size, only a block size of 1 is supported
• m - number of local rows (Cannot be PETSC_DECIDE)
• n - This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax . (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• i - row indices; that is i[0] = 0, i[row] = i[row-1] + number of block elements in that rowth block row of the matrix
• j - column indices
• a - matrix values

Output Parameter:

• mat - the matrix

Level: intermediate

-seealso: Mat, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatMPIAIJSetPreallocation(), MatMPIAIJSetPreallocationCSR(), MATMPIAIJ, MatCreateAIJ(), MatCreateMPIAIJWithSplitArrays()

External Links

• PETSc Manual: Mat/MatCreateMPIBAIJWithArrays

mpimat::PetscMat = MatCreateMPIMatConcatenateSeqMat(petsclib::PetscLibType,comm::MPI_Comm, seqmat::PetscMat, n::PetscInt, reuse::MatReuse)

Creates a single large PETSc matrix by concatenating sequential matrices from each processor

Collective

Input Parameters:

• comm - the communicators the parallel matrix will live on
• seqmat - the input sequential matrices
• n - number of local columns (or PETSC_DECIDE)
• reuse - either MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX

Output Parameter:

• mpimat - the parallel matrix generated

Level: developer

-seealso: , Mat

External Links

• PETSc Manual: Mat/MatCreateMPIMatConcatenateSeqMat

mat::PetscMat = MatCreateMPISBAIJWithArrays(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar})

creates a MATMPISBAIJ matrix using arrays that contain in standard CSR format for the local rows.

Collective

Input Parameters:

• comm - MPI communicator
• bs - the block size, only a block size of 1 is supported
• m - number of local rows (Cannot be PETSC_DECIDE)
• n - This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax . (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• i - row indices; that is i[0] = 0, i[row] = i[row-1] + number of block elements in that row block row of the matrix
• j - column indices
• a - matrix values

Output Parameter:

• mat - the matrix

Level: intermediate

-seealso: , Mat, MATMPISBAIJ, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatMPIAIJSetPreallocation(), MatMPIAIJSetPreallocationCSR(), MATMPIAIJ, MatCreateAIJ(), MatCreateMPIAIJWithSplitArrays(), MatMPISBAIJSetPreallocationCSR()

External Links

• PETSc Manual: Mat/MatCreateMPISBAIJWithArrays

B::PetscMat = MatCreateNest(petsclib::PetscLibType,comm::MPI_Comm, nr::PetscInt, is_row::Vector{IS}, nc::PetscInt, is_col::Vector{IS}, a::Vector{PetscMat})

Creates a new MATNEST matrix containing several nested submatrices, each stored separately

Collective

Input Parameters:

• comm - Communicator for the new MATNEST
• nr - number of nested row blocks
• is_row - index sets for each nested row block, or NULL to make contiguous
• nc - number of nested column blocks
• is_col - index sets for each nested column block, or NULL to make contiguous
• a - array of nr imes nc submatrices, empty submatrices can be passed using NULL

Output Parameter:

• B - new matrix

Level: advanced

-seealso: , Mat, MATNEST, MatCreate(), VecCreateNest(), DMCreateMatrix(), MatNestSetSubMat(), MatNestGetSubMat(), MatNestGetLocalISs(), MatNestGetSize(), MatNestGetISs(), MatNestSetSubMats(), MatNestGetSubMats()

External Links

• PETSc Manual: Mat/MatCreateNest

N::PetscMat = MatCreateNormal(petsclib::PetscLibType,A::PetscMat)

Creates a new MATNORMAL matrix object that behaves like A^T A.

Collective

Input Parameter:

• A - the (possibly rectangular) matrix

Output Parameter:

• N - the matrix that represents A^T A

Level: intermediate

-seealso: , Mat, MATNORMAL, MatMult(), MatNormalGetMat(), MATNORMALHERMITIAN, MatCreateNormalHermitian()

External Links

• PETSc Manual: Mat/MatCreateNormal

N::PetscMat = MatCreateNormalHermitian(petsclib::PetscLibType,A::PetscMat)

Creates a new matrix object MATNORMALHERMITIAN that behaves like A^* A.

Collective

Input Parameter:

• A - the (possibly rectangular complex) matrix

Output Parameter:

• N - the matrix that represents A^* A

Level: intermediate

-seealso: , Mat, MATNORMAL, MATNORMALHERMITIAN, MatNormalHermitianGetMat()

External Links

• PETSc Manual: Mat/MatCreateNormalHermitian

matredundant::PetscMat = MatCreateRedundantMatrix(petsclib::PetscLibType,mat::PetscMat, nsubcomm::PetscInt, subcomm::MPI_Comm, reuse::MatReuse)

Create redundant matrices and put them into processors of subcommunicators.

Collective

Input Parameters:

• mat - the matrix
• nsubcomm - the number of subcommunicators (= number of redundant parallel or sequential matrices)
• subcomm - MPI communicator split from the communicator where mat resides in (or MPI_COMM_NULL if nsubcomm is used)
• reuse - either MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX

Output Parameter:

• matredundant - redundant matrix

Level: advanced

-seealso: , Mat, MatDestroy(), PetscSubcommCreate(), PetscSubcomm

External Links

• PETSc Manual: Mat/MatCreateRedundantMatrix

A::PetscMat = MatCreateSBAIJ(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_nz::PetscInt, d_nnz::Vector{PetscInt}, o_nz::PetscInt, o_nnz::Vector{PetscInt})

Creates a sparse parallel matrix in symmetric block AIJ format, MATSBAIJ, (block compressed row). For good matrix assembly performance the user should preallocate the matrix storage by setting the parameters d_nz (or d_nnz) and o_nz (or o_nnz).

Collective

Input Parameters:

• comm - MPI communicator
• bs - size of block, the blocks are ALWAYS square. One can use MatSetBlockSizes() to set a different row and column blocksize but the row blocksize always defines the size of the blocks. The column blocksize sets the blocksize of the vectors obtained with MatCreateVecs()
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given) This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• n - number of local columns (or PETSC_DECIDE to have calculated if N is given) This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_nz - number of block nonzeros per block row in diagonal portion of local submatrix (same for all local rows)
• d_nnz - array containing the number of block nonzeros in the various block rows in the upper triangular portion of the in diagonal portion of the local (possibly different for each block block row) or NULL. If you plan to factor the matrix you must leave room for the diagonal entry and set its value even if it is zero.
• o_nz - number of block nonzeros per block row in the off-diagonal portion of local submatrix (same for all local rows).
• o_nnz - array containing the number of nonzeros in the various block rows of the off-diagonal portion of the local submatrix (possibly different for each block row) or NULL.

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_no_unroll - uses code that does not unroll the loops in the block calculations (much slower)
• -mat_block_size - size of the blocks to use
• -mat_mpi - use the parallel matrix data structures even on one processor (defaults to using SeqBAIJ format on one processor)

Level: intermediate

-seealso: , Mat, MATSBAIJ, MatCreate(), MatCreateSeqSBAIJ(), MatSetValues(), MatCreateBAIJ(), MatGetOwnershipRange(), MatGetOwnershipRanges(), MatGetOwnershipRangeColumn(), MatGetOwnershipRangesColumn(), PetscLayout

External Links

• PETSc Manual: Mat/MatCreateSBAIJ

A::PetscMat = MatCreateSELL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, d_rlenmax::PetscInt, d_rlen::Vector{PetscInt}, o_rlenmax::PetscInt, o_rlen::Vector{PetscInt})

Creates a sparse parallel matrix in MATSELL format.

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given). This value should be the same as the local size used in creating the y vector for the matrix-vector product y = Ax.
• n - This value should be the same as the local size used in creating the x vector for the matrix-vector product y = Ax. (or PETSC_DECIDE to have calculated if N is given) For square matrices n is almost always m.
• M - number of global rows (or PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (or PETSC_DETERMINE to have calculated if n is given)
• d_rlenmax - max number of nonzeros per row in DIAGONAL portion of local submatrix (same value is used for all local rows)
• d_rlen - array containing the number of nonzeros in the various rows of the DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if d_rlenmax is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m.
• o_rlenmax - max number of nonzeros per row in the OFF-DIAGONAL portion of local submatrix (same value is used for all local rows).
• o_rlen - array containing the number of nonzeros in the various rows of the OFF-DIAGONAL portion of the local submatrix (possibly different for each row) or NULL, if o_rlenmax is used to specify the nonzero structure. The size of this array is equal to the number of local rows, i.e m.

Output Parameter:

• A - the matrix

Options Database Key:

• -mat_sell_oneindex - Internally use indexing starting at 1

rather than 0. When calling MatSetValues(), the user still MUST index entries starting at 0!

Example: Consider the following 8x8 matrix with 34 non-zero values, that is assembled across 3 processors. Lets assume that proc0 owns 3 rows, proc1 owns 3 rows, proc2 owns 2 rows. This division can be shown as follows

-seealso: Mat, MATSELL, MatCreate(), MatCreateSeqSELL(), MatSetValues(), MatMPISELLSetPreallocation(), MATMPISELL

External Links

• PETSc Manual: Mat/MatCreateSELL

J::PetscMat = MatCreateSNESMF(petsclib::PetscLibType,snes::PetscSNES)

Creates a finite differencing based matrix a SNES solver. This matrix can be used as the Jacobian argument for the routine SNESSetJacobian(). See MatCreateMFFD() for details on how the finite difference computation is done.

Collective

Input Parameters:

• snes - the SNES context

Output Parameter:

• J - the matrix-free matrix which is of type MATMFFD

Level: advanced

-seealso: , SNES, MATMFFD, MatDestroy(), MatMFFDSetFunction(), MatMFFDSetFunctionError(), MatMFFDDSSetUmin() MatMFFDSetHHistory(), MatMFFDResetHHistory(), MatCreateMFFD(), MatCreateShell(), MatMFFDGetH(), MatMFFDRegister(), MatMFFDComputeJacobian(), MatSNESMFSetReuseBase(), MatSNESMFGetReuseBase()

External Links

• PETSc Manual: Snes/MatCreateSNESMF

J::PetscMat = MatCreateSNESMFMore(petsclib::PetscLibType,snes::PetscSNES, x::PetscVec)

Creates a matrix context for use with a SNES solver that uses the More method to compute an optimal h based on the noise of the function. This matrix can be used as the Jacobian argument for the routine SNESSetJacobian().

Input Parameters:

• snes - the SNES context
• x - vector where SNES solution is to be stored.

Output Parameter:

• J - the matrix-free matrix

Options Database Keys:

• -snes_mf_err <error_rel> - see MatCreateSNESMF()
• -snes_mf_umin <umin> - see MatCreateSNESMF()
• -snes_mf_compute_err - compute the square root or relative error in function
• -snes_mf_freq_err <freq> - set the frequency to recompute the parameters
• -snes_mf_jorge - use the method of Jorge More

Level: advanced

-seealso: , SNESCreateMF(), MatCreateMFFD(), MatDestroy(), MatMFFDSetFunctionError()

External Links

• PETSc Manual: Snes/MatCreateSNESMFMore

A::PetscMat = MatCreateScaLAPACK(petsclib::PetscLibType,comm::MPI_Comm, mb::PetscInt, nb::PetscInt, M::PetscInt, N::PetscInt, rsrc::PetscInt, csrc::PetscInt)

Creates a dense parallel matrix in ScaLAPACK format (2D block cyclic distribution) for a MATSCALAPACK matrix

Collective

Input Parameters:

• comm - MPI communicator
• mb - row block size (or PETSC_DECIDE to have it set)
• nb - column block size (or PETSC_DECIDE to have it set)
• M - number of global rows
• N - number of global columns
• rsrc - coordinate of process that owns the first row of the distributed matrix
• csrc - coordinate of process that owns the first column of the distributed matrix

Output Parameter:

• A - the matrix

Options Database Key:

• -mat_scalapack_block_sizes - size of the blocks to use (one or two integers separated by comma)

Level: intermediate

-seealso: , Mat, MATSCALAPACK, MATDENSE, MATELEMENTAL, MatCreate(), MatCreateDense(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateScaLAPACK

A::PetscMat = MatCreateScatter(petsclib::PetscLibType,comm::MPI_Comm, scatter::VecScatter)

Creates a new matrix of MatType MATSCATTER, based on a VecScatter

Collective

Input Parameters:

• comm - MPI communicator
• scatter - a VecScatter

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, MatScatterSetVecScatter(), MatScatterGetVecScatter(), MATSCATTER

External Links

• PETSc Manual: Mat/MatCreateScatter

S::PetscMat = MatCreateSchurComplement(petsclib::PetscLibType,A00::PetscMat, Ap00::PetscMat, A01::PetscMat, A10::PetscMat, A11::PetscMat)

Creates a new Mat that behaves like the Schur complement of a matrix

Collective

Input Parameters:

• A00 - the upper-left block of the original matrix A = [A00 A01; A10 A11]
• Ap00 - matrix from which the preconditioner is constructed for use in ksp(A00,Ap00) to approximate the action of A00^{-1}
• A01 - the upper-right block of the original matrix A = [A00 A01; A10 A11]
• A10 - the lower-left block of the original matrix A = [A00 A01; A10 A11]
• A11 - (optional) the lower-right block of the original matrix A = [A00 A01; A10 A11]

Output Parameter:

• S - the matrix that behaves as the Schur complement S = A11 - A10 ksp(A00,Ap00) A01

Level: intermediate

-seealso: , MatCreateNormal(), MatMult(), MatCreate(), MatSchurComplementGetKSP(), MatSchurComplementUpdateSubMatrices(), MatCreateTranspose(), MatGetSchurComplement(), MatSchurComplementGetPmat(), MatSchurComplementSetSubMatrices()

External Links

• PETSc Manual: Ksp/MatCreateSchurComplement

Sp::PetscMat = MatCreateSchurComplementPmat(petsclib::PetscLibType,A00::PetscMat, A01::PetscMat, A10::PetscMat, A11::PetscMat, ainvtype::MatSchurComplementAinvType, preuse::MatReuse)

create a matrix for preconditioning the Schur complement by explicitly assembling the sparse matrix Sp = A11 - A10 inv(DIAGFORM(A00)) A01

Collective

Input Parameters:

• A00 - the upper-left part of the original matrix A = [A00 A01; A10 A11]
• A01 - (optional) the upper-right part of the original matrix A = [A00 A01; A10 A11]
• A10 - (optional) the lower-left part of the original matrix A = [A00 A01; A10 A11]
• A11 - (optional) the lower-right part of the original matrix A = [A00 A01; A10 A11]
• ainvtype - type of approximation for DIAGFORM(A00) used when forming Sp = A11 - A10 inv(DIAGFORM(A00)) A01. See MatSchurComplementAinvType.
• preuse - MAT_INITIAL_MATRIX for a new Sp, or MAT_REUSE_MATRIX to reuse an existing Sp, or MAT_IGNORE_MATRIX to put nothing in Sp

Output Parameter:

• Sp - approximate Schur complement suitable for constructing a preconditioner for the true Schur complement S = A11 - A10 inv(A00) A01

Level: advanced

-seealso: , MatCreateSchurComplement(), MatGetSchurComplement(), MatSchurComplementGetPmat(), MatSchurComplementAinvType

External Links

• PETSc Manual: Ksp/MatCreateSchurComplementPmat

A::PetscMat = MatCreateSeqAIJ(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse matrix in MATSEQAIJ (compressed row) format (the default parallel PETSc format). For good matrix assembly performance the user should preallocate the matrix storage by setting the parameter nz (or the array nnz).

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• nz - number of nonzeros per row (same for all rows)
• nnz - array containing the number of nonzeros in the various rows

(possibly different for each row) or NULL

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_no_inode - Do not use inodes
• -mat_inode_limit <limit> - Sets inode limit (max limit=5)

Level: intermediate

-seealso: , Mat, Sparse Matrix Creation, MatCreate(), MatCreateAIJ(), MatSetValues(), MatSeqAIJSetColumnIndices(), MatCreateSeqAIJWithArrays()

External Links

• PETSc Manual: Mat/MatCreateSeqAIJ

A::PetscMat = MatCreateSeqAIJCRL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse matrix of type MATSEQAIJCRL.

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• nz - number of nonzeros per row (same for all rows), ignored if nnz is given
• nnz - array containing the number of nonzeros in the various rows

(possibly different for each row) or NULL

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateMPIAIJPERM(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateSeqAIJCRL

mat::PetscMat = MatCreateSeqAIJFromTriple(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar}, nz::PetscCount, idx::PetscBool)

Creates an sequential MATSEQAIJ matrix using matrix elements (in COO format) provided by the user.

Collective

Input Parameters:

• comm - must be an MPI communicator of size 1
• m - number of rows
• n - number of columns
• i - row indices
• j - column indices
• a - matrix values
• nz - number of nonzeros
• idx - if the i and j indices start with 1 use PETSC_TRUE otherwise use PETSC_FALSE

Output Parameter:

• mat - the matrix

Level: intermediate

Example: For the following matrix, the input data expected is as shown (using 0 based indexing) -seealso: , Mat, MatCreate(), MatCreateAIJ(), MatCreateSeqAIJ(), MatCreateSeqAIJWithArrays(), MatMPIAIJSetPreallocationCSR(), MatSetValuesCOO(), MatSetPreallocationCOO()

External Links

• PETSc Manual: Mat/MatCreateSeqAIJFromTriple

A::PetscMat = MatCreateSeqAIJKokkos(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

External Links

• PETSc Manual: Mat/MatCreateSeqAIJKokkos

A::PetscMat = MatCreateSeqAIJMKL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse matrix of type MATSEQAIJMKL.

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• nz - number of nonzeros per row (same for all rows)
• nnz - array containing the number of nonzeros in the various rows

(possibly different for each row) or NULL

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_aijmkl_no_spmv2 - disable use of the SpMV2 inspector-executor routines
• -mat_aijmkl_eager_inspection - perform MKL "inspection" phase upon matrix assembly; default is to do "lazy" inspection,

performing this step the first time the matrix is applied

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateMPIAIJMKL(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateSeqAIJMKL

A::PetscMat = MatCreateSeqAIJPERM(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse matrix of type MATSEQAIJPERM.

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• nz - number of nonzeros per row (same for all rows), ignored if nnz is given
• nnz - array containing the number of nonzeros in the various rows (possibly different for each row) or NULL

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateMPIAIJPERM(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateSeqAIJPERM

A::PetscMat = MatCreateSeqAIJSELL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse matrix of type MATSEQAIJSELL.

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• nz - number of nonzeros per row (same for all rows)
• nnz - array containing the number of nonzeros in the various rows

(possibly different for each row) or NULL

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_aijsell_eager_shadow - Construct shadow matrix upon matrix assembly; default is to take a "lazy" approach,

performing this step the first time the matrix is applied

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateMPIAIJSELL(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateSeqAIJSELL

A::PetscMat = MatCreateSeqAIJViennaCL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

External Links

• PETSc Manual: Mat/MatCreateSeqAIJViennaCL

mat::PetscMat = MatCreateSeqAIJWithArrays(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar})

Creates an sequential MATSEQAIJ matrix using matrix elements (in CSR format) provided by the user.

Collective

Input Parameters:

• comm - must be an MPI communicator of size 1
• m - number of rows
• n - number of columns
• i - row indices; that is i[0] = 0, i[row] = i[row-1] + number of elements in that row of the matrix
• j - column indices
• a - matrix values

Output Parameter:

• mat - the matrix

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateAIJ(), MatCreateSeqAIJ(), MatCreateMPIAIJWithArrays(), MatMPIAIJSetPreallocationCSR()

External Links

• PETSc Manual: Mat/MatCreateSeqAIJWithArrays

A::PetscMat = MatCreateSeqBAIJ(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse matrix in MATSEQAIJ (block compressed row) format. For good matrix assembly performance the user should preallocate the matrix storage by setting the parameter nz (or the array nnz).

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• bs - size of block, the blocks are ALWAYS square. One can use MatSetBlockSizes() to set a different row and column blocksize but the row

blocksize always defines the size of the blocks. The column blocksize sets the blocksize of the vectors obtained with MatCreateVecs()

• m - number of rows
• n - number of columns
• nz - number of nonzero blocks per block row (same for all rows)
• nnz - array containing the number of nonzero blocks in the various block rows

(possibly different for each block row) or NULL

Output Parameter:

• A - the matrix

Options Database Keys:

• -mat_no_unroll - uses code that does not unroll the loops in the block calculations (much slower)
• -mat_block_size - size of the blocks to use

Level: intermediate

-seealso: , Mat, Sparse Matrices, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatCreateBAIJ()

External Links

• PETSc Manual: Mat/MatCreateSeqBAIJ

A::PetscMat = MatCreateSeqBAIJMKL(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse matrix of type MATSEQBAIJMKL. This type inherits from MATSEQBAIJ and is largely identical, but uses sparse BLAS routines from Intel MKL whenever possible.

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• bs - size of block, the blocks are ALWAYS square. One can use MatSetBlockSizes() to set a different row and column blocksize but the row blocksize always defines the size of the blocks. The column blocksize sets the blocksize of the vectors obtained with MatCreateVecs()
• m - number of rows
• n - number of columns
• nz - number of nonzero blocks per block row (same for all rows)
• nnz - array containing the number of nonzero blocks in the various block rows (possibly different for each block row) or NULL

Output Parameter:

• A - the matrix

It is recommended that one use the MatCreate(), MatSetType() and/or MatSetFromOptions(), MatXXXXSetPreallocation() paradigm instead of this routine directly. [MatXXXXSetPreallocation() is, for example, MatSeqBAIJSetPreallocation()]

Options Database Keys:

• -mat_no_unroll - uses code that does not unroll the loops in the block calculations (much slower)
• -mat_block_size - size of the blocks to use

Level: intermediate

-seealso: Sparse Matrices, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatCreateBAIJ()

External Links

• PETSc Manual: Mat/MatCreateSeqBAIJMKL

mat::PetscMat = MatCreateSeqBAIJWithArrays(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar})

Creates a MATSEQBAIJ matrix using matrix elements provided by the user.

Collective

Input Parameters:

• comm - must be an MPI communicator of size 1
• bs - size of block
• m - number of rows
• n - number of columns
• i - row indices; that is i[0] = 0, i[row] = i[row-1] + number of elements in that row block row of the matrix
• j - column indices
• a - matrix values

Output Parameter:

• mat - the matrix

Level: advanced

-seealso: , Mat, MatCreate(), MatCreateBAIJ(), MatCreateSeqBAIJ()

External Links

• PETSc Manual: Mat/MatCreateSeqBAIJWithArrays

A::PetscMat = MatCreateSeqDense(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, data::Vector{PetscScalar})

Creates a MATSEQDENSE that is stored in column major order (the usual Fortran format).

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• data - optional location of matrix data in column major order. Use NULL for PETSc to control all matrix memory allocation.

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: , Mat, MATSEQDENSE, MatCreate(), MatCreateDense(), MatSetValues()

External Links

• PETSc Manual: Mat/MatCreateSeqDense

A::PetscMat = MatCreateSeqSBAIJ(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, nz::PetscInt, nnz::Vector{PetscInt})

Creates a sparse symmetric matrix in (block compressed row) MATSEQSBAIJ format. For good matrix assembly performance the user should preallocate the matrix storage by setting the parameter nz (or the array nnz).

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• bs - size of block, the blocks are ALWAYS square. One can use MatSetBlockSizes() to set a different row and column blocksize but the row blocksize always defines the size of the blocks. The column blocksize sets the blocksize of the vectors obtained with MatCreateVecs()
• m - number of rows
• n - number of columns
• nz - number of block nonzeros per block row (same for all rows)
• nnz - array containing the number of block nonzeros in the upper triangular plus diagonal portion of each block (possibly different for each block row) or NULL

Output Parameter:

• A - the symmetric matrix

Options Database Keys:

• -mat_no_unroll - uses code that does not unroll the loops in the block calculations (much slower)
• -mat_block_size - size of the blocks to use

Level: intermediate

-seealso: , Mat, Sparse Matrices, MATSEQSBAIJ, MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatCreateSBAIJ()

External Links

• PETSc Manual: Mat/MatCreateSeqSBAIJ

mat::PetscMat = MatCreateSeqSBAIJWithArrays(petsclib::PetscLibType,comm::MPI_Comm, bs::PetscInt, m::PetscInt, n::PetscInt, i::Vector{PetscInt}, j::Vector{PetscInt}, a::Vector{PetscScalar})

Creates an sequential MATSEQSBAIJ matrix using matrix elements (upper triangular entries in CSR format) provided by the user.

Collective

Input Parameters:

• comm - must be an MPI communicator of size 1
• bs - size of block
• m - number of rows
• n - number of columns
• i - row indices; that is i[0] = 0, i[row] = i[row-1] + number of block elements in that row block row of the matrix
• j - column indices
• a - matrix values

Output Parameter:

• mat - the matrix

Level: advanced

-seealso: , Mat, MATSEQSBAIJ, MatCreate(), MatCreateSBAIJ(), MatCreateSeqSBAIJ()

External Links

• PETSc Manual: Mat/MatCreateSeqSBAIJWithArrays

A::PetscMat = MatCreateSeqSELL(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, rlenmax::PetscInt, rlen::Union{Ptr,Vector{PetscInt}})

Creates a sparse matrix in MATSEQSELL format.

Collective

Input Parameters:

• comm - MPI communicator, set to PETSC_COMM_SELF
• m - number of rows
• n - number of columns
• rlenmax - maximum number of nonzeros in a row, ignored if rlen is provided
• rlen - array containing the number of nonzeros in the various rows (possibly different for each row) or NULL

Output Parameter:

• A - the matrix

Level: intermediate

-seealso: Mat, MATSEQSELL, MatCreate(), MatCreateSELL(), MatSetValues(), MatSeqSELLSetPreallocation(), MATSELL, MATMPISELL

External Links

• PETSc Manual: Mat/MatCreateSeqSELL

A::PetscMat = MatCreateShell(petsclib::PetscLibType,comm::MPI_Comm, m::PetscInt, n::PetscInt, M::PetscInt, N::PetscInt, ctx::Ptr)

Creates a new matrix of MatType MATSHELL for use with a user private matrix data storage format.

Collective

Input Parameters:

• comm - MPI communicator
• m - number of local rows (or PETSC_DECIDE to have calculated if M is given)
• n - number of local columns (or PETSC_DECIDE to have calculated if N is given)
• M - number of global rows (may be PETSC_DETERMINE to have calculated if m is given)
• N - number of global columns (may be PETSC_DETERMINE to have calculated if n is given)
• ctx - pointer to data needed by the shell matrix routines

Output Parameter:

• A - the matrix

Level: advanced

-seealso: , Mat, MATSHELL, MatShellSetOperation(), MatHasOperation(), MatShellGetContext(), MatShellSetContext(), MatShellSetManageScalingShifts(), MatShellSetMatProductOperation()

External Links

• PETSc Manual: Mat/MatCreateShell

submat::Vector{PetscMat} = MatCreateSubMatrices(petsclib::PetscLibType,mat::PetscMat, n::PetscInt, irow::Vector{IS}, icol::Vector{IS}, scall::MatReuse)

Extracts several submatrices from a matrix. If submat points to an array of valid matrices, they may be reused to store the new submatrices.

Collective

Input Parameters:

• mat - the matrix
• n - the number of submatrixes to be extracted (on this processor, may be zero)
• irow - index set of rows to extract
• icol - index set of columns to extract
• scall - either MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX

Output Parameter:

• submat - the array of submatrices

Level: advanced

-seealso: , Mat, MatDestroySubMatrices(), MatCreateSubMatrix(), MatGetRow(), MatGetDiagonal(), MatReuse

External Links

• PETSc Manual: Mat/MatCreateSubMatrices

submat::Vector{PetscMat} = MatCreateSubMatricesMPI(petsclib::PetscLibType,mat::PetscMat, n::PetscInt, irow::Vector{IS}, icol::Vector{IS}, scall::MatReuse)

Extracts MPI submatrices across a sub communicator of mat (by pairs of IS that may live on subcomms).

Collective

Input Parameters:

• mat - the matrix
• n - the number of submatrixes to be extracted
• irow - index set of rows to extract
• icol - index set of columns to extract
• scall - either MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX

Output Parameter:

• submat - the array of submatrices

Level: advanced

-seealso: , Mat, PCGASM, MatCreateSubMatrices(), MatCreateSubMatrix(), MatGetRow(), MatGetDiagonal(), MatReuse

External Links

• PETSc Manual: Mat/MatCreateSubMatricesMPI

newmat::PetscMat = MatCreateSubMatrix(petsclib::PetscLibType,mat::PetscMat, isrow::IS, iscol::IS, cll::MatReuse)

Gets a single submatrix on the same number of processors as the original matrix.

Collective

Input Parameters:

• mat - the original matrix
• isrow - parallel IS containing the rows this processor should obtain
• iscol - parallel IS containing all columns you wish to keep. Each process should list the columns that will be in IT's "diagonal part" in the new matrix.
• cll - either MAT_INITIAL_MATRIX or MAT_REUSE_MATRIX

Output Parameter:

• newmat - the new submatrix, of the same type as the original matrix

Level: advanced

-seealso: , Mat, MatCreateSubMatrices(), MatCreateSubMatricesMPI(), MatCreateSubMatrixVirtual(), MatSubMatrixVirtualUpdate()

External Links

• PETSc Manual: Mat/MatCreateSubMatrix

J::PetscMat = MatCreateSubMatrixFree(petsclib::PetscLibType,mat::PetscMat, Rows::IS, Cols::IS)

Creates a reduced matrix by masking a full matrix.

Collective

Input Parameters:

• mat - matrix of arbitrary type
• Rows - the rows that will be in the submatrix
• Cols - the columns that will be in the submatrix

Output Parameter:

• J - New matrix

Level: developer

-seealso: MatCreate()

External Links

• PETSc Manual: Tao/MatCreateSubMatrixFree

newmat::PetscMat = MatCreateSubMatrixVirtual(petsclib::PetscLibType,A::PetscMat, isrow::IS, iscol::IS)

Creates a virtual matrix MATSUBMATRIX that acts as a submatrix

Collective

Input Parameters:

• A - matrix that we will extract a submatrix of
• isrow - rows to be present in the submatrix
• iscol - columns to be present in the submatrix

Output Parameter:

• newmat - new matrix

Level: developer

-seealso: , Mat, MATSUBMATRIX, MATLOCALREF, MatCreateLocalRef(), MatCreateSubMatrix(), MatSubMatrixVirtualUpdate()

External Links

• PETSc Manual: Mat/MatCreateSubMatrixVirtual

N::PetscMat = MatCreateTranspose(petsclib::PetscLibType,A::PetscMat)

Creates a new matrix MATTRANSPOSEVIRTUAL object that behaves like A'

Collective

Input Parameter:

• A - the (possibly rectangular) matrix

Output Parameter:

• N - the matrix that represents A'

Level: intermediate

-seealso: , Mat, MATTRANSPOSEVIRTUAL, MatCreateNormal(), MatMult(), MatMultTranspose(), MatCreate(), MATNORMALHERMITIAN

External Links

• PETSc Manual: Mat/MatCreateTranspose

right::PetscVec,left::PetscVec = MatCreateVecs(petsclib::PetscLibType,mat::PetscMat)

Get vector(s) compatible with the matrix, i.e. with the same parallel layout, PetscLayout for rows and columns

Collective

Input Parameter:

• mat - the matrix

Output Parameters:

• right - (optional) vector that the matrix can be multiplied against
• left - (optional) vector that the matrix vector product can be stored in

Level: advanced

-seealso: , Mat, Vec, VecCreate(), VecDestroy(), DMCreateGlobalVector()

External Links

• PETSc Manual: Mat/MatCreateVecs

x::PetscVec,y::PetscVec,z::PetscVec = MatCreateVecsFFTW(petsclib::PetscLibType,A::PetscMat)

Get vector(s) compatible with the matrix, i.e. with the parallel layout determined by MATFFTW

Collective

Input Parameter:

• A - the matrix

Output Parameters:

• x - (optional) input vector of forward FFTW
• y - (optional) output vector of forward FFTW
• z - (optional) output vector of backward FFTW

Options Database Key:

• -mat_fftw_plannerflags - set FFTW planner flags

Level: advanced

-seealso: , Mat, MATFFTW, MatCreateFFT(), MatCreateVecs()

External Links

• PETSc Manual: Mat/MatCreateVecsFFTW

MatDFischer(petsclib::PetscLibType,jac::PetscMat, X::PetscVec, Con::PetscVec, XL::PetscVec, XU::PetscVec, T1::PetscVec, T2::PetscVec, Da::PetscVec, Db::PetscVec)

Calculates an element of the B Fischer-Burmeister function for complementarity problems.

Collective

Input Parameters:

• jac - the jacobian of f at X
• X - current point
• Con - constraints function evaluated at X
• XL - lower bounds
• XU - upper bounds
• T1 - work vector
• T2 - work vector

Output Parameters:

• Da - diagonal perturbation component of the result
• Db - row scaling component of the result

Level: developer

-seealso: Mat, VecFischer(), VecSFischer(), MatDSFischer()

External Links

• PETSc Manual: Tao/MatDFischer

MatDSFischer(petsclib::PetscLibType,jac::PetscMat, X::PetscVec, Con::PetscVec, XL::PetscVec, XU::PetscVec, mu::PetscReal, T1::PetscVec, T2::PetscVec, Da::PetscVec, Db::PetscVec, Dm::PetscVec)

Calculates an element of the B smoothed Fischer-Burmeister function for complementarity problems.

Collective

Input Parameters:

• jac - the jacobian of f at X
• X - current point
• Con - constraint function evaluated at X
• XL - lower bounds
• XU - upper bounds
• mu - smoothing parameter
• T1 - work vector
• T2 - work vector

Output Parameters:

• Da - diagonal perturbation component of the result
• Db - row scaling component of the result
• Dm - derivative with respect to scaling parameter

Level: developer

-seealso: Mat, VecFischer(), VecDFischer(), MatDFischer()

External Links

• PETSc Manual: Tao/MatDSFischer

array::Vector{PetscScalar} = MatDenseGetArray(petsclib::PetscLibType,A::PetscMat)

gives read

Logically Collective

Input Parameter:

• A - a dense matrix

Output Parameter:

• array - pointer to the data

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseRestoreArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite()

External Links

• PETSc Manual: Mat/MatDenseGetArray

array::Vector{PetscScalar},mtype::PetscMemType = MatDenseGetArrayAndMemType(petsclib::PetscLibType,A::PetscMat)

gives read

Logically Collective

Input Parameter:

• A - a dense matrix

Output Parameters:

• array - pointer to the data
• mtype - memory type of the returned pointer

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseRestoreArrayAndMemType(), MatDenseGetArrayReadAndMemType(), MatDenseGetArrayWriteAndMemType(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite(), MatSeqAIJGetCSRAndMemType()

External Links

• PETSc Manual: Mat/MatDenseGetArrayAndMemType

array::Vector{PetscScalar} = MatDenseGetArrayRead(petsclib::PetscLibType,A::PetscMat)

gives read

Not Collective

Input Parameter:

• A - a dense matrix

Output Parameter:

• array - pointer to the data

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseRestoreArrayRead(), MatDenseGetArray(), MatDenseRestoreArray(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite()

External Links

• PETSc Manual: Mat/MatDenseGetArrayRead

array::Vector{PetscScalar},mtype::PetscMemType = MatDenseGetArrayReadAndMemType(petsclib::PetscLibType,A::PetscMat)

gives read

Logically Collective

Input Parameter:

• A - a dense matrix

Output Parameters:

• array - pointer to the data
• mtype - memory type of the returned pointer

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseRestoreArrayReadAndMemType(), MatDenseGetArrayWriteAndMemType(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite(), MatSeqAIJGetCSRAndMemType()

External Links

• PETSc Manual: Mat/MatDenseGetArrayReadAndMemType

array::Vector{PetscScalar} = MatDenseGetArrayWrite(petsclib::PetscLibType,A::PetscMat)

gives write

Not Collective

Input Parameter:

• A - a dense matrix

Output Parameter:

• array - pointer to the data

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseRestoreArrayWrite(), MatDenseGetArray(), MatDenseRestoreArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead()

External Links

• PETSc Manual: Mat/MatDenseGetArrayWrite

array::Vector{PetscScalar},mtype::PetscMemType = MatDenseGetArrayWriteAndMemType(petsclib::PetscLibType,A::PetscMat)

gives write

Logically Collective

Input Parameter:

• A - a dense matrix

Output Parameters:

• array - pointer to the data
• mtype - memory type of the returned pointer

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseRestoreArrayWriteAndMemType(), MatDenseGetArrayReadAndMemType(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite(), MatSeqAIJGetCSRAndMemType()

External Links

• PETSc Manual: Mat/MatDenseGetArrayWriteAndMemType

vals::Vector{PetscScalar} = MatDenseGetColumn(petsclib::PetscLibType,A::PetscMat, col::PetscInt)

gives access to a column of a dense matrix. This is only the local part of the column. You MUST call MatDenseRestoreColumn() to avoid memory bleeding.

Not Collective

Input Parameters:

• A - a MATSEQDENSE or MATMPIDENSE matrix
• col - column index

Output Parameter:

• vals - pointer to the data

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseRestoreColumn(), MatDenseGetColumnVec()

External Links

• PETSc Manual: Mat/MatDenseGetColumn

MatDenseGetColumnVec(petsclib::PetscLibType,A::PetscMat, col::PetscInt, v::PetscVec)

Gives read

Collective

Input Parameters:

• A - the Mat object
• col - the column index

Output Parameter:

• v - the vector

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVecRead(), MatDenseGetColumnVecWrite(), MatDenseRestoreColumnVec(), MatDenseRestoreColumnVecRead(), MatDenseRestoreColumnVecWrite(), MatDenseGetColumn()

External Links

• PETSc Manual: Mat/MatDenseGetColumnVec

MatDenseGetColumnVecRead(petsclib::PetscLibType,A::PetscMat, col::PetscInt, v::PetscVec)

Gives read

Collective

Input Parameters:

• A - the Mat object
• col - the column index

Output Parameter:

• v - the vector

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVec(), MatDenseGetColumnVecWrite(), MatDenseRestoreColumnVec(), MatDenseRestoreColumnVecRead(), MatDenseRestoreColumnVecWrite()

External Links

• PETSc Manual: Mat/MatDenseGetColumnVecRead

MatDenseGetColumnVecWrite(petsclib::PetscLibType,A::PetscMat, col::PetscInt, v::PetscVec)

Gives write

Collective

Input Parameters:

• A - the Mat object
• col - the column index

Output Parameter:

• v - the vector

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVec(), MatDenseGetColumnVecRead(), MatDenseRestoreColumnVec(), MatDenseRestoreColumnVecRead(), MatDenseRestoreColumnVecWrite()

External Links

• PETSc Manual: Mat/MatDenseGetColumnVecWrite

lda::PetscInt = MatDenseGetLDA(petsclib::PetscLibType,A::PetscMat)

gets the leading dimension of the array returned from MatDenseGetArray()

Not Collective

Input Parameter:

• A - a MATDENSE or MATDENSECUDA matrix

Output Parameter:

• lda - the leading dimension

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MatDenseGetArray(), MatDenseRestoreArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseSetLDA()

External Links

• PETSc Manual: Mat/MatDenseGetLDA

MatDenseGetLocalMatrix(petsclib::PetscLibType,A::PetscMat, B::PetscMat)

For a MATMPIDENSE or MATSEQDENSE matrix returns the sequential matrix that represents the operator. For sequential matrices it returns itself.

Input Parameter:

• A - the sequential or MPI MATDENSE matrix

Output Parameter:

• B - the inner matrix

Level: intermediate

-seealso: , Mat, MATDENSE, MATMPIDENSE, MATSEQDENSE

External Links

• PETSc Manual: Mat/MatDenseGetLocalMatrix

MatDenseGetSubMatrix(petsclib::PetscLibType,A::PetscMat, rbegin::PetscInt, rend::PetscInt, cbegin::PetscInt, cend::PetscInt, v::PetscMat)

Gives access to a block of rows and columns of a dense matrix, represented as a Mat.

Collective

Input Parameters:

• A - the Mat object
• rbegin - the first global row index in the block (if PETSC_DECIDE, is 0)
• rend - the global row index past the last one in the block (if PETSC_DECIDE, is M)
• cbegin - the first global column index in the block (if PETSC_DECIDE, is 0)
• cend - the global column index past the last one in the block (if PETSC_DECIDE, is N)

Output Parameter:

• v - the matrix

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVec(), MatDenseRestoreColumnVec(), MatDenseRestoreSubMatrix()

External Links

• PETSc Manual: Mat/MatDenseGetSubMatrix

array::PetscScalar = MatDensePlaceArray(petsclib::PetscLibType,mat::PetscMat)

Allows one to replace the array in a MATDENSE matrix with an array provided by the user. This is useful to avoid copying an array into a matrix

Not Collective

Input Parameters:

• mat - the matrix
• array - the array in column major order

Level: developer

-seealso: , Mat, MATDENSE, MatDenseGetArray(), MatDenseResetArray(), VecPlaceArray(), VecGetArray(), VecRestoreArray(), VecReplaceArray(), VecResetArray(), MatDenseReplaceArray()

External Links

• PETSc Manual: Mat/MatDensePlaceArray

array::PetscScalar = MatDenseReplaceArray(petsclib::PetscLibType,mat::PetscMat)

Allows one to replace the array in a dense matrix with an array provided by the user. This is useful to avoid copying an array into a matrix

Not Collective

Input Parameters:

• mat - the matrix
• array - the array in column major order

Level: developer

-seealso: , Mat, MatDensePlaceArray(), MatDenseGetArray(), VecReplaceArray()

External Links

• PETSc Manual: Mat/MatDenseReplaceArray

MatDenseResetArray(petsclib::PetscLibType,mat::PetscMat)

Resets the matrix array to that it previously had before the call to MatDensePlaceArray()

Not Collective

Input Parameter:

• mat - the matrix

Level: developer

-seealso: , Mat, MATDENSE, MatDenseGetArray(), MatDensePlaceArray(), VecPlaceArray(), VecGetArray(), VecRestoreArray(), VecReplaceArray(), VecResetArray()

External Links

• PETSc Manual: Mat/MatDenseResetArray

array::Vector{PetscScalar} = MatDenseRestoreArray(petsclib::PetscLibType,A::PetscMat)

returns access to the array where the data for a MATDENSE matrix is stored obtained by MatDenseGetArray()

Logically Collective

Input Parameters:

• A - a dense matrix
• array - pointer to the data (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseGetArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite()

External Links

• PETSc Manual: Mat/MatDenseRestoreArray

array::Vector{PetscScalar} = MatDenseRestoreArrayAndMemType(petsclib::PetscLibType,A::PetscMat)

returns access to the array that is obtained by MatDenseGetArrayAndMemType()

Logically Collective

Input Parameters:

• A - a dense matrix
• array - pointer to the data

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseGetArrayAndMemType(), MatDenseGetArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite()

External Links

• PETSc Manual: Mat/MatDenseRestoreArrayAndMemType

array::Vector{PetscScalar} = MatDenseRestoreArrayRead(petsclib::PetscLibType,A::PetscMat)

returns access to the array where the data for a MATDENSE matrix is stored obtained by MatDenseGetArrayRead()

Not Collective

Input Parameters:

• A - a dense matrix
• array - pointer to the data (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseGetArrayRead(), MatDenseGetArray(), MatDenseRestoreArray(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite()

External Links

• PETSc Manual: Mat/MatDenseRestoreArrayRead

array::Vector{PetscScalar} = MatDenseRestoreArrayReadAndMemType(petsclib::PetscLibType,A::PetscMat)

returns access to the array that is obtained by MatDenseGetArrayReadAndMemType()

Logically Collective

Input Parameters:

• A - a dense matrix
• array - pointer to the data

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseGetArrayReadAndMemType(), MatDenseGetArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite()

External Links

• PETSc Manual: Mat/MatDenseRestoreArrayReadAndMemType

array::Vector{PetscScalar} = MatDenseRestoreArrayWrite(petsclib::PetscLibType,A::PetscMat)

returns access to the array where the data for a MATDENSE matrix is stored obtained by MatDenseGetArrayWrite()

Not Collective

Input Parameters:

• A - a dense matrix
• array - pointer to the data (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseGetArrayWrite(), MatDenseGetArray(), MatDenseRestoreArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead()

External Links

• PETSc Manual: Mat/MatDenseRestoreArrayWrite

array::Vector{PetscScalar} = MatDenseRestoreArrayWriteAndMemType(petsclib::PetscLibType,A::PetscMat)

returns access to the array that is obtained by MatDenseGetArrayReadAndMemType()

Logically Collective

Input Parameters:

• A - a dense matrix
• array - pointer to the data

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseGetArrayWriteAndMemType(), MatDenseGetArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetArrayWrite(), MatDenseRestoreArrayWrite()

External Links

• PETSc Manual: Mat/MatDenseRestoreArrayWriteAndMemType

vals::Vector{PetscScalar} = MatDenseRestoreColumn(petsclib::PetscLibType,A::PetscMat)

returns access to a column of a MATDENSE matrix which is returned by MatDenseGetColumn().

Not Collective

Input Parameters:

• A - a MATSEQDENSE or MATMPIDENSE matrix
• vals - pointer to the data (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MatDenseGetColumn()

External Links

• PETSc Manual: Mat/MatDenseRestoreColumn

MatDenseRestoreColumnVec(petsclib::PetscLibType,A::PetscMat, col::PetscInt, v::PetscVec)

Returns access to a column of a dense matrix obtained from MatDenseGetColumnVec().

Collective

Input Parameters:

• A - the Mat object
• col - the column index
• v - the Vec object (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVec(), MatDenseGetColumnVecRead(), MatDenseGetColumnVecWrite(), MatDenseRestoreColumnVecRead(), MatDenseRestoreColumnVecWrite()

External Links

• PETSc Manual: Mat/MatDenseRestoreColumnVec

MatDenseRestoreColumnVecRead(petsclib::PetscLibType,A::PetscMat, col::PetscInt, v::PetscVec)

Returns access to a column of a dense matrix obtained from MatDenseGetColumnVecRead().

Collective

Input Parameters:

• A - the Mat object
• col - the column index
• v - the Vec object (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVec(), MatDenseGetColumnVecRead(), MatDenseGetColumnVecWrite(), MatDenseRestoreColumnVec(), MatDenseRestoreColumnVecWrite()

External Links

• PETSc Manual: Mat/MatDenseRestoreColumnVecRead

MatDenseRestoreColumnVecWrite(petsclib::PetscLibType,A::PetscMat, col::PetscInt, v::PetscVec)

Returns access to a column of a dense matrix obtained from MatDenseGetColumnVecWrite().

Collective

Input Parameters:

• A - the Mat object
• col - the column index
• v - the Vec object (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVec(), MatDenseGetColumnVecRead(), MatDenseGetColumnVecWrite(), MatDenseRestoreColumnVec(), MatDenseRestoreColumnVecRead()

External Links

• PETSc Manual: Mat/MatDenseRestoreColumnVecWrite

MatDenseRestoreSubMatrix(petsclib::PetscLibType,A::PetscMat, v::PetscMat)

Returns access to a block of columns of a dense matrix obtained from MatDenseGetSubMatrix().

Collective

Input Parameters:

• A - the Mat object
• v - the Mat object (may be NULL)

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MATDENSEHIP, MatDenseGetColumnVec(), MatDenseRestoreColumnVec(), MatDenseGetSubMatrix()

External Links

• PETSc Manual: Mat/MatDenseRestoreSubMatrix

MatDenseSetLDA(petsclib::PetscLibType,A::PetscMat, lda::PetscInt)

Sets the leading dimension of the array used by the MATDENSE matrix

Collective if the matrix layouts have not yet been setup

Input Parameters:

• A - a MATDENSE or MATDENSECUDA matrix
• lda - the leading dimension

Level: intermediate

-seealso: , Mat, MATDENSE, MATDENSECUDA, MatDenseGetArray(), MatDenseRestoreArray(), MatDenseGetArrayRead(), MatDenseRestoreArrayRead(), MatDenseGetLDA()

External Links

• PETSc Manual: Mat/MatDenseSetLDA

MatDestroy(petsclib::PetscLibType,A::AbstractPetscMat)

Frees space taken by a matrix.

Collective

Input Parameter:

• A - the matrix

Level: beginner

-seealso: , Mat, MatCreate()

External Links

• PETSc Manual: Mat/MatDestroy

MatDestroyMatrices(petsclib::PetscLibType,n::PetscInt, mat::Vector{PetscMat})

Destroys an array of matrices

Collective

Input Parameters:

• n - the number of local matrices
• mat - the matrices (this is a pointer to the array of matrices)

Level: advanced

-seealso: , Mat, MatCreateSubMatrices(), MatDestroySubMatrices()

External Links

• PETSc Manual: Mat/MatDestroyMatrices

MatDestroySeqNonzeroStructure(petsclib::PetscLibType,mat::PetscMat)

Destroys matrix obtained with MatGetSeqNonzeroStructure().

Collective

Input Parameter:

• mat - the matrix

Level: advanced

-seealso: , Mat, MatGetSeqNonzeroStructure()

External Links

• PETSc Manual: Mat/MatDestroySeqNonzeroStructure

MatDestroySubMatrices(petsclib::PetscLibType,n::PetscInt, mat::Vector{PetscMat})

Destroys a set of matrices obtained with MatCreateSubMatrices().

Collective

Input Parameters:

• n - the number of local matrices
• mat - the matrices (this is a pointer to the array of matrices, to match the calling sequence of MatCreateSubMatrices())

Level: advanced

-seealso: , Mat, MatCreateSubMatrices(), MatDestroyMatrices()

External Links

• PETSc Manual: Mat/MatDestroySubMatrices

MatDiagonalGetDiagonal(petsclib::PetscLibType,A::PetscMat, diag::PetscVec)

Get the diagonal of a MATDIAGONAL

Input Parameter:

• A - the MATDIAGONAL

Output Parameter:

• diag - the Vec that defines the diagonal

Level: developer

-seealso: , MATDIAGONAL, MatCreateDiagonal(), MatDiagonalRestoreDiagonal(), MatDiagonalGetInverseDiagonal(), MatGetDiagonal()

External Links

• PETSc Manual: Mat/MatDiagonalGetDiagonal

MatDiagonalGetInverseDiagonal(petsclib::PetscLibType,A::PetscMat, inv_diag::PetscVec)

Get the inverse diagonal of a MATDIAGONAL

Input Parameter:

• A - the MATDIAGONAL

Output Parameter:

• inv_diag - the Vec that defines the inverse diagonal

Level: developer

-seealso: , MATDIAGONAL, MatCreateDiagonal(), MatDiagonalRestoreInverseDiagonal(), MatDiagonalGetDiagonal(), MATLMVMBROYDEN, MatSolve()

External Links

• PETSc Manual: Mat/MatDiagonalGetInverseDiagonal

MatDiagonalRestoreDiagonal(petsclib::PetscLibType,A::PetscMat, diag::PetscVec)

Restore the diagonal of a MATDIAGONAL

Input Parameters:

• A - the MATDIAGONAL
• diag - the Vec obtained from MatDiagonalGetDiagonal()

Level: developer

-seealso: , MATDIAGONAL, MatCreateDiagonal(), MatDiagonalGetDiagonal()

External Links

• PETSc Manual: Mat/MatDiagonalRestoreDiagonal

MatDiagonalRestoreInverseDiagonal(petsclib::PetscLibType,A::PetscMat, inv_diag::PetscVec)

Restore the inverse diagonal of a MATDIAGONAL

Input Parameters:

• A - the MATDIAGONAL
• inv_diag - the Vec obtained from MatDiagonalGetInverseDiagonal()

Level: developer

-seealso: , MATDIAGONAL, MatCreateDiagonal(), MatDiagonalGetInverseDiagonal()

External Links

• PETSc Manual: Mat/MatDiagonalRestoreInverseDiagonal

MatDiagonalScale(petsclib::PetscLibType,mat::PetscMat, l::PetscVec, r::PetscVec)

Scales a matrix on the left and right by diagonal matrices that are stored as vectors. Either of the two scaling matrices can be NULL.

Collective

Input Parameters:

• mat - the matrix to be scaled
• l - the left scaling vector (or NULL)
• r - the right scaling vector (or NULL)

Level: intermediate

-seealso: , Mat, MatScale(), MatShift(), MatDiagonalSet()

External Links

• PETSc Manual: Mat/MatDiagonalScale

MatDiagonalScaleLocal(petsclib::PetscLibType,mat::PetscMat, diag::PetscVec)

Scales columns of a matrix given the scaling values including the ghosted ones.

Not Collective

Input Parameters:

• mat - the matrix
• diag - the diagonal values, including ghost ones

Level: developer

-seealso: , Mat, MatDiagonalScale()

External Links

• PETSc Manual: Mat/MatDiagonalScaleLocal

MatDiagonalSet(petsclib::PetscLibType,Y::PetscMat, D::PetscVec, is::InsertMode)

Computes Y = Y + D, where D is a diagonal matrix that is represented as a vector. Or Y[i,i] = D[i] if InsertMode is INSERT_VALUES.

Neighbor-wise Collective

Input Parameters:

• Y - the input matrix
• D - the diagonal matrix, represented as a vector
• is - INSERT_VALUES or ADD_VALUES

Level: intermediate

-seealso: , Mat, MatShift(), MatScale(), MatDiagonalScale()

External Links

• PETSc Manual: Mat/MatDiagonalSet

MatDuplicate(petsclib::PetscLibType,mat::PetscMat, op::MatDuplicateOption, M::PetscMat)

Duplicates a matrix including the non

Collective

Input Parameters:

• mat - the matrix
• op - One of MAT_DO_NOT_COPY_VALUES, MAT_COPY_VALUES, or MAT_SHARE_NONZERO_PATTERN.

See the manual page for MatDuplicateOption() for an explanation of these options.

Output Parameter:

• M - pointer to place new matrix

Level: intermediate

-seealso: , Mat, MatCopy(), MatConvert(), MatDuplicateOption

External Links

• PETSc Manual: Mat/MatDuplicate

MatEliminateZeros(petsclib::PetscLibType,A::PetscMat, keep::PetscBool)

eliminate the nondiagonal zero entries in place from the nonzero structure of a sparse Mat in place, meaning the same memory is used for the matrix, and no new memory is allocated.

Collective

Input Parameters:

• A - the matrix
• keep - if for a given row of A, the diagonal coefficient is zero, indicates whether it should be left in the structure or eliminated as well

Level: intermediate

-seealso: , Mat, MatCreate(), MatCreateGraph(), MatFilter()

External Links

• PETSc Manual: Mat/MatEliminateZeros

flg::PetscBool = MatEqual(petsclib::PetscLibType,A::PetscMat, B::PetscMat)

Compares two matrices.

Collective

Input Parameters:

• A - the first matrix
• B - the second matrix

Output Parameter:

• flg - PETSC_TRUE if the matrices are equal; PETSC_FALSE otherwise.

Level: intermediate

-seealso: , Mat, MatMultEqual()

External Links

• PETSc Manual: Mat/MatEqual

MatFactorClearError(petsclib::PetscLibType,mat::PetscMat)

clears the error code in a factorization

Logically Collective

Input Parameter:

• mat - the factored matrix

Level: developer

-seealso: , Mat, MatZeroEntries(), MatFactor(), MatGetFactor(), MatLUFactorSymbolic(), MatCholeskyFactorSymbolic(), MatFactorGetError(), MatFactorGetErrorZeroPivot(), MatGetErrorCode(), MatFactorError

External Links

• PETSc Manual: Mat/MatFactorClearError

S::PetscMat,status::MatFactorSchurStatus = MatFactorCreateSchurComplement(petsclib::PetscLibType,F::PetscMat)

Create a Schur complement matrix object using Schur data computed during the factorization step

Logically Collective

Input Parameters:

• F - the factored matrix obtained by calling MatGetFactor()
• S - location where to return the Schur complement, can be NULL
• status - the status of the Schur complement matrix, can be NULL

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorSetSchurIS(), MatFactorGetSchurComplement(), MatFactorSchurStatus, MATSOLVERMUMPS, MATSOLVERMKL_PARDISO

External Links

• PETSc Manual: Mat/MatFactorCreateSchurComplement

MatFactorFactorizeSchurComplement(petsclib::PetscLibType,F::PetscMat)

Factorize the Schur complement matrix computed during the factorization step

Logically Collective

Input Parameter:

• F - the factored matrix obtained by calling MatGetFactor()

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorSetSchurIS(), MatFactorInvertSchurComplement()

External Links

• PETSc Manual: Mat/MatFactorFactorizeSchurComplement

flg::PetscBool = MatFactorGetCanUseOrdering(petsclib::PetscLibType,mat::PetscMat)

Indicates if the factorization can use the ordering provided in MatLUFactorSymbolic(), MatCholeskyFactorSymbolic()

Logically Collective

Input Parameter:

• mat - the matrix

Output Parameter:

• flg - PETSC_TRUE if uses the ordering

Level: developer

-seealso: , Mat, Matrix Factorization, MatCopy(), MatDuplicate(), MatGetFactorAvailable(), MatGetFactor(), MatLUFactorSymbolic(), MatCholeskyFactorSymbolic()

External Links

• PETSc Manual: Mat/MatFactorGetCanUseOrdering

MatFactorGetError(petsclib::PetscLibType,mat::PetscMat, err::MatFactorError)

gets the error code from a factorization

Logically Collective

Input Parameter:

• mat - the factored matrix

Output Parameter:

• err - the error code

Level: advanced

-seealso: , Mat, MatZeroEntries(), MatFactor(), MatGetFactor(), MatLUFactorSymbolic(), MatCholeskyFactorSymbolic(), MatFactorClearError(), MatFactorGetErrorZeroPivot(), MatFactorError

External Links

• PETSc Manual: Mat/MatFactorGetError

pivot::PetscReal,row::PetscInt = MatFactorGetErrorZeroPivot(petsclib::PetscLibType,mat::PetscMat)

returns the pivot value that was determined to be zero and the row it occurred in

Logically Collective

Input Parameter:

• mat - the factored matrix

Output Parameters:

• pivot - the pivot value computed
• row - the row that the zero pivot occurred. This row value must be interpreted carefully due to row reorderings and which processes

the share the matrix

Level: advanced

-seealso: , Mat, MatZeroEntries(), MatFactor(), MatGetFactor(), MatLUFactorSymbolic(), MatCholeskyFactorSymbolic(), MatFactorClearError(), MAT_FACTOR_NUMERIC_ZEROPIVOT

External Links

• PETSc Manual: Mat/MatFactorGetErrorZeroPivot

MatFactorGetPreferredOrdering(petsclib::PetscLibType,mat::PetscMat, ftype::MatFactorType, otype::MatOrderingType)

The preferred ordering for a particular matrix factor object

Logically Collective

Input Parameters:

• mat - the matrix obtained with MatGetFactor()
• ftype - the factorization type to be used

Output Parameter:

• otype - the preferred ordering type

Level: developer

-seealso: , Mat, Matrix Factorization, MatFactorType, MatOrderingType, MatCopy(), MatDuplicate(), MatGetFactorAvailable(), MatGetFactor(), MatLUFactorSymbolic(), MatCholeskyFactorSymbolic()

External Links

• PETSc Manual: Mat/MatFactorGetPreferredOrdering

MatFactorGetSchurComplement(petsclib::PetscLibType,F::PetscMat, S::PetscMat, status::MatFactorSchurStatus)

Gets access to a Schur complement matrix using the current Schur data within a factored matrix

Logically Collective

Input Parameters:

• F - the factored matrix obtained by calling MatGetFactor()
• S - location where to return the Schur complement, can be NULL
• status - the status of the Schur complement matrix, can be NULL

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorSetSchurIS(), MatFactorRestoreSchurComplement(), MatFactorCreateSchurComplement(), MatFactorSchurStatus

External Links

• PETSc Manual: Mat/MatFactorGetSchurComplement

type::MatSolverType = MatFactorGetSolverType(petsclib::PetscLibType,mat::PetscMat)

Returns name of the package providing the factorization routines

Not Collective

Input Parameter:

• mat - the matrix, must be a factored matrix

Output Parameter:

• type - the string name of the package (do not free this string)

Level: intermediate

-seealso: , Mat, Matrix Factorization, MatGetFactor(), MatSolverType, MatCopy(), MatDuplicate(), MatGetFactorAvailable()

External Links

• PETSc Manual: Mat/MatFactorGetSolverType

MatFactorInfoInitialize(petsclib::PetscLibType,info::MatFactorInfo)

Initializes a MatFactorInfo data structure with default values.

Not Collective

Input Parameter:

• info - the MatFactorInfo data structure

Level: developer

-seealso: , Mat, MatGetFactor(), MatFactorInfo

External Links

• PETSc Manual: Mat/MatFactorInfoInitialize

MatFactorInvertSchurComplement(petsclib::PetscLibType,F::PetscMat)

Invert the Schur complement matrix computed during the factorization step

Logically Collective

Input Parameter:

• F - the factored matrix obtained by calling MatGetFactor()

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorSetSchurIS(), MatFactorGetSchurComplement(), MatFactorCreateSchurComplement()

External Links

• PETSc Manual: Mat/MatFactorInvertSchurComplement

MatFactorRestoreSchurComplement(petsclib::PetscLibType,F::PetscMat, S::PetscMat, status::MatFactorSchurStatus)

Restore the Schur complement matrix object obtained from a call to MatFactorGetSchurComplement()

Logically Collective

Input Parameters:

• F - the factored matrix obtained by calling MatGetFactor()
• S - location where the Schur complement is stored
• status - the status of the Schur complement matrix (see MatFactorSchurStatus)

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorSetSchurIS(), MatFactorCreateSchurComplement(), MatFactorSchurStatus

External Links

• PETSc Manual: Mat/MatFactorRestoreSchurComplement

MatFactorSetSchurIS(petsclib::PetscLibType,mat::PetscMat, is::IS)

Set indices corresponding to the Schur complement you wish to have computed

Collective

Input Parameters:

• mat - the factored matrix
• is - the index set defining the Schur indices (0-based)

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorGetSchurComplement(), MatFactorRestoreSchurComplement(), MatFactorCreateSchurComplement(), MatFactorSolveSchurComplement(), MatFactorSolveSchurComplementTranspose(), MATSOLVERMUMPS, MATSOLVERMKL_PARDISO

External Links

• PETSc Manual: Mat/MatFactorSetSchurIS

MatFactorSolveSchurComplement(petsclib::PetscLibType,F::PetscMat, rhs::PetscVec, sol::PetscVec)

Solve the Schur complement system computed during the factorization step

Logically Collective

Input Parameters:

• F - the factored matrix obtained by calling MatGetFactor()
• rhs - location where the right-hand side of the Schur complement system is stored
• sol - location where the solution of the Schur complement system has to be returned

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorSetSchurIS(), MatFactorSolveSchurComplementTranspose()

External Links

• PETSc Manual: Mat/MatFactorSolveSchurComplement

MatFactorSolveSchurComplementTranspose(petsclib::PetscLibType,F::PetscMat, rhs::PetscVec, sol::PetscVec)

Solve the transpose of the Schur complement system computed during the factorization step

Logically Collective

Input Parameters:

• F - the factored matrix obtained by calling MatGetFactor()
• rhs - location where the right-hand side of the Schur complement system is stored
• sol - location where the solution of the Schur complement system has to be returned

Level: advanced

-seealso: , Mat, MatGetFactor(), MatFactorSetSchurIS(), MatFactorSolveSchurComplement()

External Links

• PETSc Manual: Mat/MatFactorSolveSchurComplementTranspose