#include <eigen_solver.h>

Inheritance diagram for libMesh::EigenSolver< T >:

Public Member Functions
	EigenSolver (const Parallel::Communicator &comm_in LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
virtual	~EigenSolver ()
bool	initialized () const
virtual void	clear ()
virtual void	init ()=0
EigenSolverType	eigen_solver_type () const
EigenProblemType	eigen_problem_type () const
PositionOfSpectrum	position_of_spectrum () const
void	set_eigensolver_type (const EigenSolverType est)
void	set_eigenproblem_type (EigenProblemType ept)
void	set_position_of_spectrum (PositionOfSpectrum pos)
virtual std::pair< unsigned int, unsigned int >	solve_standard (SparseMatrix< T > &matrix_A, int nev, int ncv, const double tol, const unsigned int m_its)=0
virtual std::pair< unsigned int, unsigned int >	solve_standard (ShellMatrix< T > &matrix_A, int nev, int ncv, const double tol, const unsigned int m_its)=0
virtual std::pair< unsigned int, unsigned int >	solve_generalized (SparseMatrix< T > &matrix_A, SparseMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its)=0
virtual std::pair< unsigned int, unsigned int >	solve_generalized (ShellMatrix< T > &matrix_A, SparseMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its)=0
virtual std::pair< unsigned int, unsigned int >	solve_generalized (SparseMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its)=0
virtual std::pair< unsigned int, unsigned int >	solve_generalized (ShellMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its)=0
virtual std::pair< Real, Real >	get_eigenpair (unsigned int i, NumericVector< T > &solution)=0
virtual std::pair< Real, Real >	get_eigenvalue (unsigned int i)=0
virtual void	attach_deflation_space (NumericVector< T > &deflation_vector)=0
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
Static Public Member Functions
static UniquePtr< EigenSolver < T > >	build (const Parallel::Communicator &comm_in LIBMESH_CAN_DEFAULT_TO_COMMWORLD, const SolverPackage solver_package=SLEPC_SOLVERS)
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
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Protected Attributes
EigenSolverType	_eigen_solver_type
EigenProblemType	_eigen_problem_type
PositionOfSpectrum	_position_of_spectrum
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

Detailed Description

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

This class provides an interface to solvers for eigenvalue problems.

Definition at line 53 of file eigen_solver.h.

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

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

Definition at line 113 of file reference_counter.h.

Constructor & Destructor Documentation

template<typename T >

libMesh::EigenSolver< T >::EigenSolver ( const Parallel::Communicator &comm_in LIBMESH_CAN_DEFAULT_TO_COMMWORLD ) [inline]

Constructor. Initializes Solver data structures

Definition at line 246 of file eigen_solver.h.

                                                                :
  ParallelObject(comm_in),
  _eigen_solver_type    (ARNOLDI),
  _eigen_problem_type   (NHEP),
  _position_of_spectrum (LARGEST_MAGNITUDE),
  _is_initialized       (false)
{
}

template<typename T >

libMesh::EigenSolver< T >::~EigenSolver ( ) [inline, virtual]

Destructor.

Definition at line 259 of file eigen_solver.h.

{
  this->clear ();
}

Member Function Documentation

template<typename T >

virtual void libMesh::EigenSolver< T >::attach_deflation_space ( NumericVector< T > & deflation_vector ) [pure virtual]

Attach a deflation space defined by a single vector.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

UniquePtr< EigenSolver< T > > libMesh::EigenSolver< T >::build	(	const Parallel::Communicator &comm_in	LIBMESH_CAN_DEFAULT_TO_COMMWORLD,
		const SolverPackage	solver_package = `SLEPC_SOLVERS`
	)		`[static]`

Builds an EigenSolver using the linear solver package specified by solver_package

Definition at line 36 of file eigen_solver.C.

References libMesh::SLEPC_SOLVERS.

{
  // Build the appropriate solver
  switch (solver_package)
    {

#ifdef LIBMESH_HAVE_SLEPC
    case SLEPC_SOLVERS:
      return UniquePtr<EigenSolver<T> >(new SlepcEigenSolver<T>(comm));
#endif

    default:
      libmesh_error_msg("ERROR:  Unrecognized eigen solver package: " << solver_package);
    }

  return UniquePtr<EigenSolver<T> >();
}

template<typename T >

virtual void libMesh::EigenSolver< T >::clear ( ) [inline, virtual]

Release all memory and clear data structures.

Reimplemented in libMesh::SlepcEigenSolver< T >.

Definition at line 87 of file eigen_solver.h.

{}

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const [inline, inherited]

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

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

  { return _communicator; }

void libMesh::ReferenceCounter::disable_print_counter_info ( ) [static, inherited]

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

template<typename T >

EigenProblemType libMesh::EigenSolver< T >::eigen_problem_type ( ) const [inline]

Returns the type of the eigen problem.

Definition at line 102 of file eigen_solver.h.

References libMesh::EigenSolver< T >::_eigen_problem_type.

{ return _eigen_problem_type;}

template<typename T >

EigenSolverType libMesh::EigenSolver< T >::eigen_solver_type ( ) const [inline]

Returns the type of eigensolver to use.

Definition at line 97 of file eigen_solver.h.

References libMesh::EigenSolver< T >::_eigen_solver_type.

{ return _eigen_solver_type; }

void libMesh::ReferenceCounter::enable_print_counter_info ( ) [static, inherited]

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

template<typename T >

virtual std::pair<Real, Real> libMesh::EigenSolver< T >::get_eigenpair	(	unsigned int	i,
		NumericVector< T > &	solution
	)		`[pure virtual]`

Returns the ith eigenvalue (real and imaginary part), and copies the \ ith eigen vector to the solution vector.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

virtual std::pair<Real, Real> libMesh::EigenSolver< T >::get_eigenvalue ( unsigned int i ) [pure virtual]

Returns the ith eigenvalue (real and imaginary part). Same as above function, except it does copy the eigenvector.

Implemented in libMesh::SlepcEigenSolver< T >.

std::string libMesh::ReferenceCounter::get_info ( ) [static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream oss;

  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";

  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name ) [inline, protected, inherited]

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

Definition at line 163 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++;
}

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name ) [inline, protected, inherited]

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

Definition at line 176 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++;
}

template<typename T >

virtual void libMesh::EigenSolver< T >::init ( ) [pure virtual]

Initialize data structures if not done so already.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

bool libMesh::EigenSolver< T >::initialized ( ) const [inline]

Returns:: true if the data structures are initialized, false otherwise.

Definition at line 81 of file eigen_solver.h.

References libMesh::EigenSolver< T >::_is_initialized.

{ return _is_initialized; }

static unsigned int libMesh::ReferenceCounter::n_objects ( ) [inline, static, inherited]

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

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

  { return _n_objects; }

processor_id_type libMesh::ParallelObject::n_processors ( ) const [inline, inherited]

Returns:: the number of processors in the group.

Definition at line 92 of file parallel_object.h.

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

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

template<typename T >

PositionOfSpectrum libMesh::EigenSolver< T >::position_of_spectrum ( ) const [inline]

Returns the position of the spectrum to compute.

Definition at line 107 of file eigen_solver.h.

References libMesh::EigenSolver< T >::_position_of_spectrum.

  { return _position_of_spectrum;}

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out ) [static, inherited]

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

Definition at line 88 of file reference_counter.C.

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

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

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

processor_id_type libMesh::ParallelObject::processor_id ( ) const [inline, inherited]

Returns:: the rank of this processor in the group.

Definition at line 98 of file parallel_object.h.

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

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

template<typename T >

void libMesh::EigenSolver< T >::set_eigenproblem_type ( EigenProblemType ept ) [inline]

Sets the type of the eigenproblem.

Definition at line 119 of file eigen_solver.h.

References libMesh::EigenSolver< T >::_eigen_problem_type.

  {_eigen_problem_type = ept;}

template<typename T >

void libMesh::EigenSolver< T >::set_eigensolver_type ( const EigenSolverType est ) [inline]

Sets the type of eigensolver to use.

Definition at line 113 of file eigen_solver.h.

References libMesh::EigenSolver< T >::_eigen_solver_type.

  { _eigen_solver_type = est; }

template<typename T >

void libMesh::EigenSolver< T >::set_position_of_spectrum ( PositionOfSpectrum pos ) [inline]

Sets the position of the spectrum.

Definition at line 125 of file eigen_solver.h.

References libMesh::EigenSolver< T >::_position_of_spectrum.

  {_position_of_spectrum= pos;}

template<typename T >

virtual std::pair<unsigned int, unsigned int> libMesh::EigenSolver< T >::solve_generalized	(	SparseMatrix< T > &	matrix_A,
		SparseMatrix< T > &	matrix_B,
		int	nev,
		int	ncv,
		const double	tol,
		const unsigned int	m_its
	)		`[pure virtual]`

Solves the generalized eigen problem when both matrix_A and matrix_B are of type SparseMatrix and returns the number of converged eigenpairs and the number of iterations.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

virtual std::pair<unsigned int, unsigned int> libMesh::EigenSolver< T >::solve_generalized	(	ShellMatrix< T > &	matrix_A,
		SparseMatrix< T > &	matrix_B,
		int	nev,
		int	ncv,
		const double	tol,
		const unsigned int	m_its
	)		`[pure virtual]`

Solves the generalized eigen problem when matrix_A is a ShellMatrix and matrix_B is a SparseMatrix.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

virtual std::pair<unsigned int, unsigned int> libMesh::EigenSolver< T >::solve_generalized	(	SparseMatrix< T > &	matrix_A,
		ShellMatrix< T > &	matrix_B,
		int	nev,
		int	ncv,
		const double	tol,
		const unsigned int	m_its
	)		`[pure virtual]`

Solves the generalized eigen problem when matrix_A is a SparseMatrix and matrix_B is a ShellMatrix.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

virtual std::pair<unsigned int, unsigned int> libMesh::EigenSolver< T >::solve_generalized	(	ShellMatrix< T > &	matrix_A,
		ShellMatrix< T > &	matrix_B,
		int	nev,
		int	ncv,
		const double	tol,
		const unsigned int	m_its
	)		`[pure virtual]`

Solves the generalized eigen problem when both matrix_A and matrix_B are of type ShellMatrix.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

virtual std::pair<unsigned int, unsigned int> libMesh::EigenSolver< T >::solve_standard	(	SparseMatrix< T > &	matrix_A,
		int	nev,
		int	ncv,
		const double	tol,
		const unsigned int	m_its
	)		`[pure virtual]`

Solves the standard eigen problem when matrix_A is a SparseMatrix, and returns the number of converged eigenpairs and the number of iterations.

Implemented in libMesh::SlepcEigenSolver< T >.

template<typename T >

virtual std::pair<unsigned int, unsigned int> libMesh::EigenSolver< T >::solve_standard	(	ShellMatrix< T > &	matrix_A,
		int	nev,
		int	ncv,
		const double	tol,
		const unsigned int	m_its
	)		`[pure virtual]`