MathLib::PETScMatrix Class Reference

Detailed Description

Wrapper class for PETSc matrix routines for matrix.

Definition at line 22 of file PETScMatrix.h.

#include <PETScMatrix.h>

Public Types
using	IndexType = PetscInt

Public Member Functions
	PETScMatrix ()
	PETScMatrix (const PetscInt nrows, const PETScSparsityPattern &sparsity_pattern)
	Constructor for a square matrix partitioning with more options.
	PETScMatrix (const PetscInt nrows, const PetscInt ncols, const PETScSparsityPattern &sparsity_pattern)
	Constructor for a rectangular matrix partitioning with more options.
	~PETScMatrix ()
	PETScMatrix (PETScMatrix const &A)
PETScMatrix &	operator= (PETScMatrix const &A)
void	finalizeAssembly (const MatAssemblyType asm_type=MAT_FINAL_ASSEMBLY)
	Perform MPI collection of assembled entries in buffer.
PetscInt	getNumberOfRows () const
	Get the number of rows.
PetscInt	getNumberOfColumns () const
	Get the number of columns.
PetscInt	getNumberOfLocalRows () const
	Get the number of local rows.
PetscInt	getNumberOfLocalColumns () const
	Get the number of local columns.
PetscInt	getRangeBegin () const
	Get the start global index of the rows of the same rank.
PetscInt	getRangeEnd () const
	Get the end global index of the rows in the same rank.
std::vector< PetscInt > const &	getSparsityColumnIndices () const
	Column indices cached at preallocation (empty on the fallback path).
Mat &	getRawMatrix ()
	Get matrix reference.
Mat const &	getRawMatrix () const
void	setZero ()
	Set all entries to zero.
void	setRowsColumnsZero (std::vector< PetscInt > const &row_pos)
	Set the specified rows to zero except diagonal entries, i.e. \(A(k, j) = \begin{cases} 0.0, &j\not=k, j=1,2,\dots,k-1, k+1, \dots, n \\ 1.0, &j = k \end{cases}\), where \(k \in \mbox{row\_pos}\) This function must be called by all ranks.
void	set (const PetscInt i, const PetscInt j, const PetscScalar value)
	Set a single entry with a value.
void	add (const PetscInt i, const PetscInt j, const PetscScalar value)
	Add value to a single entry.
void	addToDiagonal (const PetscScalar value)
	Add a constant value to all diagonal entries of the matrix.
template<class T_DENSE_MATRIX>
void	add (RowColumnIndices< PetscInt > const &indices, const T_DENSE_MATRIX &sub_matrix)
	Add sub-matrix at positions given by global indices, in which negative index indicates ghost entry.
template<class T_DENSE_MATRIX>
void	add (std::vector< PetscInt > const &row_pos, std::vector< PetscInt > const &col_pos, const T_DENSE_MATRIX &sub_mat)
	Add a dense sub-matrix to a PETSc matrix.
void	viewer (const std::string &file_name, const PetscViewerFormat vw_format=PETSC_VIEWER_ASCII_MATLAB)

Private Member Functions
void	destroy ()
void	create (const PETScSparsityPattern &sparsity_pattern)
	Create the matrix, configure memory allocation and set the related member data.
void	preallocateFromSparsityPattern (const PETScSparsityPattern &sparsity_pattern)
	Preallocate the matrix storage from an exact sparsity pattern.

Private Attributes
Mat	A_ = nullptr
	PETSc matrix.
PetscInt	nrows_
	Number of the global rows.
PetscInt	ncols_
	Number of the global columns.
PetscInt	n_loc_rows_
	Number of the local rows.
PetscInt	n_loc_cols_
	Number of the local columns.
PetscInt	start_rank_
	Starting index in a rank.
PetscInt	end_rank_
	Ending index in a rank.
std::vector< PetscInt >	sparsity_col_idx_
	Column indices from preallocation (empty when fallback path was used).

Friends
bool	finalizeMatrixAssembly (PETScMatrix &mat, const MatAssemblyType asm_type=MAT_FINAL_ASSEMBLY)
	General interface for the matrix assembly.

Member Typedef Documentation

IndexType

using MathLib::PETScMatrix::IndexType = PetscInt

Definition at line 25 of file PETScMatrix.h.

Constructor & Destructor Documentation

PETScMatrix() [1/4]

MathLib::PETScMatrix::PETScMatrix ( )

inline

Definition at line 28 of file PETScMatrix.h.

{}

Referenced by PETScMatrix(), finalizeMatrixAssembly, and operator=().

PETScMatrix() [2/4]

MathLib::PETScMatrix::PETScMatrix	(	const PetscInt	nrows,
		const PETScSparsityPattern &	sparsity_pattern )

Constructor for a square matrix partitioning with more options.

Parameters

nrows	The number of local rows of the matrix; the global size is left to PETSc.
sparsity_pattern	CSR per-local-row column indices to reserve.

Definition at line 11 of file PETScMatrix.cpp.

    : nrows_(PETSC_DECIDE),
      ncols_(PETSC_DECIDE),
      n_loc_rows_(nrows),
      n_loc_cols_(nrows)
{
    create(sparsity_pattern);
}

References create(), n_loc_cols_, n_loc_rows_, ncols_, and nrows_.

PETScMatrix() [3/4]

MathLib::PETScMatrix::PETScMatrix	(	const PetscInt	nrows,
		const PetscInt	ncols,
		const PETScSparsityPattern &	sparsity_pattern )

Constructor for a rectangular matrix partitioning with more options.

Parameters

nrows	The number of local rows; the global size is left to PETSc.
ncols	The number of local columns; the global size is left to PETSc.
sparsity_pattern	CSR per-local-row column indices to reserve.

Definition at line 21 of file PETScMatrix.cpp.

    : nrows_(PETSC_DECIDE),
      ncols_(PETSC_DECIDE),
      n_loc_rows_(nrows),
      n_loc_cols_(ncols)
{
    create(sparsity_pattern);
}

References create(), n_loc_cols_, n_loc_rows_, ncols_, and nrows_.

~PETScMatrix()

MathLib::PETScMatrix::~PETScMatrix ( )

inline

Definition at line 50 of file PETScMatrix.h.

{ destroy(); }

References destroy().

PETScMatrix() [4/4]

MathLib::PETScMatrix::PETScMatrix

(

PETScMatrix const &

A

)

Definition at line 31 of file PETScMatrix.cpp.

    : nrows_(A.nrows_),
      ncols_(A.ncols_),
      n_loc_rows_(A.n_loc_rows_),
      n_loc_cols_(A.n_loc_cols_),
      start_rank_(A.start_rank_),
      end_rank_(A.end_rank_),
      sparsity_col_idx_(A.sparsity_col_idx_)
{
    // MatDuplicate reproduces the nonzero structure exactly, so the copy
    // shares the source's structure.
    PetscCallAbort(PETSC_COMM_WORLD, MatDuplicate(A.A_, MAT_COPY_VALUES, &A_));
}

References PETScMatrix(), A_, end_rank_, n_loc_cols_, n_loc_rows_, ncols_, nrows_, sparsity_col_idx_, and start_rank_.

Member Function Documentation

add() [1/3]

void MathLib::PETScMatrix::add ( const PetscInt i, const PetscInt j, const PetscScalar value )

inline

Add value to a single entry.

Parameters

i	The row index.
j	The column index.
value	The entry value.

Definition at line 124 of file PETScMatrix.h.

    {
        PetscCallAbort(PETSC_COMM_WORLD,
                       MatSetValue(A_, i, j, value, ADD_VALUES));
    }

References A_.

Referenced by add(), MathLib::addToMatrix(), and MathLib::setMatrix().

add() [2/3]

template<class T_DENSE_MATRIX>

void MathLib::PETScMatrix::add ( RowColumnIndices< PetscInt > const & indices, const T_DENSE_MATRIX & sub_matrix )

inline

Add sub-matrix at positions given by global indices, in which negative index indicates ghost entry.

In order to use MatZeroRows to apply Dirichlet boundary condition, entries in the rows with the negative global indices are skipped to added to the global matrix, meanwhile entries in the columns with the negative global indices are added the global matrix. By using MatZeroRows to apply Dirichlet boundary condition, the off diagonal entries in ghost rows of the global matrix are set to zero, while the off diagonal entries in ghost rows of the global matrix are assembled and kept for linear solver.

For the setting of Dirichlet boundary condition in PETSc, please refer to the PETSc:Documentation:FAQ.

Definition at line 154 of file PETScMatrix.h.

    {
        // Set global column indices to positive to allow all entries of columns
        // to be added to the global matrix. For the ghost columns, only the
        // off diagonal entries are added due to the negative indices of the
        // corresponding rows.
        std::vector<PetscInt> cols;
        cols.reserve(indices.columns.size());
        for (auto col : indices.columns)
        {
            // Ghost entries, and its original index is 0.
            if (col == -ncols_)
            {
                cols.push_back(0);
            }
            else
            {
                cols.push_back(std::abs(col));
            }
        }
 
        add(indices.rows, cols, sub_matrix);
    }

References add(), MathLib::RowColumnIndices< IDX_TYPE >::columns, ncols_, and MathLib::RowColumnIndices< IDX_TYPE >::rows.

add() [3/3]

template<class T_DENSE_MATRIX>

void MathLib::PETScMatrix::add	(	std::vector< PetscInt > const &	row_pos,
		std::vector< PetscInt > const &	col_pos,
		const T_DENSE_MATRIX &	sub_mat )

Add a dense sub-matrix to a PETSc matrix.

Parameters

row_pos	The global indices of the rows of the dense sub-matrix.
col_pos	The global indices of the columns of the dense sub-matrix.
sub_mat	A dense sub-matrix to be added. Its data of which must be row oriented stored.

Definition at line 283 of file PETScMatrix.h.

{
    const PetscInt nrows = static_cast<PetscInt>(row_pos.size());
    const PetscInt ncols = static_cast<PetscInt>(col_pos.size());
 
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatSetValues(A_, nrows, &row_pos[0], ncols, &col_pos[0],
                                sub_mat.data(), ADD_VALUES));
};

References A_.

addToDiagonal()

void MathLib::PETScMatrix::addToDiagonal

(

const PetscScalar

value

)

Add a constant value to all diagonal entries of the matrix.

Parameters

value

The value to add to each diagonal entry.

Note

This is more efficient than calling add(i, i, value) in a loop.

Definition at line 227 of file PETScMatrix.cpp.

{
    // MatShift computes A_ = A_ + value * I, i.e. adds value to every diagonal
    // entry (creating missing ones). Correct in both serial and parallel.
    // Temporarily allow new nonzero entries so a diagonal entry missing from
    // the preallocated sparsity pattern doesn't abort the run.
    PetscCallAbort(
        PETSC_COMM_WORLD,
        MatSetOption(A_, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
    PetscCallAbort(PETSC_COMM_WORLD, MatShift(A_, value));
    PetscCallAbort(
        PETSC_COMM_WORLD,
        MatSetOption(A_, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
}

References A_.

create()

void MathLib::PETScMatrix::create ( const PETScSparsityPattern & sparsity_pattern )

private

Create the matrix, configure memory allocation and set the related member data.

Parameters

sparsity_pattern

CSR per-local-row column indices to reserve.

Definition at line 126 of file PETScMatrix.cpp.

{
    PetscCallAbort(PETSC_COMM_WORLD, MatCreate(PETSC_COMM_WORLD, &A_));
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatSetSizes(A_, n_loc_rows_, n_loc_cols_, nrows_, ncols_));
 
    PetscCallAbort(PETSC_COMM_WORLD, MatSetType(A_, MATAIJ));
    PetscCallAbort(PETSC_COMM_WORLD, MatSetFromOptions(A_));
 
    // Use MATPREALLOCATOR for type-agnostic exact sparsity preallocation.
    // This works regardless of the matrix type chosen via -mat_type.
    preallocateFromSparsityPattern(sparsity_pattern);
 
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatGetOwnershipRange(A_, &start_rank_, &end_rank_));
    PetscCallAbort(PETSC_COMM_WORLD, MatGetSize(A_, &nrows_, &ncols_));
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatGetLocalSize(A_, &n_loc_rows_, &n_loc_cols_));
}

References A_, end_rank_, n_loc_cols_, n_loc_rows_, ncols_, nrows_, preallocateFromSparsityPattern(), and start_rank_.

Referenced by PETScMatrix(), and PETScMatrix().

destroy()

void MathLib::PETScMatrix::destroy ( )

inlineprivate

Definition at line 225 of file PETScMatrix.h.

    {
        if (A_ != nullptr)
        {
            PetscCallAbort(PETSC_COMM_WORLD, MatDestroy(&A_));
        }
        A_ = nullptr;
    }

References A_.

Referenced by ~PETScMatrix(), and operator=().

finalizeAssembly()

void MathLib::PETScMatrix::finalizeAssembly ( const MatAssemblyType asm_type = MAT_FINAL_ASSEMBLY )

inline

Perform MPI collection of assembled entries in buffer.

Parameters

asm_type

Assembly type, either MAT_FLUSH_ASSEMBLY or MAT_FINAL_ASSEMBLY

Definition at line 60 of file PETScMatrix.h.

    {
        MatAssemblyBegin(A_, asm_type);
        MatAssemblyEnd(A_, asm_type);
    }

References A_.

Referenced by MathLib::applyKnownSolution(), MathLib::LinAlg::finalizeAssembly(), finalizeMatrixAssembly, and viewer().

getNumberOfColumns()

PetscInt MathLib::PETScMatrix::getNumberOfColumns ( ) const

inline

Get the number of columns.

Definition at line 69 of file PETScMatrix.h.

{ return ncols_; }

References ncols_.

Referenced by MathLib::addToMatrix(), and MathLib::setMatrix().

getNumberOfLocalColumns()

PetscInt MathLib::PETScMatrix::getNumberOfLocalColumns ( ) const

inline

Get the number of local columns.

Definition at line 73 of file PETScMatrix.h.

{ return n_loc_cols_; }

References n_loc_cols_.

getNumberOfLocalRows()

PetscInt MathLib::PETScMatrix::getNumberOfLocalRows ( ) const

inline

Get the number of local rows.

Definition at line 71 of file PETScMatrix.h.

{ return n_loc_rows_; }

References n_loc_rows_.

getNumberOfRows()

PetscInt MathLib::PETScMatrix::getNumberOfRows ( ) const

inline

Get the number of rows.

Definition at line 67 of file PETScMatrix.h.

{ return nrows_; }

References nrows_.

Referenced by MathLib::addToMatrix(), and MathLib::setMatrix().

getRangeBegin()

PetscInt MathLib::PETScMatrix::getRangeBegin ( ) const

inline

Get the start global index of the rows of the same rank.

Definition at line 75 of file PETScMatrix.h.

{ return start_rank_; }

References start_rank_.

getRangeEnd()

PetscInt MathLib::PETScMatrix::getRangeEnd ( ) const

inline

Get the end global index of the rows in the same rank.

Definition at line 77 of file PETScMatrix.h.

{ return end_rank_; }

References end_rank_.

getRawMatrix() [1/2]

Mat & MathLib::PETScMatrix::getRawMatrix ( )

inline

Get matrix reference.

Definition at line 85 of file PETScMatrix.h.

{ return A_; }

References A_.

Referenced by MathLib::LinAlg::axpy(), MathLib::LinAlg::aypx(), MathLib::LinAlg::matMult(), MathLib::LinAlg::matMultAdd(), MathLib::LinAlg::scale(), MathLib::setPreallocationNonzeroOption(), and MathLib::PETScLinearSolver::solve().

getRawMatrix() [2/2]

Mat const & MathLib::PETScMatrix::getRawMatrix ( ) const

inline

Get a matrix reference.

Warning

This method is dangerous insofar as you can do arbitrary things also with a const PETSc matrix.

Definition at line 92 of file PETScMatrix.h.

{ return A_; }

References A_.

getSparsityColumnIndices()

std::vector< PetscInt > const & MathLib::PETScMatrix::getSparsityColumnIndices ( ) const

inline

Column indices cached at preallocation (empty on the fallback path).

Definition at line 79 of file PETScMatrix.h.

    {
        return sparsity_col_idx_;
    }

References sparsity_col_idx_.

Referenced by MathLib::LinAlg::axpy(), and MathLib::LinAlg::aypx().

operator=()

PETScMatrix & MathLib::PETScMatrix::operator=

(

PETScMatrix const &

A

)

Definition at line 45 of file PETScMatrix.cpp.

{
    nrows_ = A.nrows_;
    ncols_ = A.ncols_;
    n_loc_rows_ = A.n_loc_rows_;
    n_loc_cols_ = A.n_loc_cols_;
    start_rank_ = A.start_rank_;
    end_rank_ = A.end_rank_;
 
    if (A_ != nullptr)
    {
        auto const pattern =
            nonzeroPatternStructure(A.sparsity_col_idx_, sparsity_col_idx_);
        sparsity_col_idx_ = A.sparsity_col_idx_;
        PetscCallAbort(PETSC_COMM_WORLD, MatCopy(A.A_, A_, pattern));
    }
    else
    {
        sparsity_col_idx_ = A.sparsity_col_idx_;
        destroy();
        PetscCallAbort(PETSC_COMM_WORLD,
                       MatDuplicate(A.A_, MAT_COPY_VALUES, &A_));
    }
 
    return *this;
}

References PETScMatrix(), A_, destroy(), end_rank_, n_loc_cols_, n_loc_rows_, ncols_, MathLib::nonzeroPatternStructure(), nrows_, sparsity_col_idx_, and start_rank_.

preallocateFromSparsityPattern()

void MathLib::PETScMatrix::preallocateFromSparsityPattern ( const PETScSparsityPattern & sparsity_pattern )

private

Preallocate the matrix storage from an exact sparsity pattern.

Uses a MATPREALLOCATOR helper matrix to reserve, type-agnostically, exactly the nonzero positions described by sparsity_pattern, then transfers the preallocation to the real matrix. Also caches the column indices in sparsity_col_idx_ for later nonzero-pattern comparisons.

Parameters

sparsity_pattern

CSR-style per-local-row column indices to reserve.

Definition at line 146 of file PETScMatrix.cpp.

{
    Mat preallocator;
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatCreate(PETSC_COMM_WORLD, &preallocator));
    PetscCallAbort(
        PETSC_COMM_WORLD,
        MatSetSizes(preallocator, n_loc_rows_, n_loc_cols_, nrows_, ncols_));
    PetscCallAbort(PETSC_COMM_WORLD, MatSetType(preallocator, MATPREALLOCATOR));
    PetscCallAbort(PETSC_COMM_WORLD, MatSetUp(preallocator));
 
    PetscInt row_start;
    PetscInt row_end;
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatGetOwnershipRange(preallocator, &row_start, &row_end));
 
    PetscInt const n_local = row_end - row_start;
 
    // The pattern is indexed by local row below, so PETSc's row distribution
    // must agree with the one the pattern was built for. A mismatch would
    // otherwise silently read the wrong rows, or read out of bounds.
    //
    // The condition is rank-local, so it is reduced before aborting: a rank
    // aborting on its own would leave the other ranks hanging in the collective
    // assembly below instead of failing with it.
    if (!BaseLib::MPI::allOf(sparsity_pattern.numberOfRows() == n_local))
    {
        OGS_FATAL(
            "PETScMatrix: the sparsity pattern's local row count and PETSc's "
            "row distribution disagree on at least one rank. On this rank the "
            "pattern describes {} local rows, but PETSc distributed {} rows.",
            sparsity_pattern.numberOfRows(), n_local);
    }
 
    // Record the nonzero structure of this rank's rows in the MATPREALLOCATOR
    // helper, one row at a time. MATPREALLOCATOR stores positions only, so the
    // values array is ignored and nullptr is passed. All rows here are in
    // [row_start, row_end), so the off-process stash path (which would read
    // the values) is never taken.
    for (PetscInt local_row = 0; local_row < n_local; ++local_row)
    {
        PetscInt const global_row = row_start + local_row;
        PetscInt const ncols = sparsity_pattern.nnzInRow(local_row);
        PetscInt const* const cols = sparsity_pattern.col_idx.data() +
                                     sparsity_pattern.row_ptr[local_row];
        PetscCallAbort(PETSC_COMM_WORLD,
                       MatSetValues(preallocator, 1, &global_row, ncols, cols,
                                    nullptr, INSERT_VALUES));
    }
 
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatAssemblyBegin(preallocator, MAT_FINAL_ASSEMBLY));
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatAssemblyEnd(preallocator, MAT_FINAL_ASSEMBLY));
 
    // Insert explicit zeros at every preallocated position by
    // MatPreallocatorPreallocate below (fill = PETSC_TRUE) so that
    // MAT_FINAL_ASSEMBLY in subsequent partial assemblies (e.g. soil-only) does
    // not discard entries that were allocated but not yet written to.
    constexpr PetscBool fill_zeros = PETSC_TRUE;
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatPreallocatorPreallocate(preallocator, fill_zeros, A_));
    // The preallocator is a transient helper, destroyed once the target matrix
    // has its structure. Keeping it would let further matrices built from the
    // same sparsity pattern skip the row-by-row MatSetValues loop above, but
    // the cache would have to live where the pattern lives (the matrix
    // specifications / matrix provider), not in a single matrix. It is not done
    // here: matrices are constructed a handful of times per process, and the
    // loop costs one pass over the pattern, negligible next to assembly.
    PetscCallAbort(PETSC_COMM_WORLD, MatDestroy(&preallocator));
 
    sparsity_col_idx_ = sparsity_pattern.col_idx;
}

References A_, BaseLib::MPI::allOf(), MathLib::PETScSparsityPattern::col_idx, n_loc_cols_, n_loc_rows_, ncols_, MathLib::PETScSparsityPattern::nnzInRow(), nrows_, MathLib::PETScSparsityPattern::numberOfRows(), OGS_FATAL, MathLib::PETScSparsityPattern::row_ptr, and sparsity_col_idx_.

Referenced by create().

set()

void MathLib::PETScMatrix::set ( const PetscInt i, const PetscInt j, const PetscScalar value )

inline

Set a single entry with a value.

Parameters

i	The row index.
j	The column index.
value	The entry value.

Definition at line 112 of file PETScMatrix.h.

    {
        PetscCallAbort(PETSC_COMM_WORLD,
                       MatSetValue(A_, i, j, value, INSERT_VALUES));
    }

References A_.

setRowsColumnsZero()

void MathLib::PETScMatrix::setRowsColumnsZero

(

std::vector< PetscInt > const &

row_pos

)

Set the specified rows to zero except diagonal entries, i.e. \(A(k, j) = \begin{cases} 0.0, &j\not=k, j=1,2,\dots,k-1, k+1, \dots, n \\ 1.0, &j = k \end{cases}\), where \(k \in \mbox{row\_pos}\) This function must be called by all ranks.

Parameters

row_pos

The row indices of the specified rows.

Definition at line 72 of file PETScMatrix.cpp.

{
    // Each rank (compute core) processes only the rows that belong to the rank
    // itself.
    const PetscScalar one = 1.0;
    const PetscInt nrows = static_cast<PetscInt>(row_pos.size());
 
    // Each process will only zero its own rows.
    // This avoids all reductions in the zero row routines
    // and thus improves performance for very large process counts.
    // See PETSc doc about MAT_NO_OFF_PROC_ZERO_ROWS.
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatSetOption(A_, MAT_NO_OFF_PROC_ZERO_ROWS, PETSC_TRUE));
 
    // Keep the non-zero pattern for the assignment operator.
    PetscCallAbort(PETSC_COMM_WORLD,
                   MatSetOption(A_, MAT_KEEP_NONZERO_PATTERN, PETSC_TRUE));
 
    if (nrows > 0)
    {
        PetscCallAbort(PETSC_COMM_WORLD,
                       MatZeroRows(A_, nrows, &row_pos[0], one, PETSC_NULLPTR,
                                   PETSC_NULLPTR));
    }
    else
    {
        PetscCallAbort(PETSC_COMM_WORLD,
                       MatZeroRows(A_, 0, PETSC_NULLPTR, one, PETSC_NULLPTR,
                                   PETSC_NULLPTR));
    }
}

References A_.

Referenced by MathLib::applyKnownSolution().

setZero()

void MathLib::PETScMatrix::setZero ( )

inline

Set all entries to zero.

Definition at line 94 of file PETScMatrix.h.

{ MatZeroEntries(A_); }

References A_.

Referenced by MathLib::setMatrix(), and MathLib::setMatrix().

viewer()

void MathLib::PETScMatrix::viewer	(	const std::string &	file_name,
		const PetscViewerFormat	vw_format = PETSC_VIEWER_ASCII_MATLAB )

View the global vector for test purpose. Do not use it for output a big vector.

Parameters

file_name

File name for output

vw_format

File format listed as: PETSC_VIEWER_DEFAULT Default format PETSC_VIEWER_ASCII_MATLAB MATLAB format PETSC_VIEWER_ASCII_DENSE Print matrix as dense PETSC_VIEWER_ASCII_IMPL Implementation-specific format (which is in many cases the same as the default) PETSC_VIEWER_ASCII_INFO Basic information about object PETSC_VIEWER_ASCII_INFO_DETAIL More detailed info about object PETSC_VIEWER_ASCII_COMMON Identical output format for all objects of a particular type PETSC_VIEWER_ASCII_INDEX (for vectors) Prints the vector element number next to each vector entry PETSC_VIEWER_ASCII_SYMMODU Print parallel vectors without indicating the processor ranges PETSC_VIEWER_ASCII_VTK Outputs the object to a VTK file PETSC_VIEWER_NATIVE Store the object to the binary file in its native format (for example, dense matrices are stored as dense), DMDA vectors are dumped directly to the file instead of being first put in the natural ordering PETSC_VIEWER_DRAW_BASIC Views the vector with a simple 1d plot PETSC_VIEWER_DRAW_LG Views the vector with a line graph PETSC_VIEWER_DRAW_CONTOUR Views the vector with a contour plot

Definition at line 104 of file PETScMatrix.cpp.

{
    PetscViewer viewer;
    PetscViewerASCIIOpen(PETSC_COMM_WORLD, file_name.c_str(), &viewer);
    PetscViewerPushFormat(viewer, vw_format);
 
    finalizeAssembly();
 
    PetscObjectSetName((PetscObject)A_, "Stiffness_matrix");
    MatView(A_, viewer);
 
// This preprocessor is only for debugging, e.g. dump the matrix and exit the
// program.
// #define EXIT_TEST
#ifdef EXIT_TEST
    MatDestroy(A_);
    PetscFinalize();
    exit(0);
#endif
}

References A_, finalizeAssembly(), and viewer().

Referenced by viewer().

Friends And Related Symbol Documentation

finalizeMatrixAssembly

bool finalizeMatrixAssembly ( PETScMatrix & mat, const MatAssemblyType asm_type = MAT_FINAL_ASSEMBLY )

friend

General interface for the matrix assembly.

Parameters

mat	The matrix to be finalized.
asm_type	Assembly type, either MAT_FLUSH_ASSEMBLY or MAT_FINAL_ASSEMBLY.

Definition at line 221 of file PETScMatrix.cpp.

{
    mat.finalizeAssembly(asm_type);
    return true;
}

References PETScMatrix(), and finalizeAssembly().

Member Data Documentation

A_

Mat MathLib::PETScMatrix::A_ = nullptr

private

PETSc matrix.

Definition at line 235 of file PETScMatrix.h.

Referenced by PETScMatrix(), add(), add(), addToDiagonal(), create(), destroy(), finalizeAssembly(), getRawMatrix(), getRawMatrix(), operator=(), preallocateFromSparsityPattern(), set(), setRowsColumnsZero(), setZero(), and viewer().

end_rank_

PetscInt MathLib::PETScMatrix::end_rank_

private

Ending index in a rank.

Definition at line 253 of file PETScMatrix.h.

Referenced by PETScMatrix(), create(), getRangeEnd(), and operator=().

n_loc_cols_

PetscInt MathLib::PETScMatrix::n_loc_cols_

private

Number of the local columns.

Definition at line 247 of file PETScMatrix.h.

Referenced by PETScMatrix(), PETScMatrix(), PETScMatrix(), create(), getNumberOfLocalColumns(), operator=(), and preallocateFromSparsityPattern().

n_loc_rows_

PetscInt MathLib::PETScMatrix::n_loc_rows_

private

Number of the local rows.

Definition at line 244 of file PETScMatrix.h.

Referenced by PETScMatrix(), PETScMatrix(), PETScMatrix(), create(), getNumberOfLocalRows(), operator=(), and preallocateFromSparsityPattern().

ncols_

PetscInt MathLib::PETScMatrix::ncols_

private

Number of the global columns.

Definition at line 241 of file PETScMatrix.h.

Referenced by PETScMatrix(), PETScMatrix(), PETScMatrix(), add(), create(), getNumberOfColumns(), operator=(), and preallocateFromSparsityPattern().

nrows_

PetscInt MathLib::PETScMatrix::nrows_

private

Number of the global rows.

Definition at line 238 of file PETScMatrix.h.

Referenced by PETScMatrix(), PETScMatrix(), PETScMatrix(), create(), getNumberOfRows(), operator=(), and preallocateFromSparsityPattern().

sparsity_col_idx_

std::vector<PetscInt> MathLib::PETScMatrix::sparsity_col_idx_

private

Column indices from preallocation (empty when fallback path was used).

Definition at line 256 of file PETScMatrix.h.

Referenced by PETScMatrix(), getSparsityColumnIndices(), operator=(), and preallocateFromSparsityPattern().

start_rank_

PetscInt MathLib::PETScMatrix::start_rank_

private

Starting index in a rank.

Definition at line 250 of file PETScMatrix.h.

Referenced by PETScMatrix(), create(), getRangeBegin(), and operator=().

---

The documentation for this class was generated from the following files:

• PETScMatrix.h
• PETScMatrix.cpp