libMesh::EpetraMatrix< T > Class Template Reference

#include <trilinos_epetra_matrix.h>

Inheritance diagram for libMesh::EpetraMatrix< T >:

Public Member Functions
	EpetraMatrix (const Parallel::Communicator &comm)
	EpetraMatrix (Epetra_FECrsMatrix *m, const Parallel::Communicator &comm)
	EpetraMatrix (EpetraMatrix &&)=delete
	EpetraMatrix (const EpetraMatrix &)=delete
EpetraMatrix &	operator= (const EpetraMatrix &)=delete
EpetraMatrix &	operator= (EpetraMatrix &&)=delete
virtual	~EpetraMatrix ()
virtual bool	need_full_sparsity_pattern () const override
virtual void	update_sparsity_pattern (const SparsityPattern::Graph &) override
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) override
virtual void	init () override
virtual void	clear () override
virtual void	zero () override
virtual void	close () override
virtual numeric_index_type	m () const override
virtual numeric_index_type	n () const override
virtual numeric_index_type	row_start () const override
virtual numeric_index_type	row_stop () const override
virtual void	set (const numeric_index_type i, const numeric_index_type j, const T value) override
virtual void	add (const numeric_index_type i, const numeric_index_type j, const T value) override
virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols) override
virtual void	add_matrix (const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &dof_indices) override
virtual void	add (const T a, const SparseMatrix< T > &X) override
virtual T	operator() (const numeric_index_type i, const numeric_index_type j) const override
virtual Real	l1_norm () const override
virtual Real	linfty_norm () const override
virtual bool	closed () const override
virtual void	print_personal (std::ostream &os=libMesh::out) const override
virtual void	get_diagonal (NumericVector< T > &dest) const override
virtual void	get_transpose (SparseMatrix< T > &dest) const override
void	swap (EpetraMatrix< T > &)
Epetra_FECrsMatrix *	mat ()
const Epetra_FECrsMatrix *	mat () const
virtual bool	initialized () const
void	attach_dof_map (const DofMap &dof_map)
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
Epetra_FECrsMatrix *	_mat
Epetra_Map *	_map
Epetra_CrsGraph *	_graph
bool	_destroy_mat_on_exit
bool	_use_transpose

Detailed Description

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

This class provides a nice interface to the Epetra data structures for parallel, sparse matrices. All overridden virtual functions are documented in sparse_matrix.h.

Author

Benjamin S. Kirk

Date

2008

Definition at line 63 of file trilinos_epetra_matrix.h.

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

EpetraMatrix() [1/4]

template<typename T >

libMesh::EpetraMatrix< T >::EpetraMatrix

(

const Parallel::Communicator &

comm

)

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 297 of file trilinos_epetra_matrix.C.

                                                               :
  SparseMatrix<T>(comm),
  _destroy_mat_on_exit(true),
  _use_transpose(false)
{}

EpetraMatrix() [2/4]

template<typename T >

libMesh::EpetraMatrix< T >::EpetraMatrix	(	Epetra_FECrsMatrix *	m,
		const Parallel::Communicator &	comm
	)

Constructor. Creates a EpetraMatrix assuming you already have a valid Epetra_FECrsMatrix object. In this case, m is NOT destroyed by the EpetraMatrix destructor when this object goes out of scope. This allows ownership of m to remain with the original creator, and to simply provide additional functionality with the EpetraMatrix.

Definition at line 307 of file trilinos_epetra_matrix.C.

References libMesh::SparseMatrix< T >::_is_initialized, libMesh::EpetraMatrix< T >::_mat, and libMesh::EpetraMatrix< T >::m().

                                                                 :
  SparseMatrix<T>(comm),
  _destroy_mat_on_exit(false),
  _use_transpose(false) // dumb guess is the best we can do...
{
  this->_mat = m;
  this->_is_initialized = true;
}

EpetraMatrix() [3/4]

template<typename T>

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

delete

This class manages the lifetime of an Epetra_FECrsMatrix manually, so we don't want to allow any automatic copy/move functions to be generated, and we can't default the destructor.

EpetraMatrix() [4/4]

template<typename T>

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

delete

~EpetraMatrix()

template<typename T >

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

virtual

Definition at line 321 of file trilinos_epetra_matrix.C.

{
  this->clear();
}

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

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

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

  {
    libmesh_not_implemented();
  }

add() [1/2]

template<typename T >

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

overridevirtual

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 402 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and value.

{
  libmesh_assert (this->initialized());

  int
    epetra_i = static_cast<int>(i),
    epetra_j = static_cast<int>(j);

  T epetra_value = value;

  _mat->SumIntoGlobalValues (epetra_i, 1, &epetra_value, &epetra_j);
}

add() [2/2]

template<typename T >

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

overridevirtual

Compute A += a*X for scalar a, matrix X.

Note

It is advisable to not only allocate appropriate memory with init(), but also explicitly zero the terms of this whenever you add a non-zero value to X.

X will be closed, if not already done, before performing any work.

Implements libMesh::SparseMatrix< T >.

Definition at line 429 of file trilinos_epetra_matrix.C.

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

{
#ifdef LIBMESH_TRILINOS_HAVE_EPETRAEXT
  libmesh_assert (this->initialized());

  // sanity check. but this cannot avoid
  // crash due to incompatible sparsity structure...
  libmesh_assert_equal_to (this->m(), X_in.m());
  libmesh_assert_equal_to (this->n(), X_in.n());

  const EpetraMatrix<T> * X =
    cast_ptr<const EpetraMatrix<T> *> (&X_in);

  EpetraExt::MatrixMatrix::Add (*X->_mat, false, a_in, *_mat, 1.);
#else
  libmesh_error_msg("ERROR: EpetraExt is required for EpetraMatrix::add()!");
#endif
}

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  )

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

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

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

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  )

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

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

add_matrix() [1/2]

template<typename T >

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

overridevirtual

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 243 of file trilinos_epetra_matrix.C.

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

{
  libmesh_assert (this->initialized());

  const numeric_index_type m = dm.m();
  const numeric_index_type n = dm.n();

  libmesh_assert_equal_to (rows.size(), m);
  libmesh_assert_equal_to (cols.size(), n);

  _mat->SumIntoGlobalValues(m, numeric_trilinos_cast(rows.data()),
                            n, numeric_trilinos_cast(cols.data()),
                            dm.get_values().data());
}

add_matrix() [2/2]

template<typename T >

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

overridevirtual

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 420 of file trilinos_epetra_matrix.C.

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

attach_dof_map()

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

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

  { _dof_map = &dof_map; }

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

staticinherited

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

Definition at line 130 of file sparse_matrix.C.

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

clear()

template<typename T >

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

overridevirtual

Restores the SparseMatrix<T> to a pristine state.

Implements libMesh::SparseMatrix< T >.

Definition at line 205 of file trilinos_epetra_matrix.C.

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

{
  //  delete _mat;
  //  delete _map;

  this->_is_initialized = false;

  libmesh_assert (!this->initialized());
}

close()

template<typename T >

void libMesh::EpetraMatrix< T >::close ( )

overridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 329 of file trilinos_epetra_matrix.C.

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

{
  libmesh_assert(_mat);

  _mat->GlobalAssemble();
}

closed()

template<typename T >

bool libMesh::EpetraMatrix< T >::closed ( ) const

overridevirtual

Returns

true if the matrix has been assembled.

Implements libMesh::SparseMatrix< T >.

Definition at line 487 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert(this->_mat);

  return this->_mat->Filled();
}

comm()

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

inlineinherited

Returns

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

Definition at line 89 of file parallel_object.h.

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::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::ImplicitSystem::add_matrix(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), 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::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::PetscDMWrapper::check_section_n_dofs(), 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::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), 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::MeshRefinement::eliminate_unrefined_patches(), libMesh::EpetraVector< T >::EpetraVector(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), 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_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(), 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::FEMSystem::mesh_position_set(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), 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::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), 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::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::CheckpointIO::select_split_config(), 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::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), 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().

  { return _communicator; }

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

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

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

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

{
  _enable_print_counter = false;
  return;
}

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.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

flush()

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

{ close(); }

get_diagonal()

template<typename T >

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

overridevirtual

Copies the diagonal part of the matrix into dest.

Implements libMesh::SparseMatrix< T >.

Definition at line 266 of file trilinos_epetra_matrix.C.

References libMesh::EpetraVector< T >::vec().

{
  // Convert vector to EpetraVector.
  EpetraVector<T> * epetra_dest = cast_ptr<EpetraVector<T> *>(&dest);

  // Call Epetra function.
  _mat->ExtractDiagonalCopy(*(epetra_dest->vec()));
}

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.

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 (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
}

get_transpose()

template<typename T >

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

overridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 278 of file trilinos_epetra_matrix.C.

References libMesh::EpetraMatrix< T >::_mat, and libMesh::EpetraMatrix< T >::_use_transpose.

{
  // Make sure the SparseMatrix passed in is really a EpetraMatrix
  EpetraMatrix<T> & epetra_dest = cast_ref<EpetraMatrix<T> &>(dest);

  // We currently only support calling get_transpose() with ourself
  // as the destination. Previously, this called the default copy
  // constructor which was not safe because this class manually
  // manages memory.
  if (&epetra_dest != this)
    libmesh_not_implemented();

  epetra_dest._use_transpose = !epetra_dest._use_transpose;
  epetra_dest._mat->SetUseTranspose(epetra_dest._use_transpose);
}

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.

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

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

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

  p.first++;
}

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.

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

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

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

  p.second++;
}

init() [1/2]

template<typename T>

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

overridevirtual

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

init() [2/2]

template<typename T >

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

overridevirtual

Initialize this matrix using the sparsity structure computed by dof_map.

Implements libMesh::SparseMatrix< T >.

Definition at line 176 of file trilinos_epetra_matrix.C.

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

{
  libmesh_assert(this->_dof_map);

  {
    // Clear initialized matrices
    if (this->initialized())
      this->clear();

    this->_is_initialized = true;
  }


  _mat = new Epetra_FECrsMatrix (Copy, *_graph);
}

initialized()

template<typename T>

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

inlinevirtualinherited

Returns

true if the matrix has been initialized, false otherwise.

Definition at line 104 of file sparse_matrix.h.

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

{ return _is_initialized; }

l1_norm()

template<typename T >

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

overridevirtual

Returns

The -norm of the matrix, that is the max column sum:

This is the natural matrix norm that is compatible with the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)

Implements libMesh::SparseMatrix< T >.

Definition at line 218 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::Real.

{
  libmesh_assert (this->initialized());

  libmesh_assert(_mat);

  return static_cast<Real>(_mat->NormOne());
}

linfty_norm()

template<typename T >

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

overridevirtual

Returns

The -norm of the matrix, that is the max row sum:

This is the natural matrix norm that is compatible to the -norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)

Implements libMesh::SparseMatrix< T >.

Definition at line 230 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and libMesh::Real.

{
  libmesh_assert (this->initialized());


  libmesh_assert(_mat);

  return static_cast<Real>(_mat->NormInf());
}

m()

template<typename T >

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

overridevirtual

Returns

The row-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 339 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

Referenced by libMesh::EpetraMatrix< T >::EpetraMatrix().

{
  libmesh_assert (this->initialized());

  return static_cast<numeric_index_type>(_mat->NumGlobalRows());
}

mat() [1/2]

template<typename T>

Epetra_FECrsMatrix* libMesh::EpetraMatrix< T >::mat ( )

inline

Returns

The raw Epetra_FECrsMatrix pointer.

Note

This is generally not required in user-level code.

Don't do anything crazy like deleting the pointer, or very bad things will likely happen!

Definition at line 192 of file trilinos_epetra_matrix.h.

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

Referenced by libMesh::TrilinosPreconditioner< T >::init(), libMesh::NoxNonlinearSolver< Number >::solve(), and libMesh::AztecLinearSolver< T >::solve().

{ libmesh_assert(_mat); return _mat; }

mat() [2/2]

template<typename T>

const Epetra_FECrsMatrix* libMesh::EpetraMatrix< T >::mat ( ) const

inline

Definition at line 194 of file trilinos_epetra_matrix.h.

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

{ libmesh_assert(_mat); return _mat; }

n()

template<typename T >

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

overridevirtual

Returns

The column-dimension of the matrix.

Implements libMesh::SparseMatrix< T >.

Definition at line 349 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

{
  libmesh_assert (this->initialized());

  return static_cast<numeric_index_type>(_mat->NumGlobalCols());
}

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.

References libMesh::ReferenceCounter::_n_objects.

  { return _n_objects; }

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 95 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), 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::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::MeshBase::get_info(), 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::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::MeshBase::partition(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), 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(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), 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().

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

need_full_sparsity_pattern()

template<typename T>

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

inlineoverridevirtual

The EpetraMatrix needs the full sparsity pattern.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 103 of file trilinos_epetra_matrix.h.

  { return true; }

operator()()

template<typename T >

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

overridevirtual

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 452 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert(this->_mat);
  libmesh_assert (this->_mat->MyGlobalRow(static_cast<int>(i)));
  libmesh_assert_greater_equal (i, this->row_start());
  libmesh_assert_less (i, this->row_stop());


  int row_length;
  int * row_indices;
  double * values;

  _mat->ExtractMyRowView (i-this->row_start(),
                          row_length,
                          values,
                          row_indices);

  //libMesh::out << "row_length=" << row_length << std::endl;

  int * index = std::lower_bound (row_indices, row_indices+row_length, j);

  libmesh_assert_less (*index, row_length);
  libmesh_assert_equal_to (static_cast<numeric_index_type>(row_indices[*index]), j);

  //libMesh::out << "val=" << values[*index] << std::endl;

  return values[*index];
}

operator=() [1/2]

template<typename T>

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

delete

operator=() [2/2]

template<typename T>

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

delete

print() [1/2]

template<>

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

inherited

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 (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;
    }
}

print() [2/2]

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

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

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.

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

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

print_matlab()

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

  {
    libmesh_not_implemented();
  }

print_personal()

template<typename T >

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

overridevirtual

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

Implements libMesh::SparseMatrix< T >.

Definition at line 508 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert(_mat);

  os << *_mat;
}

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

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

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::FEMSystem::assembly(), libMesh::EquationSystems::build_discontinuous_solution_vector(), 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::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::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::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::MeshBase::get_info(), 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::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::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::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(), libMesh::MeshRefinement::make_coarsening_compatible(), 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::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::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), 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::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< T >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), 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_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::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::System::write_parallel_data(), 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::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().

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

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

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

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

row_start()

template<typename T >

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

overridevirtual

Returns

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

Implements libMesh::SparseMatrix< T >.

Definition at line 359 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert(_map);

  return static_cast<numeric_index_type>(_map->MinMyGID());
}

row_stop()

template<typename T >

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

overridevirtual

Returns

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

Implements libMesh::SparseMatrix< T >.

Definition at line 370 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

{
  libmesh_assert (this->initialized());
  libmesh_assert(_map);

  return static_cast<numeric_index_type>(_map->MaxMyGID())+1;
}

set()

template<typename T >

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

overridevirtual

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 381 of file trilinos_epetra_matrix.C.

References libMesh::initialized(), and value.

{
  libmesh_assert (this->initialized());

  int
    epetra_i = static_cast<int>(i),
    epetra_j = static_cast<int>(j);

  T epetra_value = value;

  if (_mat->Filled())
    _mat->ReplaceGlobalValues (epetra_i, 1, &epetra_value, &epetra_j);
  else
    _mat->InsertGlobalValues (epetra_i, 1, &epetra_value, &epetra_j);
}

swap()

template<typename T >

void libMesh::EpetraMatrix< T >::swap

(

EpetraMatrix< T > &

m

)

Swaps the internal data pointers, no actual values are swapped.

Definition at line 497 of file trilinos_epetra_matrix.C.

References libMesh::EpetraMatrix< T >::_destroy_mat_on_exit, libMesh::EpetraMatrix< T >::_mat, and swap().

{
  std::swap(_mat, m._mat);
  std::swap(_destroy_mat_on_exit, m._destroy_mat_on_exit);
}

update_sparsity_pattern()

template<typename T >

void libMesh::EpetraMatrix< T >::update_sparsity_pattern ( const SparsityPattern::Graph &  sparsity_pattern )

overridevirtual

Updates the matrix sparsity pattern. This will tell the underlying matrix storage scheme how to map the elements.

Reimplemented from libMesh::SparseMatrix< T >.

Definition at line 41 of file trilinos_epetra_matrix.C.

References data, libMesh::TriangleWrapper::init(), libMesh::initialized(), and std::min().

{
  // clear data, start over
  this->clear ();

  // big trouble if this fails!
  libmesh_assert(this->_dof_map);

  const numeric_index_type n_rows = cast_int<numeric_index_type>
    (sparsity_pattern.size());

  const numeric_index_type m   = this->_dof_map->n_dofs();
  const numeric_index_type n   = m;
  const numeric_index_type n_l = this->_dof_map->n_dofs_on_processor(this->processor_id());
  const numeric_index_type m_l = n_l;

  // error checking
#ifndef NDEBUG
  {
    libmesh_assert_equal_to (n, m);
    libmesh_assert_equal_to (n_l, m_l);

    numeric_index_type
      summed_m_l = m_l,
      summed_n_l = n_l;

    this->comm().sum (summed_m_l);
    this->comm().sum (summed_n_l);

    libmesh_assert_equal_to (m, summed_m_l);
    libmesh_assert_equal_to (n, summed_n_l);
  }
#endif

  // build a map defining the data distribution
  _map = new Epetra_Map (static_cast<int>(m),
                         m_l,
                         0,
                         Epetra_MpiComm (this->comm().get()));

  libmesh_assert_equal_to (static_cast<numeric_index_type>(_map->NumGlobalPoints()), m);
  libmesh_assert_equal_to (static_cast<numeric_index_type>(_map->MaxAllGID()+1), m);

  const std::vector<numeric_index_type> & n_nz = this->_dof_map->get_n_nz();
  const std::vector<numeric_index_type> & n_oz = this->_dof_map->get_n_oz();

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

  // Epetra wants the total number of nonzeros, both local and remote.
  std::vector<int> n_nz_tot;  n_nz_tot.reserve(n_nz.size());

  for (numeric_index_type i=0; i<n_nz.size(); i++)
    n_nz_tot.push_back(std::min(n_nz[i] + n_oz[i], n));

  if (m==0)
    return;

  _graph = new Epetra_CrsGraph(Copy, *_map, n_nz_tot.data());

  // Tell the matrix about its structure.  Initialize it
  // to zero.
  for (numeric_index_type i=0; i<n_rows; i++)
    _graph->InsertGlobalIndices(_graph->GRID(i),
                                cast_int<numeric_index_type>(sparsity_pattern[i].size()),
                                const_cast<int *>(reinterpret_cast<const int *>(sparsity_pattern[i].data())));

  _graph->FillComplete();

  //Initialize the matrix
  libmesh_assert (!this->initialized());
  this->init ();
  libmesh_assert (this->initialized());
}

vector_mult()

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

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

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

vector_mult_add()

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

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

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

zero()

template<typename T >

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

overridevirtual

Set all entries to 0.

Implements libMesh::SparseMatrix< T >.

Definition at line 195 of file trilinos_epetra_matrix.C.

References libMesh::initialized().

{
  libmesh_assert (this->initialized());

  _mat->Scale(0.0);
}

zero_rows()

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

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

Member Data Documentation

_communicator

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

protectedinherited

Definition at line 107 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().

_destroy_mat_on_exit

template<typename T>

bool libMesh::EpetraMatrix< T >::_destroy_mat_on_exit

private

This boolean value should only be set to false for the constructor which takes an Epetra_FECrsMatrix object.

Definition at line 218 of file trilinos_epetra_matrix.h.

Referenced by libMesh::EpetraMatrix< T >::swap().

_dof_map

template<typename T>

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

protectedinherited

The DofMap object associated with this object.

Definition at line 425 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().

_graph

template<typename T>

Epetra_CrsGraph* libMesh::EpetraMatrix< T >::_graph

private

Holds the sparsity pattern.

Definition at line 212 of file trilinos_epetra_matrix.h.

_is_initialized

template<typename T>

bool libMesh::SparseMatrix< T >::_is_initialized

protectedinherited

Flag indicating whether or not the matrix has been initialized.

Definition at line 430 of file sparse_matrix.h.

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

_map

template<typename T>

Epetra_Map* libMesh::EpetraMatrix< T >::_map

private

Holds the distributed Map.

Definition at line 207 of file trilinos_epetra_matrix.h.

_mat

template<typename T>

Epetra_FECrsMatrix* libMesh::EpetraMatrix< T >::_mat

private

Actual Epetra datatype to hold matrix entries.

Definition at line 202 of file trilinos_epetra_matrix.h.

Referenced by libMesh::EpetraMatrix< T >::EpetraMatrix(), libMesh::EpetraMatrix< T >::get_transpose(), libMesh::EpetraMatrix< T >::mat(), and libMesh::EpetraMatrix< T >::swap().

_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().

_use_transpose

template<typename T>

bool libMesh::EpetraMatrix< T >::_use_transpose

private

Epetra has no GetUseTranspose so we need to keep track of whether we're transposed manually.

Definition at line 224 of file trilinos_epetra_matrix.h.

Referenced by libMesh::EpetraMatrix< T >::get_transpose().

---

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

• trilinos_epetra_matrix.h
• trilinos_epetra_matrix.C