#include <deal.II/lac/petsc_matrix_base.h>

Inheritance diagram for PETScWrappers::MatrixBase:

Public Types
typedef MatrixIterators::const_iterator	const_iterator

typedef types::global_dof_index	size_type

typedef PetscScalar	value_type

Public Member Functions
	MatrixBase ()

virtual	~MatrixBase ()

MatrixBase &	operator= (const value_type d)

void	clear ()

void	set (const size_type i, const size_type j, const PetscScalar value)

void	set (const std::vector< size_type > &indices, const FullMatrix< PetscScalar > &full_matrix, const bool elide_zero_values=false)

void	set (const std::vector< size_type > &row_indices, const std::vector< size_type > &col_indices, const FullMatrix< PetscScalar > &full_matrix, const bool elide_zero_values=false)

void	set (const size_type row, const std::vector< size_type > &col_indices, const std::vector< PetscScalar > &values, const bool elide_zero_values=false)

void	set (const size_type row, const size_type n_cols, const size_type col_indices, const PetscScalar values, const bool elide_zero_values=false)

void	add (const size_type i, const size_type j, const PetscScalar value)

void	add (const std::vector< size_type > &indices, const FullMatrix< PetscScalar > &full_matrix, const bool elide_zero_values=true)

void	add (const std::vector< size_type > &row_indices, const std::vector< size_type > &col_indices, const FullMatrix< PetscScalar > &full_matrix, const bool elide_zero_values=true)

void	add (const size_type row, const std::vector< size_type > &col_indices, const std::vector< PetscScalar > &values, const bool elide_zero_values=true)

void	add (const size_type row, const size_type n_cols, const size_type col_indices, const PetscScalar values, const bool elide_zero_values=true, const bool col_indices_are_sorted=false)

void	clear_row (const size_type row, const PetscScalar new_diag_value=0)

void	clear_rows (const std::vector< size_type > &rows, const PetscScalar new_diag_value=0)

void	compress (const VectorOperation::values operation)

PetscScalar	operator() (const size_type i, const size_type j) const

PetscScalar	el (const size_type i, const size_type j) const

PetscScalar	diag_element (const size_type i) const

size_type	m () const

size_type	n () const

size_type	local_size () const

std::pair< size_type, size_type >	local_range () const

bool	in_local_range (const size_type index) const

virtual const MPI_Comm &	get_mpi_communicator () const =0

size_type	n_nonzero_elements () const

size_type	row_length (const size_type row) const

PetscReal	l1_norm () const

PetscReal	linfty_norm () const

PetscReal	frobenius_norm () const

PetscScalar	matrix_norm_square (const VectorBase &v) const

PetscScalar	matrix_scalar_product (const VectorBase &u, const VectorBase &v) const

MatrixBase &	operator*= (const PetscScalar factor)

MatrixBase &	operator/= (const PetscScalar factor)

MatrixBase &	add (const PetscScalar factor, const MatrixBase &other)

MatrixBase &	add (const MatrixBase &other, const PetscScalar factor) 1

void	vmult (VectorBase &dst, const VectorBase &src) const

void	Tvmult (VectorBase &dst, const VectorBase &src) const

void	vmult_add (VectorBase &dst, const VectorBase &src) const

void	Tvmult_add (VectorBase &dst, const VectorBase &src) const

PetscScalar	residual (VectorBase &dst, const VectorBase &x, const VectorBase &b) const

const_iterator	begin () const

const_iterator	end () const

const_iterator	begin (const size_type r) const

const_iterator	end (const size_type r) const

	operator Mat () const

void	transpose ()

PetscBooleanType	is_symmetric (const double tolerance=1.e-12)

PetscBooleanType	is_hermitian (const double tolerance=1.e-12)

void	write_ascii (const PetscViewerFormat format=PETSC_VIEWER_DEFAULT)

void	print (std::ostream &out, const bool alternative_output=false) const

std::size_t	memory_consumption () const

Public Member Functions inherited from Subscriptor
	Subscriptor ()

	Subscriptor (const Subscriptor &)

	Subscriptor (Subscriptor &&)

virtual	~Subscriptor ()

Subscriptor &	operator= (const Subscriptor &)

Subscriptor &	operator= (Subscriptor &&)

void	subscribe (const char *identifier=0) const

void	unsubscribe (const char *identifier=0) const

unsigned int	n_subscriptions () const

void	list_subscribers () const

template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Static Public Member Functions
static ::ExceptionBase &	ExcSourceEqualsDestination ()

static ::ExceptionBase &	ExcWrongMode (int arg1, int arg2)

Static Public Member Functions inherited from Subscriptor
static ::ExceptionBase &	ExcInUse (int arg1, char *arg2, std::string &arg3)

static ::ExceptionBase &	ExcNoSubscriber (char arg1, char arg2)

Protected Member Functions
void	prepare_action (const VectorOperation::values new_action)

void	assert_is_compressed ()

void	prepare_add ()

void	prepare_set ()

Protected Attributes
Mat	matrix

VectorOperation::values	last_action

Private Member Functions
	MatrixBase (const MatrixBase &)

MatrixBase &	operator= (const MatrixBase &)

Private Attributes
std::vector< PetscInt >	column_indices

std::vector< PetscScalar >	column_values

Friends
template<class >
class	::BlockMatrixBase

Detailed Description

Base class for all matrix classes that are implemented on top of the PETSc matrix types. Since in PETSc all matrix types (i.e. sequential and parallel, sparse, blocked, etc.) are built by filling the contents of an abstract object that is only referenced through a pointer of a type that is independent of the actual matrix type, we can implement almost all functionality of matrices in this base class. Derived classes will then only have to provide the functionality to create one or the other kind of matrix.

The interface of this class is modeled after the existing SparseMatrix class in deal.II. It has almost the same member functions, and is often exchangeable. However, since PETSc only supports a single scalar type (either double, float, or a complex data type), it is not templated, and only works with whatever your PETSc installation has defined the data type PetscScalar to.

Note that PETSc only guarantees that operations do what you expect if the functions MatAssemblyBegin and MatAssemblyEnd have been called after matrix assembly. Therefore, you need to call SparseMatrix::compress() before you actually use the matrix. This also calls MatCompress that compresses the storage format for sparse matrices by discarding unused elements. PETSc allows to continue with assembling the matrix after calls to these functions, but since there are no more free entries available after that any more, it is better to only call SparseMatrix::compress() once at the end of the assembly stage and before the matrix is actively used.

Author: Wolfgang Bangerth, 2004

Definition at line 269 of file petsc_matrix_base.h.

Member Typedef Documentation

◆ const_iterator

typedef MatrixIterators::const_iterator PETScWrappers::MatrixBase::const_iterator

Declare a typedef for the iterator class.

Definition at line 275 of file petsc_matrix_base.h.

◆ size_type

typedef types::global_dof_index PETScWrappers::MatrixBase::size_type

Declare type for container size.

Definition at line 280 of file petsc_matrix_base.h.

◆ value_type

typedef PetscScalar PETScWrappers::MatrixBase::value_type

Declare a typedef in analogy to all the other container classes.

Definition at line 285 of file petsc_matrix_base.h.

Constructor & Destructor Documentation

◆ MatrixBase() [1/2]

PETScWrappers::MatrixBase::MatrixBase ( )

Default constructor.

Definition at line 76 of file petsc_matrix_base.cc.

◆ ~MatrixBase()

PETScWrappers::MatrixBase::~MatrixBase ( )

virtual

Destructor. Made virtual so that one can use pointers to this class.

Definition at line 84 of file petsc_matrix_base.cc.

◆ MatrixBase() [2/2]

PETScWrappers::MatrixBase::MatrixBase ( const MatrixBase & )

private

purposefully not implemented

Member Function Documentation

◆ operator=() [1/2]

MatrixBase & PETScWrappers::MatrixBase::operator= ( const value_type d )

This operator assigns a scalar to a matrix. Since this does usually not make much sense (should we set all matrix entries to this value? Only the nonzero entries of the sparsity pattern?), this operation is only allowed if the actual value to be assigned is zero. This operator only exists to allow for the obvious notation matrix=0, which sets all elements of the matrix to zero, but keeps the sparsity pattern previously used.

Definition at line 112 of file petsc_matrix_base.cc.

◆ clear()

void PETScWrappers::MatrixBase::clear ( )

Release all memory and return to a state just like after having called the default constructor.

Definition at line 92 of file petsc_matrix_base.cc.

◆ set() [1/5]

void PETScWrappers::MatrixBase::set	(	const size_type	i,
		const size_type	j,
		const PetscScalar	value
	)

Set the element (i,j) to value.

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds a new entry to the matrix if it didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist. If value is not a finite number an exception is thrown.

◆ set() [2/5]

void PETScWrappers::MatrixBase::set	(	const std::vector< size_type > &	indices,
		const FullMatrix< PetscScalar > &	full_matrix,
		const bool	elide_zero_values = `false`
	)

Set all elements given in a FullMatrix<double> into the sparse matrix locations given by indices. In other words, this function writes the elements in full_matrix into the calling matrix, using the local-to-global indexing specified by indices for both the rows and the columns of the matrix. This function assumes a quadratic sparse matrix and a quadratic full_matrix, the usual situation in FE calculations.

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds some new entries to the matrix if they didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist.

The optional parameter elide_zero_values can be used to specify whether zero values should be inserted anyway or they should be filtered away. The default value is false, i.e., even zero values are inserted/replaced.

◆ set() [3/5]

void PETScWrappers::MatrixBase::set	(	const std::vector< size_type > &	row_indices,
		const std::vector< size_type > &	col_indices,
		const FullMatrix< PetscScalar > &	full_matrix,
		const bool	elide_zero_values = `false`
	)

Same function as before, but now including the possibility to use rectangular full_matrices and different local-to-global indexing on rows and columns, respectively.

◆ set() [4/5]

void PETScWrappers::MatrixBase::set	(	const size_type	row,
		const std::vector< size_type > &	col_indices,
		const std::vector< PetscScalar > &	values,
		const bool	elide_zero_values = `false`
	)

Set several elements in the specified row of the matrix with column indices as given by col_indices to the respective value.

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds some new entries to the matrix if they didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist.

The optional parameter elide_zero_values can be used to specify whether zero values should be inserted anyway or they should be filtered away. The default value is false, i.e., even zero values are inserted/replaced.

◆ set() [5/5]

void PETScWrappers::MatrixBase::set	(	const size_type	row,
		const size_type	n_cols,
		const size_type *	col_indices,
		const PetscScalar *	values,
		const bool	elide_zero_values = `false`
	)

Set several elements to values given by values in a given row in columns given by col_indices into the sparse matrix.

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds some new entries to the matrix if they didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist.

The optional parameter elide_zero_values can be used to specify whether zero values should be inserted anyway or they should be filtered away. The default value is false, i.e., even zero values are inserted/replaced.

◆ add() [1/7]

void PETScWrappers::MatrixBase::add	(	const size_type	i,
		const size_type	j,
		const PetscScalar	value
	)

Add value to the element (i,j).

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds a new entry to the matrix if it didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist. If value is not a finite number an exception is thrown.

◆ add() [2/7]

void PETScWrappers::MatrixBase::add	(	const std::vector< size_type > &	indices,
		const FullMatrix< PetscScalar > &	full_matrix,
		const bool	elide_zero_values = `true`
	)

Add all elements given in a FullMatrix<double> into sparse matrix locations given by indices. In other words, this function adds the elements in full_matrix to the respective entries in calling matrix, using the local-to-global indexing specified by indices for both the rows and the columns of the matrix. This function assumes a quadratic sparse matrix and a quadratic full_matrix, the usual situation in FE calculations.

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds some new entries to the matrix if they didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist.

The optional parameter elide_zero_values can be used to specify whether zero values should be added anyway or these should be filtered away and only non-zero data is added. The default value is true, i.e., zero values won't be added into the matrix.

◆ add() [3/7]

void PETScWrappers::MatrixBase::add	(	const std::vector< size_type > &	row_indices,
		const std::vector< size_type > &	col_indices,
		const FullMatrix< PetscScalar > &	full_matrix,
		const bool	elide_zero_values = `true`
	)

Same function as before, but now including the possibility to use rectangular full_matrices and different local-to-global indexing on rows and columns, respectively.

◆ add() [4/7]

void PETScWrappers::MatrixBase::add	(	const size_type	row,
		const std::vector< size_type > &	col_indices,
		const std::vector< PetscScalar > &	values,
		const bool	elide_zero_values = `true`
	)

Set several elements in the specified row of the matrix with column indices as given by col_indices to the respective value.

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds some new entries to the matrix if they didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist.

The optional parameter elide_zero_values can be used to specify whether zero values should be added anyway or these should be filtered away and only non-zero data is added. The default value is true, i.e., zero values won't be added into the matrix.

◆ add() [5/7]

void PETScWrappers::MatrixBase::add	(	const size_type	row,
		const size_type	n_cols,
		const size_type *	col_indices,
		const PetscScalar *	values,
		const bool	elide_zero_values = `true`,
		const bool	col_indices_are_sorted = `false`
	)

Add an array of values given by values in the given global matrix row at columns specified by col_indices in the sparse matrix.

If the present object (from a derived class of this one) happens to be a sparse matrix, then this function adds some new entries to the matrix if they didn't exist before, very much in contrast to the SparseMatrix class which throws an error if the entry does not exist.

The optional parameter elide_zero_values can be used to specify whether zero values should be added anyway or these should be filtered away and only non-zero data is added. The default value is true, i.e., zero values won't be added into the matrix.

◆ clear_row()

void PETScWrappers::MatrixBase::clear_row	(	const size_type	row,
		const PetscScalar	new_diag_value = `0`
	)

Remove all elements from this row by setting them to zero. The function does not modify the number of allocated nonzero entries, it only sets some entries to zero. It may drop them from the sparsity pattern, though (but retains the allocated memory in case new entries are again added later).

This operation is used in eliminating constraints (e.g. due to hanging nodes) and makes sure that we can write this modification to the matrix without having to read entries (such as the locations of non-zero elements) from it – without this operation, removing constraints on parallel matrices is a rather complicated procedure.

The second parameter can be used to set the diagonal entry of this row to a value different from zero. The default is to set it to zero.

Definition at line 128 of file petsc_matrix_base.cc.

◆ clear_rows()

void PETScWrappers::MatrixBase::clear_rows	(	const std::vector< size_type > &	rows,
		const PetscScalar	new_diag_value = `0`
	)

Same as clear_row(), except that it works on a number of rows at once.

The second parameter can be used to set the diagonal entries of all cleared rows to something different from zero. Note that all of these diagonal entries get the same value – if you want different values for the diagonal entries, you have to set them by hand.

Definition at line 138 of file petsc_matrix_base.cc.

◆ compress()

void PETScWrappers::MatrixBase::compress ( const VectorOperation::values operation )

PETSc matrices store their own sparsity patterns. So, in analogy to our own SparsityPattern class, this function compresses the sparsity pattern and allows the resulting matrix to be used in all other operations where before only assembly functions were allowed. This function must therefore be called once you have assembled the matrix.

See Compressing distributed objects for more information.

Definition at line 207 of file petsc_matrix_base.cc.

◆ operator()()

PetscScalar PETScWrappers::MatrixBase::operator()	(	const size_type	i,
		const size_type	j
	)		const

Return the value of the entry (i,j). This may be an expensive operation and you should always take care where to call this function. In contrast to the respective function in the MatrixBase class, we don't throw an exception if the respective entry doesn't exist in the sparsity pattern of this class, since PETSc does not transmit this information.

This function is therefore exactly equivalent to the el() function.

◆ el()

PetscScalar PETScWrappers::MatrixBase::el	(	const size_type	i,
		const size_type	j
	)		const

Return the value of the matrix entry (i,j). If this entry does not exist in the sparsity pattern, then zero is returned. While this may be convenient in some cases, note that it is simple to write algorithms that are slow compared to an optimal solution, since the sparsity of the matrix is not used.

Definition at line 178 of file petsc_matrix_base.cc.

◆ diag_element()

PetscScalar PETScWrappers::MatrixBase::diag_element ( const size_type i ) const

Return the main diagonal element in the ith row. This function throws an error if the matrix is not quadratic.

Since we do not have direct access to the underlying data structure, this function is no faster than the elementwise access using the el() function. However, we provide this function for compatibility with the SparseMatrix class.

Definition at line 195 of file petsc_matrix_base.cc.

◆ m()

MatrixBase::size_type PETScWrappers::MatrixBase::m ( ) const

Return the number of rows in this matrix.

Definition at line 246 of file petsc_matrix_base.cc.

◆ n()

MatrixBase::size_type PETScWrappers::MatrixBase::n ( ) const

Return the number of columns in this matrix.

Definition at line 259 of file petsc_matrix_base.cc.

◆ local_size()

MatrixBase::size_type PETScWrappers::MatrixBase::local_size ( ) const

Return the local dimension of the matrix, i.e. the number of rows stored on the present MPI process. For sequential matrices, this number is the same as m(), but for parallel matrices it may be smaller.

To figure out which elements exactly are stored locally, use local_range().

Definition at line 272 of file petsc_matrix_base.cc.

◆ local_range()

std::pair< MatrixBase::size_type, MatrixBase::size_type > PETScWrappers::MatrixBase::local_range ( ) const

Return a pair of indices indicating which rows of this matrix are stored locally. The first number is the index of the first row stored, the second the index of the one past the last one that is stored locally. If this is a sequential matrix, then the result will be the pair (0,m()), otherwise it will be a pair (i,i+n), where n=local_size().

Definition at line 285 of file petsc_matrix_base.cc.

◆ in_local_range()

bool PETScWrappers::MatrixBase::in_local_range ( const size_type index ) const

Return whether index is in the local range or not, see also local_range().

◆ get_mpi_communicator()

virtual const MPI_Comm& PETScWrappers::MatrixBase::get_mpi_communicator ( ) const

pure virtual

Return a reference to the MPI communicator object in use with this matrix. This function has to be implemented in derived classes.

Implemented in PETScWrappers::MPI::SparseMatrix, PETScWrappers::SparseMatrix, PETScWrappers::MatrixFree, and PETScWrappers::FullMatrix.

◆ n_nonzero_elements()

MatrixBase::size_type PETScWrappers::MatrixBase::n_nonzero_elements ( ) const

Return the number of nonzero elements of this matrix. Actually, it returns the number of entries in the sparsity pattern; if any of the entries should happen to be zero, it is counted anyway.

Definition at line 299 of file petsc_matrix_base.cc.

◆ row_length()

MatrixBase::size_type PETScWrappers::MatrixBase::row_length ( const size_type row ) const

Number of entries in a specific row.

Definition at line 312 of file petsc_matrix_base.cc.

◆ l1_norm()

PetscReal PETScWrappers::MatrixBase::l1_norm ( ) const

Return the l1-norm of the matrix, that is \(|M|_1=max_{all columns j}\sum_{all rows i} |M_ij|\), (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. \(|Mv|_1\leq |M|_1 |v|_1\). (cf. Haemmerlin-Hoffmann: Numerische Mathematik)

Definition at line 347 of file petsc_matrix_base.cc.

◆ linfty_norm()

PetscReal PETScWrappers::MatrixBase::linfty_norm ( ) const

Return the linfty-norm of the matrix, that is \(|M|_infty=max_{all rows i}\sum_{all columns j} |M_ij|\), (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. \(|Mv|_infty \leq |M|_infty |v|_infty\). (cf. Haemmerlin-Hoffmann: Numerische Mathematik)

Definition at line 360 of file petsc_matrix_base.cc.

◆ frobenius_norm()

PetscReal PETScWrappers::MatrixBase::frobenius_norm ( ) const

Return the frobenius norm of the matrix, i.e. the square root of the sum of squares of all entries in the matrix.

Definition at line 373 of file petsc_matrix_base.cc.

◆ matrix_norm_square()

PetscScalar PETScWrappers::MatrixBase::matrix_norm_square ( const VectorBase & v ) const

Return the square of the norm of the vector \(v\) with respect to the norm induced by this matrix, i.e. \(\left(v,Mv\right)\). This is useful, e.g. in the finite element context, where the \(L_2\) norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.

Obviously, the matrix needs to be quadratic for this operation.

The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.

Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then the given vector has to be a distributed vector as well. Conversely, if the matrix is not distributed, then neither may the vector be.

Definition at line 385 of file petsc_matrix_base.cc.

◆ matrix_scalar_product()

PetscScalar PETScWrappers::MatrixBase::matrix_scalar_product	(	const VectorBase &	u,
		const VectorBase &	v
	)		const

Compute the matrix scalar product \(\left(u,Mv\right)\).

The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.

Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then both vectors have to be distributed vectors as well. Conversely, if the matrix is not distributed, then neither of the vectors may be.

Definition at line 394 of file petsc_matrix_base.cc.

◆ operator*=()

MatrixBase & PETScWrappers::MatrixBase::operator*= ( const PetscScalar factor )

Multiply the entire matrix by a fixed factor.

Definition at line 419 of file petsc_matrix_base.cc.

◆ operator/=()

MatrixBase & PETScWrappers::MatrixBase::operator/= ( const PetscScalar factor )

Divide the entire matrix by a fixed factor.

Definition at line 430 of file petsc_matrix_base.cc.

◆ add() [6/7]

MatrixBase & PETScWrappers::MatrixBase::add	(	const PetscScalar	factor,
		const MatrixBase &	other
	)

Add the matrix other scaled by the factor factor to the current matrix.

Definition at line 441 of file petsc_matrix_base.cc.

◆ add() [7/7]

MatrixBase & PETScWrappers::MatrixBase::add	(	const MatrixBase &	other,
		const PetscScalar	factor
	)

Add the matrix other scaled by the factor factor to the current matrix.

Deprecated:: Use the function with order of arguments reversed instead.

Definition at line 454 of file petsc_matrix_base.cc.

◆ vmult()

void PETScWrappers::MatrixBase::vmult	(	VectorBase &	dst,
		const VectorBase &	src
	)		const

Matrix-vector multiplication: let dst = M*src with M being this matrix.

Source and destination must not be the same vector.

Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then both vectors have to be distributed vectors as well. Conversely, if the matrix is not distributed, then neither of the vectors may be.

Definition at line 462 of file petsc_matrix_base.cc.

◆ Tvmult()

void PETScWrappers::MatrixBase::Tvmult	(	VectorBase &	dst,
		const VectorBase &	src
	)		const

Matrix-vector multiplication: let dst = M^T*src with M being this matrix. This function does the same as vmult() but takes the transposed matrix.

Source and destination must not be the same vector.

Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then both vectors have to be distributed vectors as well. Conversely, if the matrix is not distributed, then neither of the vectors may be.

Definition at line 474 of file petsc_matrix_base.cc.

◆ vmult_add()

void PETScWrappers::MatrixBase::vmult_add	(	VectorBase &	dst,
		const VectorBase &	src
	)		const

Adding Matrix-vector multiplication. Add M*src on dst with M being this matrix.

Source and destination must not be the same vector.

Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then both vectors have to be distributed vectors as well. Conversely, if the matrix is not distributed, then neither of the vectors may be.

Definition at line 486 of file petsc_matrix_base.cc.

◆ Tvmult_add()

void PETScWrappers::MatrixBase::Tvmult_add	(	VectorBase &	dst,
		const VectorBase &	src
	)		const

Adding Matrix-vector multiplication. Add M^T*src to dst with M being this matrix. This function does the same as vmult_add() but takes the transposed matrix.

Source and destination must not be the same vector.

Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then both vectors have to be distributed vectors as well. Conversely, if the matrix is not distributed, then neither of the vectors may be.

Definition at line 498 of file petsc_matrix_base.cc.

◆ residual()

PetscScalar PETScWrappers::MatrixBase::residual	(	VectorBase &	dst,
		const VectorBase &	x,
		const VectorBase &	b
	)		const

Compute the residual of an equation Mx=b, where the residual is defined to be r=b-Mx. Write the residual into dst. The l₂ norm of the residual vector is returned.

Source x and destination dst must not be the same vector.

Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then all vectors have to be distributed vectors as well. Conversely, if the matrix is not distributed, then neither of the vectors may be.

Definition at line 509 of file petsc_matrix_base.cc.

◆ begin() [1/2]

const_iterator PETScWrappers::MatrixBase::begin ( ) const

Iterator starting at the first entry.

◆ end() [1/2]

const_iterator PETScWrappers::MatrixBase::end ( ) const

Final iterator.

◆ begin() [2/2]

const_iterator PETScWrappers::MatrixBase::begin ( const size_type r ) const

Iterator starting at the first entry of row r.

Note that if the given row is empty, i.e. does not contain any nonzero entries, then the iterator returned by this function equals end(r). Note also that the iterator may not be dereferencable in that case.

◆ end() [2/2]

const_iterator PETScWrappers::MatrixBase::end ( const size_type r ) const

Final iterator of row r. It points to the first element past the end of line r, or past the end of the entire sparsity pattern.

Note that the end iterator is not necessarily dereferencable. This is in particular the case if it is the end iterator for the last row of a matrix.

◆ operator Mat()

PETScWrappers::MatrixBase::operator Mat ( ) const

Conversion operator to gain access to the underlying PETSc type. If you do this, you cut this class off some information it may need, so this conversion operator should only be used if you know what you do. In particular, it should only be used for read-only operations into the matrix.

Definition at line 525 of file petsc_matrix_base.cc.

◆ transpose()

void PETScWrappers::MatrixBase::transpose ( )

Make an in-place transpose of a matrix.

Definition at line 531 of file petsc_matrix_base.cc.

◆ is_symmetric()

PetscBooleanType PETScWrappers::MatrixBase::is_symmetric ( const double tolerance = 1.e-12 )

Test whether a matrix is symmetric. Default tolerance is \(1000\times32\)-bit machine precision.

Definition at line 538 of file petsc_matrix_base.cc.

◆ is_hermitian()

PetscBooleanType PETScWrappers::MatrixBase::is_hermitian ( const double tolerance = 1.e-12 )

Test whether a matrix is Hermitian, i.e. it is the complex conjugate of its transpose. Default tolerance is \(1000\times32\)-bit machine precision.

Definition at line 548 of file petsc_matrix_base.cc.

◆ write_ascii()

void PETScWrappers::MatrixBase::write_ascii ( const PetscViewerFormat format = PETSC_VIEWER_DEFAULT )

Print the PETSc matrix object values using PETSc internal matrix viewer function MatView. The default format prints the non- zero matrix elements. For other valid view formats, consult http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MatView.html

Definition at line 560 of file petsc_matrix_base.cc.

◆ print()

void PETScWrappers::MatrixBase::print	(	std::ostream &	out,
		const bool	alternative_output = `false`
	)		const

Print the elements of a matrix to the given output stream.

Parameters

[in,out]	out	The output stream to which to write.
[in]	alternative_output	This argument is ignored. It exists for compatibility with similar functions in other matrix classes.

Definition at line 575 of file petsc_matrix_base.cc.

◆ memory_consumption()

std::size_t PETScWrappers::MatrixBase::memory_consumption ( ) const

Return the number bytes consumed by this matrix on this CPU.

Definition at line 606 of file petsc_matrix_base.cc.

◆ prepare_action()

void PETScWrappers::MatrixBase::prepare_action ( const VectorOperation::values new_action )

protected

Ensure that the add/set mode that is required for actions following this call is compatible with the current mode. Should be called from all internal functions accessing matrix elements.

◆ assert_is_compressed()

void PETScWrappers::MatrixBase::assert_is_compressed ( )

protected

Internal function that checks that there are no pending insert/add operations. Throws an exception otherwise. Useful before calling any PETSc internal functions modifying the matrix.

◆ prepare_add()

void PETScWrappers::MatrixBase::prepare_add ( )

protected

For some matrix storage formats, in particular for the PETSc distributed blockmatrices, set and add operations on individual elements can not be freely mixed. Rather, one has to synchronize operations when one wants to switch from setting elements to adding to elements. BlockMatrixBase automatically synchronizes the access by calling this helper function for each block. This function ensures that the matrix is in a state that allows adding elements; if it previously already was in this state, the function does nothing.

◆ prepare_set()

void PETScWrappers::MatrixBase::prepare_set ( )

protected

Same as prepare_add() but prepare the matrix for setting elements if the representation of elements in this class requires such an operation.

◆ operator=() [2/2]

MatrixBase& PETScWrappers::MatrixBase::operator= ( const MatrixBase & )

private

purposefully not implemented

Friends And Related Function Documentation

◆ ::BlockMatrixBase

template<class >

friend class ::BlockMatrixBase

friend

To allow calling protected prepare_add() and prepare_set().

Definition at line 971 of file petsc_matrix_base.h.

Member Data Documentation

◆ matrix

Mat PETScWrappers::MatrixBase::matrix

protected

A generic matrix object in PETSc. The actual type, a sparse matrix, is set in the constructor.

Definition at line 901 of file petsc_matrix_base.h.

◆ last_action

VectorOperation::values PETScWrappers::MatrixBase::last_action

protected

Store whether the last action was a write or add operation.

Definition at line 906 of file petsc_matrix_base.h.

◆ column_indices

std::vector<PetscInt> PETScWrappers::MatrixBase::column_indices

private

An internal array of integer values that is used to store the column indices when adding/inserting local data into the (large) sparse matrix.

Definition at line 958 of file petsc_matrix_base.h.

◆ column_values

std::vector<PetscScalar> PETScWrappers::MatrixBase::column_values

private

An internal array of double values that is used to store the column indices when adding/inserting local data into the (large) sparse matrix.

Definition at line 965 of file petsc_matrix_base.h.

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

deal.II/lac/petsc_matrix_base.h
source/lac/petsc_matrix_base.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ MatrixBase() [1/2]

◆ ~MatrixBase()

◆ MatrixBase() [2/2]

Member Function Documentation

◆ operator=() [1/2]

◆ clear()

◆ set() [1/5]

◆ set() [2/5]

◆ set() [3/5]

◆ set() [4/5]

◆ set() [5/5]

◆ add() [1/7]

◆ add() [2/7]

◆ add() [3/7]

◆ add() [4/7]

◆ add() [5/7]

◆ clear_row()

◆ clear_rows()

◆ compress()

◆ operator()()

◆ el()

◆ diag_element()

◆ m()

◆ n()

◆ local_size()

◆ local_range()

◆ in_local_range()

◆ get_mpi_communicator()

◆ n_nonzero_elements()

◆ row_length()

◆ l1_norm()

◆ linfty_norm()

◆ frobenius_norm()

◆ matrix_norm_square()

◆ matrix_scalar_product()

◆ operator*=()

◆ operator/=()

◆ add() [6/7]

◆ add() [7/7]

◆ vmult()

◆ Tvmult()

◆ vmult_add()

◆ Tvmult_add()

◆ residual()

◆ begin() [1/2]

◆ end() [1/2]

◆ begin() [2/2]

◆ end() [2/2]

◆ operator Mat()

◆ transpose()

◆ is_symmetric()

◆ is_hermitian()

◆ write_ascii()

◆ print()

◆ memory_consumption()

◆ prepare_action()

◆ assert_is_compressed()

◆ prepare_add()

◆ prepare_set()

◆ operator=() [2/2]

Friends And Related Function Documentation

◆ ::BlockMatrixBase

Member Data Documentation

◆ matrix

◆ last_action

◆ column_indices