#include <eigen_sparse_matrix.h>

Inheritance diagram for libMesh::EigenSparseMatrix< T >:

[legend]

Public Types
typedef EigenSM	DataType

typedef Eigen::Triplet< T, eigen_idx_type >	TripletType

Public Member Functions
	EigenSparseMatrix (const Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)

	~EigenSparseMatrix ()

virtual void	init (const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1) libmesh_override

virtual void	init () libmesh_override

virtual void	clear () libmesh_override

virtual void	zero () libmesh_override

virtual void	close () libmesh_override

virtual numeric_index_type	m () const libmesh_override

virtual numeric_index_type	n () const libmesh_override

virtual numeric_index_type	row_start () const libmesh_override

virtual numeric_index_type	row_stop () const libmesh_override

virtual void	set (const numeric_index_type i, const numeric_index_type j, const T value) libmesh_override

virtual void	add (const numeric_index_type i, const numeric_index_type j, const T value) libmesh_override

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) libmesh_override

virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) libmesh_override

virtual void	add (const T a, SparseMatrix< T > &X) libmesh_override

virtual T	operator() (const numeric_index_type i, const numeric_index_type j) const libmesh_override

virtual Real	l1_norm () const libmesh_override

virtual Real	linfty_norm () const libmesh_override

virtual bool	closed () const libmesh_override

virtual void	print_personal (std::ostream &os=libMesh::out) const libmesh_override

virtual void	get_diagonal (NumericVector< T > &dest) const libmesh_override

virtual void	get_transpose (SparseMatrix< T > &dest) const libmesh_override

virtual bool	initialized () const

void	attach_dof_map (const DofMap &dof_map)

virtual bool	need_full_sparsity_pattern () const

virtual void	update_sparsity_pattern (const SparsityPattern::Graph &)

virtual void	zero_rows (std::vector< numeric_index_type > &rows, T diag_value=0.0)

virtual void	flush ()

virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols)

virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices)

void	print (std::ostream &os=libMesh::out, const bool sparse=false) const

template<>
void	print (std::ostream &os, const bool sparse) const

virtual void	print_matlab (const std::string &="") const

virtual void	create_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const

virtual void	reinit_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const

void	vector_mult (NumericVector< T > &dest, const NumericVector< T > &arg) const

void	vector_mult_add (NumericVector< T > &dest, const NumericVector< T > &arg) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< SparseMatrix< T > >	build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())

static std::string	get_info ()

static void	print_info (std::ostream &out=libMesh::out)

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts

Protected Member Functions
virtual void	_get_submatrix (SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const

void	increment_constructor_count (const std::string &name)

void	increment_destructor_count (const std::string &name)

Protected Attributes
DofMap const *	_dof_map

bool	_is_initialized

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter = true

Private Attributes
DataType	_mat

bool	_closed

Friends
class	EigenSparseVector< T >

class	EigenSparseLinearSolver< T >

Detailed Description

template<typename T>
class libMesh::EigenSparseMatrix< T >

The EigenSparseMatrix class wraps a sparse matrix object from the Eigen library. All overridden virtual functions are documented in sparse_matrix.h.

Author: Benjamin S. Kirk

Date: 2013

Definition at line 54 of file eigen_sparse_matrix.h.

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information. The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

template<typename T>

typedef EigenSM libMesh::EigenSparseMatrix< T >::DataType

Convenient typedefs

Definition at line 80 of file eigen_sparse_matrix.h.

template<typename T>

typedef Eigen::Triplet<T,eigen_idx_type> libMesh::EigenSparseMatrix< T >::TripletType

Definition at line 81 of file eigen_sparse_matrix.h.

Constructor & Destructor Documentation

template<typename T>

libMesh::EigenSparseMatrix< T >::EigenSparseMatrix ( const Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD )

Constructor; initializes the matrix to be empty, without any structure, i.e. the matrix is not usable at all. This constructor is therefore only useful for matrices which are members of a class. All other matrices should be created at a point in the data flow where all necessary information is available.

You have to initialize the matrix before usage with init(...).

Definition at line 161 of file eigen_sparse_matrix.C.

                                                                              :
   SparseMatrix<T>(comm_in),
   _closed (false)
 {
 }

template<typename T >

libMesh::EigenSparseMatrix< T >::~EigenSparseMatrix ( )

Destructor. Free all memory, but do not release the memory of the sparsity structure.

Definition at line 170 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::clear().

 {
   this->clear ();
 }

Member Function Documentation

template<typename T>

virtual void libMesh::SparseMatrix< T >::_get_submatrix	(	SparseMatrix< T > &	,
		const std::vector< numeric_index_type > &	,
		const std::vector< numeric_index_type > &	,
		const bool
	)		const

inlineprotectedvirtualinherited

Protected implementation of the create_submatrix and reinit_submatrix routines.

Note: This function must be overridden in derived classes for it to work properly!

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 411 of file sparse_matrix.h.

   {
     libmesh_not_implemented();
   }

template<typename T >

void libMesh::EigenSparseMatrix< T >::add	(	const numeric_index_type	i,
		const numeric_index_type	j,
		const T	value
	)

virtual

Add value to the element (i,j). Throws an error if the entry does not exist. Zero values can be "added" to non-existent entries.

Implements libMesh::SparseMatrix< T >.

Definition at line 247 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, libMesh::SparseMatrix< T >::initialized(), libMesh::EigenSparseMatrix< T >::m(), libMesh::EigenSparseMatrix< T >::n(), and value.

Referenced by libMesh::EigenSparseMatrix< T >::close().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->m());
   libmesh_assert_less (j, this->n());
 
   _mat.coeffRef(i,j) += value;
 }

template<typename T >

void libMesh::EigenSparseMatrix< T >::add	(	const T	a,
		SparseMatrix< T > &	X
	)

virtual

Compute $A \leftarrow A + a*X$ for scalar a, matrix X.

Implements libMesh::SparseMatrix< T >.

Definition at line 270 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, libMesh::SparseMatrix< T >::initialized(), libMesh::EigenSparseMatrix< T >::m(), libMesh::SparseMatrix< T >::m(), libMesh::EigenSparseMatrix< T >::n(), and libMesh::SparseMatrix< T >::n().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_equal_to (this->m(), X_in.m());
   libmesh_assert_equal_to (this->n(), X_in.n());
 
   EigenSparseMatrix<T> & X = cast_ref<EigenSparseMatrix<T> &> (X_in);
 
   _mat += X._mat*a_in;
 }

template<typename T>

void libMesh::SparseMatrix< T >::add_block_matrix	(	const DenseMatrix< T > &	dm,
		const std::vector< numeric_index_type > &	brows,
		const std::vector< numeric_index_type > &	bcols
	)

virtualinherited

Add the full matrix dm to the SparseMatrix. This is useful for adding an element matrix at assembly time. The matrix is assumed blocked, and brow, bcol correspond to the block row and column indices.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 62 of file sparse_matrix.C.

References libMesh::SparseMatrix< T >::add_matrix(), libMesh::DenseMatrixBase< T >::m(), and libMesh::DenseMatrixBase< T >::n().

 {
   libmesh_assert_equal_to (dm.m() / brows.size(), dm.n() / bcols.size());
 
   const numeric_index_type blocksize = cast_int<numeric_index_type>
     (dm.m() / brows.size());
 
   libmesh_assert_equal_to (dm.m()%blocksize, 0);
   libmesh_assert_equal_to (dm.n()%blocksize, 0);
 
   std::vector<numeric_index_type> rows, cols;
 
   rows.reserve(blocksize*brows.size());
   cols.reserve(blocksize*bcols.size());
 
   for (std::size_t ib=0; ib<brows.size(); ib++)
     {
       numeric_index_type i=brows[ib]*blocksize;
 
       for (unsigned int v=0; v<blocksize; v++)
         rows.push_back(i++);
     }
 
   for (std::size_t jb=0; jb<bcols.size(); jb++)
     {
       numeric_index_type j=bcols[jb]*blocksize;
 
       for (unsigned int v=0; v<blocksize; v++)
         cols.push_back(j++);
     }
 
   this->add_matrix (dm, rows, cols);
 }

template<typename T>

virtual void libMesh::SparseMatrix< T >::add_block_matrix	(	const DenseMatrix< T > &	dm,
		const std::vector< numeric_index_type > &	dof_indices
	)

inlinevirtualinherited

Same as add_block_matrix(), but assumes the row and column maps are the same. Thus the matrix dm must be square.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 250 of file sparse_matrix.h.

252 { this->add_block_matrix (dm, dof_indices, dof_indices); }

libMesh::SparseMatrix::add_block_matrix

virtual void add_block_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols)

Definition: sparse_matrix.C:62

template<typename T >

void libMesh::EigenSparseMatrix< T >::add_matrix	(	const DenseMatrix< T > &	dm,
		const std::vector< numeric_index_type > &	rows,
		const std::vector< numeric_index_type > &	cols
	)

virtual

Add the full matrix dm to the SparseMatrix. This is useful for adding an element matrix at assembly time.

Implements libMesh::SparseMatrix< T >.

Definition at line 121 of file eigen_sparse_matrix.C.

References libMesh::initialized(), libMesh::DenseMatrixBase< T >::m(), and libMesh::DenseMatrixBase< T >::n().

Referenced by libMesh::EigenSparseMatrix< T >::add_matrix(), and libMesh::EigenSparseMatrix< T >::close().

 {
   libmesh_assert (this->initialized());
   unsigned int n_rows = cast_int<unsigned int>(rows.size());
   unsigned int n_cols = cast_int<unsigned int>(cols.size());
   libmesh_assert_equal_to (dm.m(), n_rows);
   libmesh_assert_equal_to (dm.n(), n_cols);
 
 
   for (unsigned int i=0; i<n_rows; i++)
     for (unsigned int j=0; j<n_cols; j++)
       this->add(rows[i],cols[j],dm(i,j));
 }

template<typename T >

void libMesh::EigenSparseMatrix< T >::add_matrix	(	const DenseMatrix< T > &	dm,
		const std::vector< numeric_index_type > &	dof_indices
	)

virtual

Same as add_matrix, but assumes the row and column maps are the same. Thus the matrix dm must be square.

Implements libMesh::SparseMatrix< T >.

Definition at line 261 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::add_matrix().

 {
   this->add_matrix (dm, dof_indices, dof_indices);
 }

template<typename T>

void libMesh::SparseMatrix< T >::attach_dof_map ( const DofMap & dof_map )

inlineinherited

Get a pointer to the DofMap to use.

Definition at line 106 of file sparse_matrix.h.

Referenced by libMesh::__libmesh_tao_hessian(), and libMesh::DofMap::attach_matrix().

107 { _dof_map = &dof_map; }

libMesh::SparseMatrix::_dof_map

DofMap const * _dof_map

Definition: sparse_matrix.h:422

template<typename T >

std::unique_ptr< SparseMatrix< T > > libMesh::SparseMatrix< T >::build	(	const Parallel::Communicator &	comm,
		const SolverPackage	solver_package = `libMesh::default_solver_package()`
	)

staticinherited

Builds a SparseMatrix<T> using the linear solver package specified by solver_package

Definition at line 136 of file sparse_matrix.C.

References libMesh::ParallelObject::comm(), libMesh::EIGEN_SOLVERS, libMesh::LASPACK_SOLVERS, libMesh::libmesh_ignore(), libMesh::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

Referenced by libMesh::ImplicitSystem::add_matrix(), libMesh::EigenSystem::init_data(), and libMesh::EigenSystem::init_matrices().

 {
   // Avoid unused parameter warnings when no solver packages are enabled.
   libmesh_ignore(comm);
 
   // Build the appropriate vector
   switch (solver_package)
     {
 
 #ifdef LIBMESH_HAVE_LASPACK
     case LASPACK_SOLVERS:
       return libmesh_make_unique<LaspackMatrix<T>>(comm);
 #endif
 
 
 #ifdef LIBMESH_HAVE_PETSC
     case PETSC_SOLVERS:
       return libmesh_make_unique<PetscMatrix<T>>(comm);
 #endif
 
 
 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
     case TRILINOS_SOLVERS:
       return libmesh_make_unique<EpetraMatrix<T>>(comm);
 #endif
 
 
 #ifdef LIBMESH_HAVE_EIGEN
     case EIGEN_SOLVERS:
       return libmesh_make_unique<EigenSparseMatrix<T>>(comm);
 #endif
 
     default:
       libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
     }
 }

template<typename T >

void libMesh::EigenSparseMatrix< T >::clear ( )

virtual

Restores the SparseMatrix<T> to a pristine state.

Implements libMesh::SparseMatrix< T >.

Definition at line 178 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_closed, libMesh::SparseMatrix< T >::_is_initialized, and libMesh::EigenSparseMatrix< T >::_mat.

Referenced by libMesh::EigenSparseMatrix< T >::~EigenSparseMatrix().

 {
   _mat.resize(0,0);
 
   _closed = false;
   this->_is_initialized = false;
 }

template<typename T>

virtual void libMesh::EigenSparseMatrix< T >::close ( )

inlinevirtual

Calls the SparseMatrix's internal assembly routines, ensuring that the values are consistent across processors.

Implements libMesh::SparseMatrix< T >.

Definition at line 97 of file eigen_sparse_matrix.h.

References libMesh::EigenSparseMatrix< T >::_closed, libMesh::EigenSparseMatrix< T >::add(), libMesh::EigenSparseMatrix< T >::add_matrix(), libMesh::EigenSparseMatrix< T >::l1_norm(), libMesh::EigenSparseMatrix< T >::linfty_norm(), libMesh::EigenSparseMatrix< T >::m(), libMesh::EigenSparseMatrix< T >::n(), libMesh::EigenSparseMatrix< T >::operator()(), libMesh::Real, libMesh::EigenSparseMatrix< T >::row_start(), libMesh::EigenSparseMatrix< T >::row_stop(), and value.

Referenced by libMesh::EigenSparseLinearSolver< T >::solve().

97 { this->_closed = true; }

libMesh::EigenSparseMatrix::_closed

bool _closed

Definition: eigen_sparse_matrix.h:149

template<typename T>

virtual bool libMesh::EigenSparseMatrix< T >::closed ( ) const

inlinevirtual

Returns: true if the matrix has been assembled.

Implements libMesh::SparseMatrix< T >.

Definition at line 131 of file eigen_sparse_matrix.h.

References libMesh::EigenSparseMatrix< T >::_closed.

131 { return _closed; }

libMesh::EigenSparseMatrix::_closed

bool _closed

Definition: eigen_sparse_matrix.h:149

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns: A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

88 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:105

template<typename T>

virtual void libMesh::SparseMatrix< T >::create_submatrix	(	SparseMatrix< T > &	submatrix,
		const std::vector< numeric_index_type > &	rows,
		const std::vector< numeric_index_type > &	cols
	)		const

inlinevirtualinherited

This function creates a matrix called "submatrix" which is defined by the row and column indices given in the "rows" and "cols" entries. Currently this operation is only defined for the PetscMatrix type.

Definition at line 351 of file sparse_matrix.h.

   {
     this->_get_submatrix(submatrix,
                          rows,
                          cols,
                          false); // false means DO NOT REUSE submatrix
   }

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 107 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::LibMeshInit(), and libMesh::ReferenceCounter::n_objects().

 {
   _enable_print_counter = false;
   return;
 }

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

Methods to enable/disable the reference counter output from print_info()

Definition at line 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::ReferenceCounter::n_objects().

 {
   _enable_print_counter = true;
   return;
 }

template<typename T>

virtual void libMesh::SparseMatrix< T >::flush ( )

inlinevirtualinherited

For PETSc matrix , this function is similar to close but without shrinking memory. This is useful when we want to switch between ADD_VALUES and INSERT_VALUES. close should be called before using the matrix.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 179 of file sparse_matrix.h.

179 { close(); }

libMesh::SparseMatrix::close

virtual void close()=0

template<typename T >

void libMesh::EigenSparseMatrix< T >::get_diagonal ( NumericVector< T > & dest ) const

virtual

Copies the diagonal part of the matrix into dest.

Implements libMesh::SparseMatrix< T >.

Definition at line 141 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseVector< T >::_vec.

Referenced by libMesh::EigenSparseMatrix< T >::print_personal().

 {
   EigenSparseVector<T> & dest = cast_ref<EigenSparseVector<T> &>(dest_in);
 
   dest._vec = _mat.diagonal();
 }

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (Counts::iterator it = _counts.begin();
        it != _counts.end(); ++it)
     {
       const std::string name(it->first);
       const unsigned int creations    = it->second.first;
       const unsigned int destructions = it->second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

template<typename T >

void libMesh::EigenSparseMatrix< T >::get_transpose ( SparseMatrix< T > & dest ) const

virtual

Copies the transpose of the matrix into dest, which may be *this.

Implements libMesh::SparseMatrix< T >.

Definition at line 151 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat.

Referenced by libMesh::EigenSparseMatrix< T >::print_personal().

 {
   EigenSparseMatrix<T> & dest = cast_ref<EigenSparseMatrix<T> &>(dest_in);
 
   dest._mat = _mat.transpose();
 }

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name )

inlineprotectedinherited

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 185 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name )

inlineprotectedinherited

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 198 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

template<typename T>

virtual void libMesh::EigenSparseMatrix< T >::init	(	const numeric_index_type	m,
		const numeric_index_type	n,
		const numeric_index_type	m_l,
		const numeric_index_type	n_l,
		const numeric_index_type	nnz = `30`,
		const numeric_index_type	noz = `10`,
		const numeric_index_type	blocksize = `1`
	)

virtual

Initialize SparseMatrix with the specified sizes.

Parameters

m	The global number of rows.
n	The global number of columns.
m_l	The local number of rows.
n_l	The local number of columns.
nnz	The number of on-diagonal nonzeros per row (defaults to 30).
noz	The number of off-diagonal nonzeros per row (defaults to 10).
blocksize	Optional value indicating dense coupled blocks for systems with multiple variables all of the same type.

Implements libMesh::SparseMatrix< T >.

template<typename T >

void libMesh::EigenSparseMatrix< T >::init ( )

virtual

Initialize this matrix using the sparsity structure computed by dof_map.

Implements libMesh::SparseMatrix< T >.

Definition at line 63 of file eigen_sparse_matrix.C.

References libMesh::libMeshPrivateData::_is_initialized, and libMesh::initialized().

 {
   // Ignore calls on initialized objects
   if (this->initialized())
     return;
 
   // We need the DofMap for this!
   libmesh_assert(this->_dof_map);
 
   // Clear initialized matrices
   if (this->initialized())
     this->clear();
 
   const numeric_index_type n_rows   = this->_dof_map->n_dofs();
   const numeric_index_type n_cols   = n_rows;
 
 #ifndef NDEBUG
   // The following variables are only used for assertions,
   // so avoid declaring them when asserts are inactive.
   const numeric_index_type n_l = this->_dof_map->n_dofs_on_processor(0);
   const numeric_index_type m_l = n_l;
 #endif
 
   // Laspack Matrices only work for uniprocessor cases
   libmesh_assert_equal_to (n_rows, n_cols);
   libmesh_assert_equal_to (m_l, n_rows);
   libmesh_assert_equal_to (n_l, n_cols);
 
   const std::vector<numeric_index_type> & n_nz = this->_dof_map->get_n_nz();
 
 #ifndef NDEBUG
   // The following variables are only used for assertions,
   // so avoid declaring them when asserts are inactive.
   const std::vector<numeric_index_type> & n_oz = this->_dof_map->get_n_oz();
 #endif
 
   // Make sure the sparsity pattern isn't empty
   libmesh_assert_equal_to (n_nz.size(), n_l);
   libmesh_assert_equal_to (n_oz.size(), n_l);
 
   if (n_rows==0)
     {
       _mat.resize(0,0);
       return;
     }
 
   _mat.resize(n_rows,n_cols);
   _mat.reserve(n_nz);
 
   this->_is_initialized = true;
 
   libmesh_assert_equal_to (n_rows, this->m());
   libmesh_assert_equal_to (n_cols, this->n());
 }

template<typename T>

virtual bool libMesh::SparseMatrix< T >::initialized ( ) const

inlinevirtualinherited

Returns: true if the matrix has been initialized, false otherwise.

Definition at line 101 of file sparse_matrix.h.

Referenced by libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::EigenSparseMatrix< T >::add(), libMesh::LaspackMatrix< T >::add(), libMesh::ImplicitSystem::assemble(), libMesh::LaspackMatrix< T >::clear(), libMesh::ImplicitSystem::init_matrices(), libMesh::EigenSparseMatrix< T >::m(), libMesh::LaspackMatrix< T >::m(), libMesh::EigenSparseMatrix< T >::n(), libMesh::LaspackMatrix< T >::n(), libMesh::EigenSparseMatrix< T >::operator()(), libMesh::LaspackMatrix< T >::operator()(), libMesh::SparseMatrix< T >::print(), libMesh::EigenSparseMatrix< T >::set(), and libMesh::LaspackMatrix< T >::set().

101 { return _is_initialized; }

libMesh::SparseMatrix::_is_initialized

bool _is_initialized

Definition: sparse_matrix.h:427

template<typename T >

Real libMesh::EigenSparseMatrix< T >::l1_norm ( ) const

virtual

Returns: The $\ell_1$ -norm of the matrix, that is the max column sum: $|M|_1 = \max_{j} \sum_{i} |M_{ij}|$

This is the natural matrix norm that is compatible with the $\ell_1$ -norm for vectors, i.e. $|Mv|_1 \leq |M|_1 |v|_1$ . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)

Implements libMesh::SparseMatrix< T >.

Definition at line 298 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, std::abs(), libMesh::EigenSparseMatrix< T >::m(), and libMesh::EigenSparseMatrix< T >::n().

Referenced by libMesh::EigenSparseMatrix< T >::close().

 {
   // There does not seem to be a straightforward way to iterate over
   // the columns of an EigenSparseMatrix.  So we use some extra
   // storage and keep track of the column sums while going over the
   // row entries...
   std::vector<Real> abs_col_sums(this->n());
 
   // For a row-major Eigen SparseMatrix like we're using, the
   // InnerIterator iterates over the non-zero entries of rows.
   for (unsigned row=0; row<this->m(); ++row)
     {
       EigenSM::InnerIterator it(_mat, row);
       for (; it; ++it)
         abs_col_sums[it.col()] += std::abs(it.value());
     }
 
   return *(std::max_element(abs_col_sums.begin(), abs_col_sums.end()));
 }

template<typename T >

Real libMesh::EigenSparseMatrix< T >::linfty_norm ( ) const

virtual

Returns: The $\ell_{\infty}$ -norm of the matrix, that is the max row sum:

$|M|_{\infty} = \max_{i} \sum_{j} |M_{ij}|$

This is the natural matrix norm that is compatible to the $\ell_{\infty}$ -norm of vectors, i.e. $|Mv|_{\infty} \leq |M|_{\infty} |v|_{\infty}$ . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)

Implements libMesh::SparseMatrix< T >.

Definition at line 321 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, std::abs(), libMesh::EigenSparseMatrix< T >::m(), std::max(), and libMesh::Real.

Referenced by libMesh::EigenSparseMatrix< T >::close().

 {
   Real max_abs_row_sum = 0.;
 
   // For a row-major Eigen SparseMatrix like we're using, the
   // InnerIterator iterates over the non-zero entries of rows.
   for (unsigned row=0; row<this->m(); ++row)
     {
       Real current_abs_row_sum = 0.;
       EigenSM::InnerIterator it(_mat, row);
       for (; it; ++it)
         current_abs_row_sum += std::abs(it.value());
 
       max_abs_row_sum = std::max(max_abs_row_sum, current_abs_row_sum);
     }
 
   return max_abs_row_sum;
 }

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::m ( ) const

virtual

Returns: The row-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 197 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, and libMesh::SparseMatrix< T >::initialized().

Referenced by libMesh::EigenSparseMatrix< T >::add(), libMesh::EigenSparseMatrix< T >::close(), libMesh::EigenSparseMatrix< T >::l1_norm(), libMesh::EigenSparseMatrix< T >::linfty_norm(), libMesh::EigenSparseMatrix< T >::operator()(), libMesh::EigenSparseMatrix< T >::row_stop(), and libMesh::EigenSparseMatrix< T >::set().

 {
   libmesh_assert (this->initialized());
 
   return _mat.rows();
 }

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::n ( ) const

virtual

Returns: The column-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 207 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, and libMesh::SparseMatrix< T >::initialized().

Referenced by libMesh::EigenSparseMatrix< T >::add(), libMesh::EigenSparseMatrix< T >::close(), libMesh::EigenSparseMatrix< T >::l1_norm(), libMesh::EigenSparseMatrix< T >::operator()(), and libMesh::EigenSparseMatrix< T >::set().

 {
   libmesh_assert (this->initialized());
 
   return _mat.cols();
 }

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects, libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), libMesh::ReferenceCounter::increment_constructor_count(), libMesh::ReferenceCounter::increment_destructor_count(), and libMesh::Quality::name().

Referenced by libMesh::System::hide_output(), and libMesh::LibMeshInit::LibMeshInit().

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

Definition: reference_counter.h:132

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 93 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

94 { return cast_int<processor_id_type>(_communicator.size()); }

libMesh::Parallel::Communicator::size

unsigned int size() const

Definition: parallel.h:725

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:105

template<typename T>

virtual bool libMesh::SparseMatrix< T >::need_full_sparsity_pattern ( ) const

inlinevirtualinherited

Returns: true if this sparse matrix format needs to be fed the graph of the sparse matrix.

This is true for LaspackMatrix, but not PetscMatrix. In the case where the full graph is not required, we can efficiently approximate it to provide a good estimate of the required size of the sparse matrix.

Reimplemented in libMesh::EpetraMatrix< T >, and libMesh::LaspackMatrix< T >.

Definition at line 118 of file sparse_matrix.h.

Referenced by libMesh::DofMap::attach_matrix().

119 { return false; }

template<typename T >

T libMesh::EigenSparseMatrix< T >::operator()	(	const numeric_index_type	i,
		const numeric_index_type	j
	)		const

virtual

Returns: A copy of matrix entry (i,j).

Note: This may be an expensive operation, and you should always be careful where you call this function.

Implements libMesh::SparseMatrix< T >.

Definition at line 285 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, libMesh::SparseMatrix< T >::initialized(), libMesh::EigenSparseMatrix< T >::m(), and libMesh::EigenSparseMatrix< T >::n().

Referenced by libMesh::EigenSparseMatrix< T >::close().

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->m());
   libmesh_assert_less (j, this->n());
 
   return _mat.coeff(i,j);
 }

template<>

void libMesh::SparseMatrix< Complex >::print	(	std::ostream &	os,
		const bool	sparse
	)		const

inherited

Definition at line 102 of file sparse_matrix.C.

References libMesh::SparseMatrix< T >::m(), and libMesh::SparseMatrix< T >::n().

 {
   // std::complex<>::operator<<() is defined, but use this form
 
   if (sparse)
     {
       libmesh_not_implemented();
     }
 
   os << "Real part:" << std::endl;
   for (numeric_index_type i=0; i<this->m(); i++)
     {
       for (numeric_index_type j=0; j<this->n(); j++)
         os << std::setw(8) << (*this)(i,j).real() << " ";
       os << std::endl;
     }
 
   os << std::endl << "Imaginary part:" << std::endl;
   for (numeric_index_type i=0; i<this->m(); i++)
     {
       for (numeric_index_type j=0; j<this->n(); j++)
         os << std::setw(8) << (*this)(i,j).imag() << " ";
       os << std::endl;
     }
 }

template<typename T >

void libMesh::SparseMatrix< T >::print	(	std::ostream &	os = `libMesh::out`,
		const bool	sparse = `false`
	)		const

inherited

Print the contents of the matrix to the screen in a uniform style, regardless of matrix/solver package being used.

Definition at line 206 of file sparse_matrix.C.

References libMesh::SparseMatrix< T >::_dof_map, libMesh::ParallelObject::comm(), libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), libMesh::SparseMatrix< T >::initialized(), libMesh::SparseMatrix< T >::m(), libMesh::SparseMatrix< T >::n(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::Parallel::Communicator::receive(), and libMesh::Parallel::Communicator::send().

Referenced by libMesh::EigenSparseMatrix< T >::print_personal(), and libMesh::LaspackMatrix< T >::print_personal().

 {
   parallel_object_only();
 
   libmesh_assert (this->initialized());
 
   if (!this->_dof_map)
     libmesh_error_msg("Error!  Trying to print a matrix with no dof_map set!");
 
   // We'll print the matrix from processor 0 to make sure
   // it's serialized properly
   if (this->processor_id() == 0)
     {
       libmesh_assert_equal_to (this->_dof_map->first_dof(), 0);
       for (numeric_index_type i=this->_dof_map->first_dof();
            i!=this->_dof_map->end_dof(); ++i)
         {
           if (sparse)
             {
               for (numeric_index_type j=0; j<this->n(); j++)
                 {
                   T c = (*this)(i,j);
                   if (c != static_cast<T>(0.0))
                     {
                       os << i << " " << j << " " << c << std::endl;
                     }
                 }
             }
           else
             {
               for (numeric_index_type j=0; j<this->n(); j++)
                 os << (*this)(i,j) << " ";
               os << std::endl;
             }
         }
 
       std::vector<numeric_index_type> ibuf, jbuf;
       std::vector<T> cbuf;
       numeric_index_type currenti = this->_dof_map->end_dof();
       for (processor_id_type p=1; p < this->n_processors(); ++p)
         {
           this->comm().receive(p, ibuf);
           this->comm().receive(p, jbuf);
           this->comm().receive(p, cbuf);
           libmesh_assert_equal_to (ibuf.size(), jbuf.size());
           libmesh_assert_equal_to (ibuf.size(), cbuf.size());
 
           if (ibuf.empty())
             continue;
           libmesh_assert_greater_equal (ibuf.front(), currenti);
           libmesh_assert_greater_equal (ibuf.back(), ibuf.front());
 
           std::size_t currentb = 0;
           for (;currenti <= ibuf.back(); ++currenti)
             {
               if (sparse)
                 {
                   for (numeric_index_type j=0; j<this->n(); j++)
                     {
                       if (currentb < ibuf.size() &&
                           ibuf[currentb] == currenti &&
                           jbuf[currentb] == j)
                         {
                           os << currenti << " " << j << " " << cbuf[currentb] << std::endl;
                           currentb++;
                         }
                     }
                 }
               else
                 {
                   for (numeric_index_type j=0; j<this->n(); j++)
                     {
                       if (currentb < ibuf.size() &&
                           ibuf[currentb] == currenti &&
                           jbuf[currentb] == j)
                         {
                           os << cbuf[currentb] << " ";
                           currentb++;
                         }
                       else
                         os << static_cast<T>(0.0) << " ";
                     }
                   os << std::endl;
                 }
             }
         }
       if (!sparse)
         {
           for (; currenti != this->m(); ++currenti)
             {
               for (numeric_index_type j=0; j<this->n(); j++)
                 os << static_cast<T>(0.0) << " ";
               os << std::endl;
             }
         }
     }
   else
     {
       std::vector<numeric_index_type> ibuf, jbuf;
       std::vector<T> cbuf;
 
       // We'll assume each processor has access to entire
       // matrix rows, so (*this)(i,j) is valid if i is a local index.
       for (numeric_index_type i=this->_dof_map->first_dof();
            i!=this->_dof_map->end_dof(); ++i)
         {
           for (numeric_index_type j=0; j<this->n(); j++)
             {
               T c = (*this)(i,j);
               if (c != static_cast<T>(0.0))
                 {
                   ibuf.push_back(i);
                   jbuf.push_back(j);
                   cbuf.push_back(c);
                 }
             }
         }
       this->comm().send(0,ibuf);
       this->comm().send(0,jbuf);
       this->comm().send(0,cbuf);
     }
 }

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::LibMeshInit().

 {
   if (_enable_print_counter)
     out_stream << ReferenceCounter::get_info();
 }

template<typename T>

virtual void libMesh::SparseMatrix< T >::print_matlab ( const std::string & = "" ) const

inlinevirtualinherited

Print the contents of the matrix in Matlab's sparse matrix format. Optionally prints the matrix to the file named name. If name is not specified it is dumped to the screen.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 341 of file sparse_matrix.h.

   {
     libmesh_not_implemented();
   }

template<typename T>

virtual void libMesh::EigenSparseMatrix< T >::print_personal ( std::ostream & os = libMesh::out ) const

inlinevirtual

Print the contents of the matrix to the screen in a package-personalized style, if available.

Implements libMesh::SparseMatrix< T >.

Definition at line 133 of file eigen_sparse_matrix.h.

References libMesh::EigenSparseMatrix< T >::get_diagonal(), libMesh::EigenSparseMatrix< T >::get_transpose(), and libMesh::SparseMatrix< T >::print().

133 { this->print(os); }

libMesh::SparseMatrix::print

void print(std::ostream &os=libMesh::out, const bool sparse=false) const

Definition: sparse_matrix.C:206

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 99 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

100 { return cast_int<processor_id_type>(_communicator.rank()); }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:105

libMesh::Parallel::Communicator::rank

unsigned int rank() const

Definition: parallel.h:723

template<typename T>

virtual void libMesh::SparseMatrix< T >::reinit_submatrix	(	SparseMatrix< T > &	submatrix,
		const std::vector< numeric_index_type > &	rows,
		const std::vector< numeric_index_type > &	cols
	)		const

inlinevirtualinherited

This function is similar to the one above, but it allows you to reuse the existing sparsity pattern of "submatrix" instead of reallocating it again. This should hopefully be more efficient if you are frequently extracting submatrices of the same size.

Definition at line 367 of file sparse_matrix.h.

   {
     this->_get_submatrix(submatrix,
                          rows,
                          cols,
                          true); // true means REUSE submatrix
   }

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::row_start ( ) const

virtual

Returns: The index of the first matrix row stored on this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 217 of file eigen_sparse_matrix.C.

Referenced by libMesh::EigenSparseMatrix< T >::close().

 {
   return 0;
 }

template<typename T >

numeric_index_type libMesh::EigenSparseMatrix< T >::row_stop ( ) const

virtual

Returns: The index of the last matrix row (+1) stored on this processor.

Implements libMesh::SparseMatrix< T >.

Definition at line 225 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::m().

Referenced by libMesh::EigenSparseMatrix< T >::close().

 {
   return this->m();
 }

template<typename T >

void libMesh::EigenSparseMatrix< T >::set	(	const numeric_index_type	i,
		const numeric_index_type	j,
		const T	value
	)

virtual

Set the element (i,j) to value. Throws an error if the entry does not exist. Zero values can be "stored" in non-existent fields.

Implements libMesh::SparseMatrix< T >.

Definition at line 233 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat, libMesh::SparseMatrix< T >::initialized(), libMesh::EigenSparseMatrix< T >::m(), libMesh::EigenSparseMatrix< T >::n(), and value.

 {
   libmesh_assert (this->initialized());
   libmesh_assert_less (i, this->m());
   libmesh_assert_less (j, this->n());
 
   _mat.coeffRef(i,j) = value;
 }

template<typename T>

virtual void libMesh::SparseMatrix< T >::update_sparsity_pattern ( const SparsityPattern::Graph & )

inlinevirtualinherited

Updates the matrix sparsity pattern. When your SparseMatrix<T> implementation does not need this data, simply do not override this method.

Reimplemented in libMesh::EpetraMatrix< T >, and libMesh::LaspackMatrix< T >.

Definition at line 126 of file sparse_matrix.h.

Referenced by libMesh::DofMap::attach_matrix().

126 {}

template<typename T>

void libMesh::SparseMatrix< T >::vector_mult	(	NumericVector< T > &	dest,
		const NumericVector< T > &	arg
	)		const

inherited

Multiplies the matrix by the NumericVector arg and stores the result in NumericVector dest.

Definition at line 176 of file sparse_matrix.C.

References libMesh::SparseMatrix< T >::vector_mult_add(), and libMesh::NumericVector< T >::zero().

Referenced by libMesh::ImplicitSystem::qoi_parameter_hessian(), and libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product().

 {
   dest.zero();
   this->vector_mult_add(dest,arg);
 }

template<typename T>

void libMesh::SparseMatrix< T >::vector_mult_add	(	NumericVector< T > &	dest,
		const NumericVector< T > &	arg
	)		const

inherited

Multiplies the matrix by the NumericVector arg and adds the result to the NumericVector dest.

Definition at line 186 of file sparse_matrix.C.

References libMesh::NumericVector< T >::add_vector().

Referenced by libMesh::SparseMatrix< T >::vector_mult(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

 {
   /* This functionality is actually implemented in the \p
      NumericVector class.  */
   dest.add_vector(arg,*this);
 }

template<typename T >

void libMesh::EigenSparseMatrix< T >::zero ( )

virtual

Set all entries to 0.

Implements libMesh::SparseMatrix< T >.

Definition at line 189 of file eigen_sparse_matrix.C.

References libMesh::EigenSparseMatrix< T >::_mat.

 {
   _mat.setZero();
 }

template<typename T>

void libMesh::SparseMatrix< T >::zero_rows	(	std::vector< numeric_index_type > &	rows,
		T	diag_value = `0.0`
	)

virtualinherited

Sets all row entries to 0 then puts diag_value in the diagonal entry.

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 197 of file sparse_matrix.C.

 {
   /* This functionality isn't implemented or stubbed in every subclass yet */
   libmesh_not_implemented();
 }

Friends And Related Function Documentation

template<typename T>

friend class EigenSparseLinearSolver< T >

friend

Definition at line 155 of file eigen_sparse_matrix.h.

template<typename T>

friend class EigenSparseVector< T >

friend

Make other Eigen datatypes friends

Definition at line 154 of file eigen_sparse_matrix.h.

Member Data Documentation

template<typename T>

bool libMesh::EigenSparseMatrix< T >::_closed

private

Flag indicating if the matrix has been closed yet.

Definition at line 149 of file eigen_sparse_matrix.h.

Referenced by libMesh::EigenSparseMatrix< T >::clear(), libMesh::EigenSparseMatrix< T >::close(), and libMesh::EigenSparseMatrix< T >::closed().

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 105 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::EquationSystems::get_solution(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

template<typename T>

DofMap const* libMesh::SparseMatrix< T >::_dof_map

protectedinherited

The DofMap object associated with this object.

Definition at line 422 of file sparse_matrix.h.

Referenced by libMesh::SparseMatrix< T >::print().

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

template<typename T>

bool libMesh::SparseMatrix< T >::_is_initialized

protectedinherited

Flag indicating whether or not the matrix has been initialized.

Definition at line 427 of file sparse_matrix.h.

Referenced by libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::EigenSparseMatrix< T >::clear(), libMesh::LaspackMatrix< T >::clear(), and libMesh::PetscMatrix< T >::get_transpose().

template<typename T>

DataType libMesh::EigenSparseMatrix< T >::_mat

private

Actual Eigen::SparseMatrix<> we are wrapping.

Definition at line 144 of file eigen_sparse_matrix.h.

Referenced by libMesh::EigenSparseMatrix< T >::add(), libMesh::EigenSparseMatrix< T >::clear(), libMesh::EigenSparseMatrix< T >::get_transpose(), libMesh::EigenSparseMatrix< T >::l1_norm(), libMesh::EigenSparseMatrix< T >::linfty_norm(), libMesh::EigenSparseMatrix< T >::m(), libMesh::EigenSparseMatrix< T >::n(), libMesh::EigenSparseMatrix< T >::operator()(), libMesh::EigenSparseMatrix< T >::set(), libMesh::EigenSparseLinearSolver< T >::solve(), and libMesh::EigenSparseMatrix< T >::zero().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Attributes

Friends

Detailed Description

template<typename T> class libMesh::EigenSparseMatrix< T >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename T>
class libMesh::EigenSparseMatrix< T >