libMesh::SparseMatrix< T > Class Template Reference

Generic sparse matrix. More...

#include <dof_map.h>

Inheritance diagram for libMesh::SparseMatrix< T >:

Public Member Functions
	SparseMatrix (const Parallel::Communicator &comm)
	Constructor; initializes the matrix to be empty, without any structure, i.e. More...
	SparseMatrix (SparseMatrix &&)=default
	The 5 special functions can be defaulted for this class, as it does not manage any memory itself. More...
	SparseMatrix (const SparseMatrix &)=default
SparseMatrix &	operator= (const SparseMatrix &)=default
SparseMatrix &	operator= (SparseMatrix &&)=default
virtual	~SparseMatrix ()=default
virtual bool	initialized () const
void	attach_dof_map (const DofMap &dof_map)
	Get a pointer to the DofMap to use. More...
virtual bool	need_full_sparsity_pattern () const
virtual void	update_sparsity_pattern (const SparsityPattern::Graph &)
	Updates the matrix sparsity pattern. More...
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)=0
	Initialize SparseMatrix with the specified sizes. More...
virtual void	init ()=0
	Initialize this matrix using the sparsity structure computed by dof_map. More...
virtual void	clear ()=0
	Restores the SparseMatrix<T> to a pristine state. More...
virtual void	zero ()=0
	Set all entries to 0. More...
virtual void	zero_rows (std::vector< numeric_index_type > &rows, T diag_value=0.0)
	Sets all row entries to 0 then puts diag_value in the diagonal entry. More...
virtual void	close ()=0
	Calls the SparseMatrix's internal assembly routines, ensuring that the values are consistent across processors. More...
virtual void	flush ()
	For PETSc matrix , this function is similar to close but without shrinking memory. More...
virtual numeric_index_type	m () const =0
virtual numeric_index_type	local_m () const
	Get the number of rows owned by this process. More...
virtual numeric_index_type	n () const =0
virtual numeric_index_type	row_start () const =0
virtual numeric_index_type	row_stop () const =0
virtual void	set (const numeric_index_type i, const numeric_index_type j, const T value)=0
	Set the element (i,j) to value. More...
virtual void	add (const numeric_index_type i, const numeric_index_type j, const T value)=0
	Add value to the element (i,j). More...
virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols)=0
	Add the full matrix dm to the SparseMatrix. More...
virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices)=0
	Same as add_matrix, but assumes the row and column maps are the same. More...
virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &brows, const std::vector< numeric_index_type > &bcols)
	Add the full matrix dm to the SparseMatrix. More...
virtual void	add_block_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices)
	Same as add_block_matrix(), but assumes the row and column maps are the same. More...
virtual void	add (const T a, const SparseMatrix< T > &X)=0
	Compute \( A \leftarrow A + a*X \) for scalar a, matrix X. More...
virtual T	operator() (const numeric_index_type i, const numeric_index_type j) const =0
virtual Real	l1_norm () const =0
virtual Real	linfty_norm () const =0
virtual bool	closed () const =0
void	print (std::ostream &os=libMesh::out, const bool sparse=false) const
	Print the contents of the matrix to the screen in a uniform style, regardless of matrix/solver package being used. More...
virtual void	print_personal (std::ostream &os=libMesh::out) const =0
	Print the contents of the matrix to the screen in a package-personalized style, if available. More...
virtual void	print_matlab (const std::string &="") const
	Print the contents of the matrix in Matlab's sparse matrix format. More...
virtual void	create_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const
	This function creates a matrix called "submatrix" which is defined by the row and column indices given in the "rows" and "cols" entries. More...
virtual void	reinit_submatrix (SparseMatrix< T > &submatrix, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) const
	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. More...
void	vector_mult (NumericVector< T > &dest, const NumericVector< T > &arg) const
	Multiplies the matrix by the NumericVector arg and stores the result in NumericVector dest. More...
void	vector_mult_add (NumericVector< T > &dest, const NumericVector< T > &arg) const
	Multiplies the matrix by the NumericVector arg and adds the result to the NumericVector dest. More...
virtual void	get_diagonal (NumericVector< T > &dest) const =0
	Copies the diagonal part of the matrix into dest. More...
virtual void	get_transpose (SparseMatrix< T > &dest) const =0
	Copies the transpose of the matrix into dest, which may be *this. More...
virtual void	get_row (numeric_index_type, std::vector< numeric_index_type > &, std::vector< T > &) const
	Get a row from the matrix. More...
template<>
void	print (std::ostream &os, const bool sparse) 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())
	Builds a SparseMatrix<T> using the linear solver package specified by solver_package. More...
static std::string	get_info ()
	Gets a string containing the reference information. More...
static void	print_info (std::ostream &out=libMesh::out)
	Prints the reference information, by default to libMesh::out. More...
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. More...
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() More...
static void	disable_print_counter_info ()

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information. More...

Protected Member Functions
virtual void	_get_submatrix (SparseMatrix< T > &, const std::vector< numeric_index_type > &, const std::vector< numeric_index_type > &, const bool) const
	Protected implementation of the create_submatrix and reinit_submatrix routines. More...
void	increment_constructor_count (const std::string &name)
	Increments the construction counter. More...
void	increment_destructor_count (const std::string &name)
	Increments the destruction counter. More...

Protected Attributes
const DofMap *	_dof_map
	The DofMap object associated with this object. More...
bool	_is_initialized
	Flag indicating whether or not the matrix has been initialized. More...
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data. More...
static Threads::atomic< unsigned int >	_n_objects
	The number of objects. More...
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting. More...
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called. More...

Friends
std::ostream &	operator<< (std::ostream &os, const SparseMatrix< T > &m)
	Same as the print method above, but allows you to print to a stream in the standard syntax. More...

Detailed Description

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

Generic sparse matrix.

This class contains pure virtual members that must be overridden in derived classes. Using a common base class allows for uniform access to sparse matrices from various different solver packages in different formats.

Author

Benjamin S. Kirk

Date

2003

Definition at line 45 of file vector_fe_ex5.C.

Member Typedef Documentation

Counts

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 117 of file reference_counter.h.

Constructor & Destructor Documentation

SparseMatrix() [1/3]

template<typename T >

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

explicit

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 45 of file sparse_matrix.C.

                                                                   :
  ParallelObject(comm_in),
  _dof_map(nullptr),
  _is_initialized(false)
{}

SparseMatrix() [2/3]

template<typename T>

libMesh::SparseMatrix< T >::SparseMatrix ( SparseMatrix< T > &&  )

default

The 5 special functions can be defaulted for this class, as it does not manage any memory itself.

SparseMatrix() [3/3]

template<typename T>

libMesh::SparseMatrix< T >::SparseMatrix ( const SparseMatrix< T > &  )

default

~SparseMatrix()

template<typename T>

virtual libMesh::SparseMatrix< T >::~SparseMatrix ( )

virtualdefault

Member Function Documentation

_get_submatrix()

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

inlineprotectedvirtual

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 432 of file sparse_matrix.h.

  {
    libmesh_not_implemented();
  }

Referenced by libMesh::SparseMatrix< ValOut >::create_submatrix(), and libMesh::SparseMatrix< ValOut >::reinit_submatrix().

add() [1/2]

template<typename T>

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

pure 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.

Implemented in libMesh::PetscMatrix< T >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by add_M_C_K_helmholtz(), libMesh::RBConstruction::add_scaled_Aq(), libMesh::TransientRBConstruction::add_scaled_mass_matrix(), assemble_shell(), libMesh::NewmarkSystem::compute_matrix(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), AssembleOptimization::hessian(), LinearElasticityWithContact::residual_and_jacobian(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), libMesh::TransientRBConstruction::truth_assembly(), and libMesh::RBConstruction::truth_assembly().

add() [2/2]

template<typename T>

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

pure virtual

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

Implemented in libMesh::PetscMatrix< T >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

add_block_matrix() [1/2]

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  )

virtual

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 56 of file sparse_matrix.C.

{
  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 (auto & row : brows)
    {
      numeric_index_type i = row * blocksize;
 
      for (unsigned int v=0; v<blocksize; v++)
        rows.push_back(i++);
    }
 
  for (auto & col : bcols)
    {
      numeric_index_type j = col * blocksize;
 
      for (unsigned int v=0; v<blocksize; v++)
        cols.push_back(j++);
    }
 
  this->add_matrix (dm, rows, cols);
}

Referenced by libMesh::SparseMatrix< ValOut >::add_block_matrix().

add_block_matrix() [2/2]

template<typename T>

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

inlinevirtual

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 257 of file sparse_matrix.h.

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

add_matrix() [1/2]

template<typename T>

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

pure virtual

Same as add_matrix, but assumes the row and column maps are the same.

Thus the matrix dm must be square.

Implemented in libMesh::PetscMatrix< T >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

add_matrix() [2/2]

template<typename T>

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

pure virtual

Add the full matrix dm to the SparseMatrix.

This is useful for adding an element matrix at assembly time.

Implemented in libMesh::PetscMatrix< T >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

Referenced by libMesh::RBConstruction::add_scaled_matrix_and_vector(), assemble(), LinearElasticity::assemble(), assemble_1D(), AssembleOptimization::assemble_A_and_F(), assemble_biharmonic(), assemble_elasticity(), assemble_ellipticdg(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), assemble_matrices(), assemble_matrix_and_rhs(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), assembly_with_dg_fem_context(), compute_jacobian(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), Biharmonic::JR::residual_and_jacobian(), LinearElasticityWithContact::residual_and_jacobian(), and OverlappingCouplingGhostingTest::run_sparsity_pattern_test().

attach_dof_map()

template<typename T>

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

inline

Get a pointer to the DofMap to use.

Definition at line 108 of file sparse_matrix.h.

  { _dof_map = &dof_map; }

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

build()

template<typename T >

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

static

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

Definition at line 130 of file sparse_matrix.C.

{
  // 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);
    }
}

Referenced by libMesh::ImplicitSystem::add_matrix(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::EigenSystem::init_matrices(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

clear()

template<typename T>

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

pure virtual

Restores the SparseMatrix<T> to a pristine state.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by libMesh::PetscMatrix< libMesh::Number >::_get_submatrix(), and libMesh::PetscMatrix< libMesh::Number >::get_transpose().

close()

template<typename T>

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

pure virtual

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

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by add_M_C_K_helmholtz(), libMesh::RBConstruction::add_scaled_Aq(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::LinearSolver< Number >::adjoint_solve(), assemble(), AssembleOptimization::assemble_A_and_F(), assemble_matrix_and_rhs(), libMesh::FEMSystem::assembly(), libMesh::LinearImplicitSystem::assembly(), libMesh::NewmarkSystem::compute_matrix(), libMesh::ContinuationSystem::continuation_solve(), libMesh::SparseMatrix< ValOut >::flush(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), main(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::ImplicitSystem::sensitivity_solve(), libMesh::NewtonSolver::solve(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

closed()

template<typename T>

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

pure virtual

Returns

true if the matrix has been assembled.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

comm()

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

inlineinherited

Returns

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

Definition at line 94 of file parallel_object.h.

  { return _communicator; }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::DynaIO::add_spline_constraints(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), SystemsTest::testBlockRestrictedVarNDofs(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), CheckpointIOTest::testSplitter(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

create_submatrix()

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

inlinevirtual

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 358 of file sparse_matrix.h.

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

Referenced by libMesh::libmesh_petsc_DMCreateInterpolation().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

flush()

template<typename T>

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

inlinevirtual

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 >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 181 of file sparse_matrix.h.

{ close(); }

get_diagonal()

template<typename T>

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

pure virtual

Copies the diagonal part of the matrix into dest.

Implemented in libMesh::PetscMatrix< T >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

Referenced by libMesh::DiagonalMatrix< T >::add().

get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

get_row()

template<typename T>

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

inlinevirtual

Get a row from the matrix.

Parameters

i	The matrix row to get
indices	A container that will be filled with the column indices corresponding to (possibly) non-zero values
values	A container holding the column values

Reimplemented in libMesh::PetscMatrix< T >.

Definition at line 416 of file sparse_matrix.h.

  {
    libmesh_not_implemented();
  }

get_transpose()

template<typename T>

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

pure virtual

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

Implemented in libMesh::PetscMatrix< T >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

Referenced by libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::LinearSolver< Number >::adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

increment_constructor_count()

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 181 of file reference_counter.h.

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

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

increment_destructor_count()

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 194 of file reference_counter.h.

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

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

init() [1/2]

template<typename T>

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

pure virtual

Initialize this matrix using the sparsity structure computed by dof_map.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

init() [2/2]

template<typename T>

virtual void libMesh::SparseMatrix< 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  )

pure 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.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

Referenced by OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

initialized()

template<typename T>

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

inlinevirtual

Returns

true if the matrix has been initialized, false otherwise.

Definition at line 103 of file sparse_matrix.h.

{ return _is_initialized; }

Referenced by libMesh::PetscMatrix< libMesh::Number >::_get_submatrix(), libMesh::ImplicitSystem::assemble(), and libMesh::ImplicitSystem::init_matrices().

l1_norm()

template<typename T>

virtual Real libMesh::SparseMatrix< T >::l1_norm ( ) const

pure 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)

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

Referenced by libMesh::FEMSystem::assembly().

linfty_norm()

template<typename T>

virtual Real libMesh::SparseMatrix< T >::linfty_norm ( ) const

pure 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)

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

Referenced by SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

local_m()

template<typename T>

virtual numeric_index_type libMesh::SparseMatrix< T >::local_m ( ) const

inlinevirtual

Get the number of rows owned by this process.

Reimplemented in libMesh::PetscMatrix< T >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 191 of file sparse_matrix.h.

{ return row_stop() - row_start(); }

m()

template<typename T>

virtual numeric_index_type libMesh::SparseMatrix< T >::m ( ) const

pure virtual

Returns

The row-dimension of the matrix.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by libMesh::EigenSparseMatrix< T >::add(), libMesh::LaspackMatrix< T >::add(), libMesh::EpetraMatrix< T >::add(), and libMesh::PetscMatrix< libMesh::Number >::add().

n()

template<typename T>

virtual numeric_index_type libMesh::SparseMatrix< T >::n ( ) const

pure virtual

Returns

The column-dimension of the matrix.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by libMesh::EigenSparseMatrix< T >::add(), libMesh::LaspackMatrix< T >::add(), libMesh::EpetraMatrix< T >::add(), and libMesh::PetscMatrix< libMesh::Number >::add().

n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::partition(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::VTKIO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

need_full_sparsity_pattern()

template<typename T>

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

inlinevirtual

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 120 of file sparse_matrix.h.

  { return false; }

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

operator()()

template<typename T>

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

pure 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.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

operator=() [1/2]

template<typename T>

SparseMatrix& libMesh::SparseMatrix< T >::operator= ( const SparseMatrix< T > &  )

default

operator=() [2/2]

template<typename T>

SparseMatrix& libMesh::SparseMatrix< T >::operator= ( SparseMatrix< T > &&  )

default

print() [1/2]

template<>

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

Definition at line 96 of file sparse_matrix.C.

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

print() [2/2]

template<typename T >

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

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

Definition at line 200 of file sparse_matrix.C.

{
  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 (auto j : IntRange<numeric_index_type>(0, this->n()))
                {
                  T c = (*this)(i,j);
                  if (c != static_cast<T>(0.0))
                    {
                      os << i << " " << j << " " << c << std::endl;
                    }
                }
            }
          else
            {
              for (auto j : IntRange<numeric_index_type>(0, this->n()))
                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 (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          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 (auto j : IntRange<numeric_index_type>(0, this->n()))
                    {
                      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 (auto j : IntRange<numeric_index_type>(0, this->n()))
            {
              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);
    }
}

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

print_info()

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

print_matlab()

template<typename T>

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

inlinevirtual

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 >, and libMesh::PetscMatrix< libMesh::Number >.

Definition at line 348 of file sparse_matrix.h.

  {
    libmesh_not_implemented();
  }

print_personal()

template<typename T>

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

pure virtual

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

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::EigenSparseMatrix< T >, and libMesh::DiagonalMatrix< T >.

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

reinit_submatrix()

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

inlinevirtual

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 374 of file sparse_matrix.h.

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

row_start()

template<typename T>

virtual numeric_index_type libMesh::SparseMatrix< T >::row_start ( ) const

pure virtual

Returns

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

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by libMesh::MatrixFillAction< ValIn, ValOut >::insert(), libMesh::SparseMatrix< ValOut >::local_m(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

row_stop()

template<typename T>

virtual numeric_index_type libMesh::SparseMatrix< T >::row_stop ( ) const

pure virtual

Returns

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

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by libMesh::MatrixFillAction< ValIn, ValOut >::insert(), libMesh::SparseMatrix< ValOut >::local_m(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

set()

template<typename T>

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

pure 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.

Implemented in libMesh::PetscMatrix< T >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by AssembleOptimization::equality_constraints_jacobian(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::MatrixFillAction< ValIn, ValOut >::insert(), libMesh::System::projection_matrix(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), and SystemsTest::testProjectMatrix3D().

update_sparsity_pattern()

template<typename T>

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

inlinevirtual

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 128 of file sparse_matrix.h.

{}

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

vector_mult()

template<typename T>

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

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

Definition at line 170 of file sparse_matrix.C.

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

Referenced by libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), AssembleOptimization::gradient(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), AssembleOptimization::objective(), libMesh::RBConstruction::print_basis_function_orthogonality(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_solve(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), and libMesh::RBConstruction::update_residual_terms().

vector_mult_add()

template<typename T>

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

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

Definition at line 180 of file sparse_matrix.C.

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

Referenced by libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

zero()

template<typename T>

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

pure virtual

Set all entries to 0.

Implemented in libMesh::PetscMatrix< T >, libMesh::PetscMatrix< libMesh::Number >, libMesh::EpetraMatrix< T >, libMesh::LaspackMatrix< T >, libMesh::DiagonalMatrix< T >, and libMesh::EigenSparseMatrix< T >.

Referenced by add_M_C_K_helmholtz(), libMesh::ImplicitSystem::assemble(), AssembleOptimization::assemble_A_and_F(), libMesh::RBConstruction::assemble_Aq_matrix(), libMesh::RBConstruction::assemble_inner_product_matrix(), libMesh::TransientRBConstruction::assemble_L2_matrix(), libMesh::TransientRBConstruction::assemble_mass_matrix(), libMesh::TransientRBConstruction::assemble_Mq_matrix(), libMesh::FEMSystem::assembly(), libMesh::NewmarkSystem::compute_matrix(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), AssembleOptimization::equality_constraints_jacobian(), AssembleOptimization::hessian(), AssembleOptimization::inequality_constraints_jacobian(), LargeDeformationElasticity::jacobian(), main(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::TransientRBConstruction::truth_assembly(), and libMesh::RBConstruction::truth_assembly().

zero_rows()

template<typename T>

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

virtual

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

Reimplemented in libMesh::DiagonalMatrix< T >, and libMesh::PetscMatrix< T >.

Definition at line 191 of file sparse_matrix.C.

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

Friends And Related Function Documentation

operator<<

template<typename T>

std::ostream& operator<< ( std::ostream &  os, const SparseMatrix< T > &  m  )

friend

Same as the print method above, but allows you to print to a stream in the standard syntax.

template <typename U>
friend std::ostream & operator << (std::ostream & os, const SparseMatrix<U> & m);

Note

The above syntax, which does not require any prior declaration of operator<<, declares any instantiation of SparseMatrix<X> is friend to any instantiation of operator<<(ostream &, SparseMatrix<Y> &). It would not happen in practice, but in principle it means that SparseMatrix<Complex> would be friend to operator<<(ostream &, SparseMatrix<Real>).

The form below, which requires a previous declaration of the operator<<(stream &, SparseMatrix<T> &) function (see top of this file), means that any instantiation of SparseMatrix<T> is friend to the specialization operator<<(ostream &, SparseMatrix<T> &), but e.g. SparseMatrix is not friend to the same function. So this is slightly different to the form above...

This method seems to be the "preferred" technique, see http://www.parashift.com/c++-faq-lite/template-friends.html

Definition at line 462 of file sparse_matrix.h.

{
  m.print(os);
  return os;
}

Member Data Documentation

_communicator

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

protectedinherited

Definition at line 112 of file parallel_object.h.

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

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

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

_dof_map

template<typename T>

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

protected

The DofMap object associated with this object.

Definition at line 443 of file sparse_matrix.h.

Referenced by libMesh::SparseMatrix< ValOut >::attach_dof_map().

_enable_print_counter

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 141 of file reference_counter.h.

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

_is_initialized

template<typename T>

bool libMesh::SparseMatrix< T >::_is_initialized

protected

Flag indicating whether or not the matrix has been initialized.

Definition at line 448 of file sparse_matrix.h.

Referenced by libMesh::PetscMatrix< libMesh::Number >::_get_submatrix(), libMesh::EpetraMatrix< T >::EpetraMatrix(), libMesh::PetscMatrix< libMesh::Number >::get_transpose(), and libMesh::SparseMatrix< ValOut >::initialized().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

_n_objects

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 130 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:

• examples/vector_fe/vector_fe_ex5/vector_fe_ex5.C
• include/numerics/sparse_matrix.h
• src/numerics/sparse_matrix.C