libMesh
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
libMesh::SlepcEigenSolver< T > Class Template Reference

This class provides an interface to the SLEPc eigenvalue solver library from http://slepc.upv.es/. More...

#include <slepc_eigen_solver.h>

Inheritance diagram for libMesh::SlepcEigenSolver< T >:
[legend]

Public Member Functions

 SlepcEigenSolver (const Parallel::Communicator &comm_in LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
 Constructor. More...
 
 ~SlepcEigenSolver ()
 Destructor. More...
 
virtual void clear () libmesh_override
 Release all memory and clear data structures. More...
 
virtual void init () libmesh_override
 Initialize data structures if not done so already. More...
 
virtual std::pair< unsigned int, unsigned intsolve_standard (SparseMatrix< T > &matrix_A, int nev, int ncv, const double tol, const unsigned int m_its) libmesh_override
 This function calls the SLEPc solver to compute the eigenpairs of the SparseMatrix matrix_A. More...
 
virtual std::pair< unsigned int, unsigned intsolve_standard (ShellMatrix< T > &shell_matrix, int nev, int ncv, const double tol, const unsigned int m_its) libmesh_override
 Same as above except that matrix_A is a ShellMatrix in this case. More...
 
virtual std::pair< unsigned int, unsigned intsolve_generalized (SparseMatrix< T > &matrix_A, SparseMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) libmesh_override
 This function calls the SLEPc solver to compute the eigenpairs for the generalized eigenproblem defined by the matrix_A and matrix_B, which are of type SparseMatrix. More...
 
virtual std::pair< unsigned int, unsigned intsolve_generalized (ShellMatrix< T > &matrix_A, SparseMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) libmesh_override
 Solve generalized eigenproblem when matrix_A is of type ShellMatrix, matrix_B is of type SparseMatrix. More...
 
virtual std::pair< unsigned int, unsigned intsolve_generalized (SparseMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) libmesh_override
 Solve generalized eigenproblem when matrix_A is of type SparseMatrix, matrix_B is of type ShellMatrix. More...
 
virtual std::pair< unsigned int, unsigned intsolve_generalized (ShellMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) libmesh_override
 Solve generalized eigenproblem when both matrix_A and matrix_B are of type ShellMatrix. More...
 
virtual std::pair< Real, Realget_eigenpair (dof_id_type i, NumericVector< T > &solution_in) libmesh_override
 
virtual std::pair< Real, Realget_eigenvalue (dof_id_type i) libmesh_override
 Same as above, but does not copy the eigenvector. More...
 
Real get_relative_error (unsigned int i)
 
virtual void attach_deflation_space (NumericVector< T > &deflation_vector) libmesh_override
 Attach a deflation space defined by a single vector. More...
 
virtual void set_initial_space (NumericVector< T > &initial_space_in) libmesh_override
 Use initial_space_in as the initial guess. More...
 
EPS eps ()
 
bool initialized () const
 
bool get_close_matrix_before_solve () const
 
void set_close_matrix_before_solve (bool val)
 Set the flag which controls whether libmesh closes the eigenproblem matrices before solving. More...
 
EigenSolverType eigen_solver_type () const
 
EigenProblemType eigen_problem_type () const
 
PositionOfSpectrum position_of_spectrum () const
 
void set_eigensolver_type (const EigenSolverType est)
 Sets the type of eigensolver to use. More...
 
void set_eigenproblem_type (EigenProblemType ept)
 Sets the type of the eigenproblem. More...
 
void set_position_of_spectrum (PositionOfSpectrum pos)
 Sets the position of the spectrum. More...
 
void set_position_of_spectrum (Real pos)
 
void set_position_of_spectrum (Real pos, PositionOfSpectrum target)
 
void set_solver_configuration (SolverConfiguration &solver_configuration)
 Set the solver configuration object. More...
 
const Parallel::Communicatorcomm () 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)
 Builds an EigenSolver 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

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

EigenSolverType _eigen_solver_type
 Enum stating which type of eigensolver to use. More...
 
EigenProblemType _eigen_problem_type
 Enum stating which type of eigen problem we deal with. More...
 
PositionOfSpectrum _position_of_spectrum
 Enum stating where to evaluate the spectrum. More...
 
bool _is_initialized
 Flag indicating if the data structures have been initialized. More...
 
SolverConfiguration_solver_configuration
 Optionally store a SolverOptions object that can be used to set parameters like solver type, tolerances and iteration limits. More...
 
Real _target_val
 
bool _close_matrix_before_solve
 
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...
 

Private Member Functions

std::pair< unsigned int, unsigned int_solve_standard_helper (Mat mat, int nev, int ncv, const double tol, const unsigned int m_its)
 Helper function that actually performs the standard eigensolve. More...
 
std::pair< unsigned int, unsigned int_solve_generalized_helper (Mat mat_A, Mat mat_B, int nev, int ncv, const double tol, const unsigned int m_its)
 Helper function that actually performs the generalized eigensolve. More...
 
void set_slepc_solver_type ()
 Tells Slepc to use the user-specified solver stored in _eigen_solver_type. More...
 
void set_slepc_problem_type ()
 Tells Slepc to deal with the type of problem stored in _eigen_problem_type. More...
 
void set_slepc_position_of_spectrum ()
 Tells Slepc to compute the spectrum at the position stored in _position_of_spectrum. More...
 

Static Private Member Functions

static PetscErrorCode _petsc_shell_matrix_mult (Mat mat, Vec arg, Vec dest)
 Internal function if shell matrix mode is used, this just calls the shell matrix's matrix multiplication function. More...
 
static PetscErrorCode _petsc_shell_matrix_get_diagonal (Mat mat, Vec dest)
 Internal function if shell matrix mode is used, this just calls the shell matrix's get_diagonal function. More...
 

Private Attributes

EPS _eps
 Eigenproblem solver context. More...
 

Detailed Description

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

This class provides an interface to the SLEPc eigenvalue solver library from http://slepc.upv.es/.

Author
Steffen Peterson
Date
2005 EigenSolver implementation based on SLEPc.

Definition at line 48 of file slepc_eigen_solver.h.

Member Typedef Documentation

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

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

template<typename T >
libMesh::SlepcEigenSolver< T >::SlepcEigenSolver ( const Parallel::Communicator &comm_in  LIBMESH_CAN_DEFAULT_TO_COMMWORLD)

Constructor.

Initializes Petsc data structures

Definition at line 279 of file slepc_eigen_solver.h.

References libMesh::EigenSolver< T >::_eigen_problem_type, libMesh::EigenSolver< T >::_eigen_solver_type, libMesh::ARNOLDI, and libMesh::NHEP.

279  :
280  EigenSolver<T>(comm_in)
281 {
282  this->_eigen_solver_type = ARNOLDI;
283  this->_eigen_problem_type = NHEP;
284 }
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:268
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:273
template<typename T >
libMesh::SlepcEigenSolver< T >::~SlepcEigenSolver ( )

Destructor.

Definition at line 290 of file slepc_eigen_solver.h.

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

291 {
292  this->clear ();
293 }
virtual void clear() libmesh_override
Release all memory and clear data structures.

Member Function Documentation

template<typename T >
PetscErrorCode libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal ( Mat  mat,
Vec  dest 
)
staticprivate

Internal function if shell matrix mode is used, this just calls the shell matrix's get_diagonal function.

Required in order to use Jacobi preconditioning.

Definition at line 868 of file slepc_eigen_solver.C.

References libMesh::ParallelObject::comm(), libMesh::ctx, libMesh::ShellMatrix< T >::get_diagonal(), and ierr.

Referenced by libMesh::SlepcEigenSolver< T >::eps().

869 {
870  // Get the matrix context.
871  PetscErrorCode ierr=0;
872  void * ctx;
873  ierr = MatShellGetContext(mat,&ctx);
874 
876  PetscObjectGetComm((PetscObject)mat,&comm);
877  CHKERRABORT(comm,ierr);
878 
879  // Get user shell matrix object.
880  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
881 
882  // Make \p NumericVector instances around the vector.
883  PetscVector<T> dest_global(dest, shell_matrix.comm());
884 
885  // Call the user function.
886  shell_matrix.get_diagonal(dest_global);
887 
888  return ierr;
889 }
MPI_Comm communicator
Communicator object for talking with subsets of processors.
Definition: parallel.h:181
PetscErrorCode Vec Mat Mat void * ctx
PetscErrorCode ierr
const Parallel::Communicator & comm() const
template<typename T >
PetscErrorCode libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult ( Mat  mat,
Vec  arg,
Vec  dest 
)
staticprivate

Internal function if shell matrix mode is used, this just calls the shell matrix's matrix multiplication function.

See PetscLinearSolver for a similar implementation.

Definition at line 843 of file slepc_eigen_solver.C.

References libMesh::ParallelObject::comm(), libMesh::ctx, ierr, and libMesh::ShellMatrix< T >::vector_mult().

Referenced by libMesh::SlepcEigenSolver< T >::eps().

844 {
845  // Get the matrix context.
846  PetscErrorCode ierr=0;
847  void * ctx;
848  ierr = MatShellGetContext(mat,&ctx);
849 
851  PetscObjectGetComm((PetscObject)mat,&comm);
852  CHKERRABORT(comm,ierr);
853 
854  // Get user shell matrix object.
855  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
856 
857  // Make \p NumericVector instances around the vectors.
858  PetscVector<T> arg_global(arg, shell_matrix.comm());
859  PetscVector<T> dest_global(dest, shell_matrix.comm());
860 
861  // Call the user function.
862  shell_matrix.vector_mult(dest_global,arg_global);
863 
864  return ierr;
865 }
MPI_Comm communicator
Communicator object for talking with subsets of processors.
Definition: parallel.h:181
PetscErrorCode Vec Mat Mat void * ctx
PetscErrorCode ierr
const Parallel::Communicator & comm() const
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::_solve_generalized_helper ( Mat  mat_A,
Mat  mat_B,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
private

Helper function that actually performs the generalized eigensolve.

Definition at line 438 of file slepc_eigen_solver.C.

References ierr.

Referenced by libMesh::SlepcEigenSolver< T >::eps().

444 {
445  LOG_SCOPE("solve_generalized()", "SlepcEigenSolver");
446 
447  PetscErrorCode ierr=0;
448 
449  // converged eigen pairs and number of iterations
450  PetscInt nconv=0;
451  PetscInt its=0;
452 
453 #ifdef DEBUG
454  // The relative error.
455  PetscReal error, re, im;
456 
457  // Pointer to vectors of the real parts, imaginary parts.
458  PetscScalar kr, ki;
459 #endif
460 
461  // Set operators.
462  ierr = EPSSetOperators (_eps, mat_A, mat_B);
463  LIBMESH_CHKERR(ierr);
464 
465  //set the problem type and the position of the spectrum
468 
469  // Set eigenvalues to be computed.
470 #if SLEPC_VERSION_LESS_THAN(3,0,0)
471  ierr = EPSSetDimensions (_eps, nev, ncv);
472 #else
473  ierr = EPSSetDimensions (_eps, nev, ncv, PETSC_DECIDE);
474 #endif
475  LIBMESH_CHKERR(ierr);
476 
477 
478  // Set the tolerance and maximum iterations.
479  ierr = EPSSetTolerances (_eps, tol, m_its);
480  LIBMESH_CHKERR(ierr);
481 
482  // Set runtime options, e.g.,
483  // -eps_type <type>, -eps_nev <nev>, -eps_ncv <ncv>
484  // Similar to PETSc, these options will override those specified
485  // above as long as EPSSetFromOptions() is called _after_ any
486  // other customization routines.
487  ierr = EPSSetFromOptions (_eps);
488  LIBMESH_CHKERR(ierr);
489 
490  // If the SolverConfiguration object is provided, use it to override
491  // solver options.
492  if (this->_solver_configuration)
493  {
495  }
496 
497  // Solve the eigenproblem.
498  ierr = EPSSolve (_eps);
499  LIBMESH_CHKERR(ierr);
500 
501  // Get the number of iterations.
502  ierr = EPSGetIterationNumber (_eps, &its);
503  LIBMESH_CHKERR(ierr);
504 
505  // Get number of converged eigenpairs.
506  ierr = EPSGetConverged(_eps,&nconv);
507  LIBMESH_CHKERR(ierr);
508 
509 
510 #ifdef DEBUG
511  // ierr = PetscPrintf(this->comm().get(),
512  // "\n Number of iterations: %d\n"
513  // " Number of converged eigenpairs: %d\n\n", its, nconv);
514 
515  // Display eigenvalues and relative errors.
516  ierr = PetscPrintf(this->comm().get(),
517  " k ||Ax-kx||/|kx|\n"
518  " ----------------- -----------------\n" );
519  LIBMESH_CHKERR(ierr);
520 
521  for (PetscInt i=0; i<nconv; i++ )
522  {
523  ierr = EPSGetEigenpair(_eps, i, &kr, &ki, PETSC_NULL, PETSC_NULL);
524  LIBMESH_CHKERR(ierr);
525 
526 #if SLEPC_VERSION_LESS_THAN(3,6,0)
527  ierr = EPSComputeRelativeError(_eps, i, &error);
528 #else
529  ierr = EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error);
530 #endif
531  LIBMESH_CHKERR(ierr);
532 
533 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
534  re = PetscRealPart(kr);
535  im = PetscImaginaryPart(kr);
536 #else
537  re = kr;
538  im = ki;
539 #endif
540 
541  if (im != .0)
542  {
543  ierr = PetscPrintf(this->comm().get()," %9f%+9f i %12f\n", re, im, error);
544  LIBMESH_CHKERR(ierr);
545  }
546  else
547  {
548  ierr = PetscPrintf(this->comm().get()," %12f %12f\n", re, error);
549  LIBMESH_CHKERR(ierr);
550  }
551  }
552 
553  ierr = PetscPrintf(this->comm().get(),"\n" );
554  LIBMESH_CHKERR(ierr);
555 #endif // DEBUG
556 
557  // return the number of converged eigenpairs
558  // and the number of iterations
559  return std::make_pair(nconv, its);
560 }
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
Definition: eigen_solver.h:289
virtual void configure_solver()=0
Apply solver options to a particular solver.
void set_slepc_problem_type()
Tells Slepc to deal with the type of problem stored in _eigen_problem_type.
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
const Parallel::Communicator & comm() const
void set_slepc_position_of_spectrum()
Tells Slepc to compute the spectrum at the position stored in _position_of_spectrum.
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::_solve_standard_helper ( Mat  mat,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
private

Helper function that actually performs the standard eigensolve.

Definition at line 142 of file slepc_eigen_solver.C.

References ierr.

Referenced by libMesh::SlepcEigenSolver< T >::eps().

147 {
148  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
149 
150  PetscErrorCode ierr=0;
151 
152  // converged eigen pairs and number of iterations
153  PetscInt nconv=0;
154  PetscInt its=0;
155 
156 #ifdef DEBUG
157  // The relative error.
158  PetscReal error, re, im;
159 
160  // Pointer to vectors of the real parts, imaginary parts.
161  PetscScalar kr, ki;
162 #endif
163 
164  // Set operators.
165  ierr = EPSSetOperators (_eps, mat, PETSC_NULL);
166  LIBMESH_CHKERR(ierr);
167 
168  //set the problem type and the position of the spectrum
171 
172  // Set eigenvalues to be computed.
173 #if SLEPC_VERSION_LESS_THAN(3,0,0)
174  ierr = EPSSetDimensions (_eps, nev, ncv);
175 #else
176  ierr = EPSSetDimensions (_eps, nev, ncv, PETSC_DECIDE);
177 #endif
178  LIBMESH_CHKERR(ierr);
179  // Set the tolerance and maximum iterations.
180  ierr = EPSSetTolerances (_eps, tol, m_its);
181  LIBMESH_CHKERR(ierr);
182 
183  // Set runtime options, e.g.,
184  // -eps_type <type>, -eps_nev <nev>, -eps_ncv <ncv>
185  // Similar to PETSc, these options will override those specified
186  // above as long as EPSSetFromOptions() is called _after_ any
187  // other customization routines.
188  ierr = EPSSetFromOptions (_eps);
189  LIBMESH_CHKERR(ierr);
190 
191  // If the SolverConfiguration object is provided, use it to override
192  // solver options.
193  if (this->_solver_configuration)
194  {
196  }
197 
198  // Solve the eigenproblem.
199  ierr = EPSSolve (_eps);
200  LIBMESH_CHKERR(ierr);
201 
202  // Get the number of iterations.
203  ierr = EPSGetIterationNumber (_eps, &its);
204  LIBMESH_CHKERR(ierr);
205 
206  // Get number of converged eigenpairs.
207  ierr = EPSGetConverged(_eps,&nconv);
208  LIBMESH_CHKERR(ierr);
209 
210 
211 #ifdef DEBUG
212  // ierr = PetscPrintf(this->comm().get(),
213  // "\n Number of iterations: %d\n"
214  // " Number of converged eigenpairs: %d\n\n", its, nconv);
215 
216  // Display eigenvalues and relative errors.
217  ierr = PetscPrintf(this->comm().get(),
218  " k ||Ax-kx||/|kx|\n"
219  " ----------------- -----------------\n" );
220  LIBMESH_CHKERR(ierr);
221 
222  for (PetscInt i=0; i<nconv; i++ )
223  {
224  ierr = EPSGetEigenpair(_eps, i, &kr, &ki, PETSC_NULL, PETSC_NULL);
225  LIBMESH_CHKERR(ierr);
226 
227 #if SLEPC_VERSION_LESS_THAN(3,6,0)
228  ierr = EPSComputeRelativeError(_eps, i, &error);
229 #else
230  ierr = EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error);
231 #endif
232  LIBMESH_CHKERR(ierr);
233 
234 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
235  re = PetscRealPart(kr);
236  im = PetscImaginaryPart(kr);
237 #else
238  re = kr;
239  im = ki;
240 #endif
241 
242  if (im != .0)
243  {
244  ierr = PetscPrintf(this->comm().get()," %9f%+9f i %12f\n", re, im, error);
245  LIBMESH_CHKERR(ierr);
246  }
247  else
248  {
249  ierr = PetscPrintf(this->comm().get()," %12f %12f\n", re, error);
250  LIBMESH_CHKERR(ierr);
251  }
252  }
253 
254  ierr = PetscPrintf(this->comm().get(),"\n" );
255  LIBMESH_CHKERR(ierr);
256 #endif // DEBUG
257 
258  // return the number of converged eigenpairs
259  // and the number of iterations
260  return std::make_pair(nconv, its);
261 }
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
Definition: eigen_solver.h:289
virtual void configure_solver()=0
Apply solver options to a particular solver.
void set_slepc_problem_type()
Tells Slepc to deal with the type of problem stored in _eigen_problem_type.
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
const Parallel::Communicator & comm() const
void set_slepc_position_of_spectrum()
Tells Slepc to compute the spectrum at the position stored in _position_of_spectrum.
template<typename T >
void libMesh::SlepcEigenSolver< T >::attach_deflation_space ( NumericVector< T > &  deflation_vector)
virtual

Attach a deflation space defined by a single vector.

Implements libMesh::EigenSolver< T >.

Definition at line 793 of file slepc_eigen_solver.C.

References ierr, and libMesh::TriangleWrapper::init().

794 {
795  this->init();
796 
797  PetscErrorCode ierr = 0;
798 
799  // Make sure the input vector is actually a PetscVector
800  PetscVector<T> * deflation_vector_petsc_vec =
801  dynamic_cast<PetscVector<T> *>(&deflation_vector_in);
802 
803  if (!deflation_vector_petsc_vec)
804  libmesh_error_msg("Error attaching deflation space: input vector must be a PetscVector.");
805 
806  // Get a handle for the underlying Vec.
807  Vec deflation_vector = deflation_vector_petsc_vec->vec();
808 
809 #if SLEPC_VERSION_LESS_THAN(3,1,0)
810  ierr = EPSAttachDeflationSpace(_eps, 1, &deflation_vector, PETSC_FALSE);
811 #else
812  ierr = EPSSetDeflationSpace(_eps, 1, &deflation_vector);
813 #endif
814  LIBMESH_CHKERR(ierr);
815 }
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
virtual void init() libmesh_override
Initialize data structures if not done so already.
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 
)
staticinherited

Builds an EigenSolver using the linear solver package specified by solver_package.

Definition at line 37 of file eigen_solver.C.

References libMesh::SLEPC_SOLVERS.

39 {
40  // Build the appropriate solver
41  switch (solver_package)
42  {
43 
44 #ifdef LIBMESH_HAVE_SLEPC
45  case SLEPC_SOLVERS:
46  return UniquePtr<EigenSolver<T>>(new SlepcEigenSolver<T>(comm));
47 #endif
48 
49  default:
50  libmesh_error_msg("ERROR: Unrecognized eigen solver package: " << solver_package);
51  }
52 
53  return UniquePtr<EigenSolver<T>>();
54 }
const Parallel::Communicator & comm() const
template<typename T >
void libMesh::SlepcEigenSolver< T >::clear ( )
virtual

Release all memory and clear data structures.

Reimplemented from libMesh::EigenSolver< T >.

Definition at line 40 of file slepc_eigen_solver.C.

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

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

41 {
42  if (this->initialized())
43  {
44  this->_is_initialized = false;
45 
46  PetscErrorCode ierr=0;
47 
48  ierr = LibMeshEPSDestroy(&_eps);
49  LIBMESH_CHKERR(ierr);
50 
51  // SLEPc default eigenproblem solver
53  }
54 }
bool _is_initialized
Flag indicating if the data structures have been initialized.
Definition: eigen_solver.h:283
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
bool initialized() const
Definition: eigen_solver.h:82
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:268
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_preconditioner_apply(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_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::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< 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(), add_cube_convex_hull_to_mesh(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), 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::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), 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::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::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::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::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_nelem_target(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TopologyMap::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), 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::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(), libMesh::MeshSerializer::MeshSerializer(), LinearElasticityWithContact::move_mesh(), 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(), new_function_base(), 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::Partitioner::partition(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::SparseMatrix< T >::print(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), libMesh::MeshRefinement::test_unflagged(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), 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::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::XdrIO::write_serialized_bcs_helper(), 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().

88  { return _communicator; }
const Parallel::Communicator & _communicator
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 107 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

108 {
109  _enable_print_counter = false;
110  return;
111 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
template<typename T >
EigenProblemType libMesh::EigenSolver< T >::eigen_problem_type ( ) const
inherited
Returns
The type of the eigen problem.

Definition at line 123 of file eigen_solver.h.

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

123 { return _eigen_problem_type;}
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:273
template<typename T >
EigenSolverType libMesh::EigenSolver< T >::eigen_solver_type ( ) const
inherited
Returns
The type of eigensolver to use.

Definition at line 118 of file eigen_solver.h.

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

118 { return _eigen_solver_type; }
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:268
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

102 {
103  _enable_print_counter = true;
104  return;
105 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
template<typename T >
EPS libMesh::SlepcEigenSolver< T >::eps ( )
template<typename T >
bool libMesh::EigenSolver< T >::get_close_matrix_before_solve ( ) const
inherited
Returns
The value of the flag which controls whether libmesh closes the eigenproblem matrices before solving. by default.

Definition at line 89 of file eigen_solver.h.

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

90  {
91  libmesh_experimental();
93  }
template<typename T >
std::pair< Real, Real > libMesh::SlepcEigenSolver< T >::get_eigenpair ( dof_id_type  i,
NumericVector< T > &  solution_in 
)
virtual
Returns
The real and imaginary part of the ith eigenvalue and copies the respective eigenvector to the solution vector.
Note
The eigenpair may be complex even for real-valued matrices.

Implements libMesh::EigenSolver< T >.

Definition at line 717 of file slepc_eigen_solver.C.

References ierr.

719 {
720  PetscErrorCode ierr=0;
721 
722  PetscReal re, im;
723 
724  // Make sure the NumericVector passed in is really a PetscVector
725  PetscVector<T> * solution = dynamic_cast<PetscVector<T> *>(&solution_in);
726 
727  if (!solution)
728  libmesh_error_msg("Error getting eigenvector: input vector must be a PetscVector.");
729 
730  // real and imaginary part of the ith eigenvalue.
731  PetscScalar kr, ki;
732 
733  solution->close();
734 
735  ierr = EPSGetEigenpair(_eps, i, &kr, &ki, solution->vec(), PETSC_NULL);
736  LIBMESH_CHKERR(ierr);
737 
738 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
739  re = PetscRealPart(kr);
740  im = PetscImaginaryPart(kr);
741 #else
742  re = kr;
743  im = ki;
744 #endif
745 
746  return std::make_pair(re, im);
747 }
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
template<typename T >
std::pair< Real, Real > libMesh::SlepcEigenSolver< T >::get_eigenvalue ( dof_id_type  i)
virtual

Same as above, but does not copy the eigenvector.

Implements libMesh::EigenSolver< T >.

Definition at line 751 of file slepc_eigen_solver.C.

References ierr.

752 {
753  PetscErrorCode ierr=0;
754 
755  PetscReal re, im;
756 
757  // real and imaginary part of the ith eigenvalue.
758  PetscScalar kr, ki;
759 
760  ierr = EPSGetEigenvalue(_eps, i, &kr, &ki);
761  LIBMESH_CHKERR(ierr);
762 
763 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
764  re = PetscRealPart(kr);
765  im = PetscImaginaryPart(kr);
766 #else
767  re = kr;
768  im = ki;
769 #endif
770 
771  return std::make_pair(re, im);
772 }
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
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().

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (Counts::iterator it = _counts.begin();
59  it != _counts.end(); ++it)
60  {
61  const std::string name(it->first);
62  const unsigned int creations = it->second.first;
63  const unsigned int destructions = it->second.second;
64 
65  oss << "| " << name << " reference count information:\n"
66  << "| Creations: " << creations << '\n'
67  << "| Destructions: " << destructions << '\n';
68  }
69 
70  oss << " ---------------------------------------------------------------------------- \n";
71 
72  return oss.str();
73 
74 #else
75 
76  return "";
77 
78 #endif
79 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
static Counts _counts
Actually holds the data.
template<typename T >
Real libMesh::SlepcEigenSolver< T >::get_relative_error ( unsigned int  i)
Returns
The relative error $ ||A x - \lambda x|| / |\lambda x| $ of the ith eigenpair (or the equivalent for a general eigenvalue problem).

Definition at line 776 of file slepc_eigen_solver.C.

References ierr.

777 {
778  PetscErrorCode ierr=0;
779  PetscReal error;
780 
781 #if SLEPC_VERSION_LESS_THAN(3,6,0)
782  ierr = EPSComputeRelativeError(_eps, i, &error);
783 #else
784  ierr = EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error);
785 #endif
786  LIBMESH_CHKERR(ierr);
787 
788  return error;
789 }
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
protectedinherited

Increments the construction counter.

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

Definition at line 185 of file reference_counter.h.

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

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

186 {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189 
190  p.first++;
191 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
protectedinherited

Increments the destruction counter.

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

Definition at line 198 of file reference_counter.h.

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

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

199 {
200  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
201  std::pair<unsigned int, unsigned int> & p = _counts[name];
202 
203  p.second++;
204 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
template<typename T >
void libMesh::SlepcEigenSolver< T >::init ( )
virtual

Initialize data structures if not done so already.

Implements libMesh::EigenSolver< T >.

Definition at line 59 of file slepc_eigen_solver.C.

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

Referenced by libMesh::SlepcEigenSolver< T >::eps().

60 {
61 
62  PetscErrorCode ierr=0;
63 
64  // Initialize the data structures if not done so already.
65  if (!this->initialized())
66  {
67  this->_is_initialized = true;
68 
69  // Create the eigenproblem solver context
70  ierr = EPSCreate (this->comm().get(), &_eps);
71  LIBMESH_CHKERR(ierr);
72 
73  // Set user-specified solver
75  }
76 }
bool _is_initialized
Flag indicating if the data structures have been initialized.
Definition: eigen_solver.h:283
void set_slepc_solver_type()
Tells Slepc to use the user-specified solver stored in _eigen_solver_type.
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
const Parallel::Communicator & comm() const
bool initialized() const
Definition: eigen_solver.h:82
template<typename T >
bool libMesh::EigenSolver< T >::initialized ( ) const
inherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 82 of file eigen_solver.h.

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

82 { return _is_initialized; }
bool _is_initialized
Flag indicating if the data structures have been initialized.
Definition: eigen_solver.h:283
static unsigned int libMesh::ReferenceCounter::n_objects ( )
staticinherited
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inherited
Returns
The number of processors in the group.

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), 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::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:726
const Parallel::Communicator & _communicator
template<typename T >
PositionOfSpectrum libMesh::EigenSolver< T >::position_of_spectrum ( ) const
inherited
Returns
The position of the spectrum to compute.

Definition at line 128 of file eigen_solver.h.

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

129  { return _position_of_spectrum;}
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:278
void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out)
staticinherited

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

Definition at line 88 of file reference_counter.C.

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

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

89 {
91  out_stream << ReferenceCounter::get_info();
92 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inherited
Returns
The rank of this processor in the group.

Definition at line 99 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::MeshCommunication::broadcast(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::build_sparsity(), 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::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::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), 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::EquationSystems::get_solution(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ParmetisPartitioner::initialize(), 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::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_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), 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::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::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MetisPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print_global(), 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::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), BoundaryInfoTest::testShellFaceConstraints(), 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::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::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::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::RBEvaluation::write_out_vectors(), write_output_solvedata(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:724
template<typename T >
void libMesh::EigenSolver< T >::set_close_matrix_before_solve ( bool  val)
inherited

Set the flag which controls whether libmesh closes the eigenproblem matrices before solving.

Definition at line 99 of file eigen_solver.h.

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

100  {
101  libmesh_experimental();
103  }
template<typename T >
void libMesh::EigenSolver< T >::set_eigenproblem_type ( EigenProblemType  ept)
inherited

Sets the type of the eigenproblem.

Definition at line 140 of file eigen_solver.h.

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

141  {_eigen_problem_type = ept;}
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:273
template<typename T >
void libMesh::EigenSolver< T >::set_eigensolver_type ( const EigenSolverType  est)
inherited

Sets the type of eigensolver to use.

Definition at line 134 of file eigen_solver.h.

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

135  { _eigen_solver_type = est; }
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:268
template<typename T >
void libMesh::SlepcEigenSolver< T >::set_initial_space ( NumericVector< T > &  initial_space_in)
virtual

Use initial_space_in as the initial guess.

Implements libMesh::EigenSolver< T >.

Definition at line 818 of file slepc_eigen_solver.C.

References ierr, and libMesh::TriangleWrapper::init().

819 {
820 #if SLEPC_VERSION_LESS_THAN(3,1,0)
821  libmesh_error_msg("SLEPc 3.1 is required to call EigenSolver::set_initial_space()");
822 #else
823  this->init();
824 
825  PetscErrorCode ierr = 0;
826 
827  // Make sure the input vector is actually a PetscVector
828  PetscVector<T> * initial_space_petsc_vec =
829  dynamic_cast<PetscVector<T> *>(&initial_space_in);
830 
831  if (!initial_space_petsc_vec)
832  libmesh_error_msg("Error attaching initial space: input vector must be a PetscVector.");
833 
834  // Get a handle for the underlying Vec.
835  Vec initial_vector = initial_space_petsc_vec->vec();
836 
837  ierr = EPSSetInitialSpace(_eps, 1, &initial_vector);
838  LIBMESH_CHKERR(ierr);
839 #endif
840 }
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
virtual void init() libmesh_override
Initialize data structures if not done so already.
template<typename T >
void libMesh::EigenSolver< T >::set_position_of_spectrum ( PositionOfSpectrum  pos)
inherited
template<typename T >
void libMesh::EigenSolver< T >::set_position_of_spectrum ( Real  pos)
inherited

Definition at line 64 of file eigen_solver.C.

References libMesh::TARGET_MAGNITUDE, and libMesh::TARGET_REAL.

65 {
66  if (pos >= 0)
68  else
70 
71  _target_val = pos;
72 }
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:278
template<typename T >
void libMesh::EigenSolver< T >::set_position_of_spectrum ( Real  pos,
PositionOfSpectrum  target 
)
inherited

Definition at line 75 of file eigen_solver.C.

76 {
77  _position_of_spectrum = target;
78  _target_val = pos;
79 }
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:278
template<typename T >
void libMesh::SlepcEigenSolver< T >::set_slepc_position_of_spectrum ( )
private

Tells Slepc to compute the spectrum at the position stored in _position_of_spectrum.

Definition at line 635 of file slepc_eigen_solver.C.

References ierr, libMesh::LARGEST_IMAGINARY, libMesh::LARGEST_MAGNITUDE, libMesh::LARGEST_REAL, libMesh::SMALLEST_IMAGINARY, libMesh::SMALLEST_MAGNITUDE, libMesh::SMALLEST_REAL, libMesh::TARGET_IMAGINARY, libMesh::TARGET_MAGNITUDE, and libMesh::TARGET_REAL.

Referenced by libMesh::SlepcEigenSolver< T >::eps().

636 {
637  PetscErrorCode ierr = 0;
638 
639  switch (this->_position_of_spectrum)
640  {
641  case LARGEST_MAGNITUDE:
642  {
643  ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_MAGNITUDE);
644  LIBMESH_CHKERR(ierr);
645  return;
646  }
647  case SMALLEST_MAGNITUDE:
648  {
649  ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_MAGNITUDE);
650  LIBMESH_CHKERR(ierr);
651  return;
652  }
653  case LARGEST_REAL:
654  {
655  ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_REAL);
656  LIBMESH_CHKERR(ierr);
657  return;
658  }
659  case SMALLEST_REAL:
660  {
661  ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_REAL);
662  LIBMESH_CHKERR(ierr);
663  return;
664  }
665  case LARGEST_IMAGINARY:
666  {
667  ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_IMAGINARY);
668  LIBMESH_CHKERR(ierr);
669  return;
670  }
671  case SMALLEST_IMAGINARY:
672  {
673  ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_IMAGINARY);
674  LIBMESH_CHKERR(ierr);
675  return;
676  }
677 
678  // The EPS_TARGET_XXX enums were added in SLEPc 3.1
679 #if !SLEPC_VERSION_LESS_THAN(3,1,0)
680  case TARGET_MAGNITUDE:
681  {
682  ierr = EPSSetTarget(_eps, this->_target_val);
683  LIBMESH_CHKERR(ierr);
684  ierr = EPSSetWhichEigenpairs (_eps, EPS_TARGET_MAGNITUDE);
685  LIBMESH_CHKERR(ierr);
686  return;
687  }
688  case TARGET_REAL:
689  {
690  ierr = EPSSetTarget(_eps, this->_target_val);
691  LIBMESH_CHKERR(ierr);
692  ierr = EPSSetWhichEigenpairs (_eps, EPS_TARGET_REAL);
693  LIBMESH_CHKERR(ierr);
694  return;
695  }
696  case TARGET_IMAGINARY:
697  {
698  ierr = EPSSetTarget(_eps, this->_target_val);
699  LIBMESH_CHKERR(ierr);
700  ierr = EPSSetWhichEigenpairs (_eps, EPS_TARGET_IMAGINARY);
701  LIBMESH_CHKERR(ierr);
702  return;
703  }
704 #endif
705 
706  default:
707  libmesh_error_msg("ERROR: Unsupported SLEPc position of spectrum: " << this->_position_of_spectrum);
708  }
709 }
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:278
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
template<typename T >
void libMesh::SlepcEigenSolver< T >::set_slepc_problem_type ( )
private

Tells Slepc to deal with the type of problem stored in _eigen_problem_type.

Definition at line 605 of file slepc_eigen_solver.C.

References libMesh::err, libMesh::GHEP, libMesh::GHIEP, libMesh::GNHEP, libMesh::HEP, ierr, and libMesh::NHEP.

Referenced by libMesh::SlepcEigenSolver< T >::eps().

606 {
607  PetscErrorCode ierr = 0;
608 
609  switch (this->_eigen_problem_type)
610  {
611  case NHEP:
612  ierr = EPSSetProblemType (_eps, EPS_NHEP); LIBMESH_CHKERR(ierr); return;
613  case GNHEP:
614  ierr = EPSSetProblemType (_eps, EPS_GNHEP); LIBMESH_CHKERR(ierr); return;
615  case HEP:
616  ierr = EPSSetProblemType (_eps, EPS_HEP); LIBMESH_CHKERR(ierr); return;
617  case GHEP:
618  ierr = EPSSetProblemType (_eps, EPS_GHEP); LIBMESH_CHKERR(ierr); return;
619 #if !SLEPC_VERSION_LESS_THAN(3,3,0)
620  // EPS_GHIEP added in 3.3.0
621  case GHIEP:
622  ierr = EPSSetProblemType (_eps, EPS_GHIEP); LIBMESH_CHKERR(ierr); return;
623 #endif
624 
625  default:
626  libMesh::err << "ERROR: Unsupported SLEPc Eigen Problem: "
627  << this->_eigen_problem_type << std::endl
628  << "Continuing with SLEPc defaults" << std::endl;
629  }
630 }
OStreamProxy err
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:273
template<typename T >
void libMesh::SlepcEigenSolver< T >::set_slepc_solver_type ( )
private

Tells Slepc to use the user-specified solver stored in _eigen_solver_type.

Definition at line 573 of file slepc_eigen_solver.C.

References libMesh::ARNOLDI, libMesh::Utility::enum_to_string(), libMesh::err, ierr, libMesh::KRYLOVSCHUR, libMesh::LANCZOS, libMesh::LAPACK, libMesh::POWER, and libMesh::SUBSPACE.

Referenced by libMesh::SlepcEigenSolver< T >::eps().

574 {
575  PetscErrorCode ierr = 0;
576 
577  switch (this->_eigen_solver_type)
578  {
579  case POWER:
580  ierr = EPSSetType (_eps, (char *) EPSPOWER); LIBMESH_CHKERR(ierr); return;
581  case SUBSPACE:
582  ierr = EPSSetType (_eps, (char *) EPSSUBSPACE); LIBMESH_CHKERR(ierr); return;
583  case LAPACK:
584  ierr = EPSSetType (_eps, (char *) EPSLAPACK); LIBMESH_CHKERR(ierr); return;
585  case ARNOLDI:
586  ierr = EPSSetType (_eps, (char *) EPSARNOLDI); LIBMESH_CHKERR(ierr); return;
587  case LANCZOS:
588  ierr = EPSSetType (_eps, (char *) EPSLANCZOS); LIBMESH_CHKERR(ierr); return;
589  case KRYLOVSCHUR:
590  ierr = EPSSetType (_eps, (char *) EPSKRYLOVSCHUR); LIBMESH_CHKERR(ierr); return;
591  // case ARPACK:
592  // ierr = EPSSetType (_eps, (char *) EPSARPACK); LIBMESH_CHKERR(ierr); return;
593 
594  default:
595  libMesh::err << "ERROR: Unsupported SLEPc Eigen Solver: "
596  << Utility::enum_to_string(this->_eigen_solver_type) << std::endl
597  << "Continuing with SLEPc defaults" << std::endl;
598  }
599 }
OStreamProxy err
std::string enum_to_string(const T e)
EPS _eps
Eigenproblem solver context.
PetscErrorCode ierr
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:268
template<typename T >
void libMesh::EigenSolver< T >::set_solver_configuration ( SolverConfiguration solver_configuration)
inherited

Set the solver configuration object.

Definition at line 58 of file eigen_solver.C.

Referenced by libMesh::EigenSolver< T >::set_position_of_spectrum().

59 {
60  _solver_configuration = &solver_configuration;
61 }
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
Definition: eigen_solver.h:289
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_generalized ( SparseMatrix< T > &  matrix_A,
SparseMatrix< T > &  matrix_B,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
virtual

This function calls the SLEPc solver to compute the eigenpairs for the generalized eigenproblem defined by the matrix_A and matrix_B, which are of type SparseMatrix.

The argument nev is the number of eigenpairs to be computed and ncv is the number of basis vectors to be used in the solution procedure. Return values are the number of converged eigen values and the number of the iterations carried out by the eigen solver.

Implements libMesh::EigenSolver< T >.

Definition at line 269 of file slepc_eigen_solver.C.

References libMesh::TriangleWrapper::init().

275 {
276  this->init ();
277 
278  // Make sure the data passed in are really of Petsc types
279  PetscMatrix<T> * matrix_A = dynamic_cast<PetscMatrix<T> *>(&matrix_A_in);
280  PetscMatrix<T> * matrix_B = dynamic_cast<PetscMatrix<T> *>(&matrix_B_in);
281 
282  if (!matrix_A || !matrix_B)
283  libmesh_error_msg("Error: inputs to solve_generalized() must be of type PetscMatrix.");
284 
285  // Close the matrix and vectors in case this wasn't already done.
286  if (this->_close_matrix_before_solve)
287  {
288  matrix_A->close ();
289  matrix_B->close ();
290  }
291 
292  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), nev, ncv, tol, m_its);
293 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
virtual void init() libmesh_override
Initialize data structures if not done so already.
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_generalized ( ShellMatrix< T > &  matrix_A,
SparseMatrix< T > &  matrix_B,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
virtual

Solve generalized eigenproblem when matrix_A is of type ShellMatrix, matrix_B is of type SparseMatrix.

Implements libMesh::EigenSolver< T >.

Definition at line 297 of file slepc_eigen_solver.C.

References ierr, libMesh::TriangleWrapper::init(), libMesh::ShellMatrix< T >::m(), and libMesh::ShellMatrix< T >::n().

303 {
304  this->init ();
305 
306  PetscErrorCode ierr=0;
307 
308  // Prepare the matrix. Note that the const_cast is only necessary
309  // because PETSc does not accept a const void *. Inside the member
310  // function _petsc_shell_matrix() below, the pointer is casted back
311  // to a const ShellMatrix<T> *.
312  Mat mat_A;
313  ierr = MatCreateShell(this->comm().get(),
314  shell_matrix_A.m(), // Specify the number of local rows
315  shell_matrix_A.n(), // Specify the number of local columns
316  PETSC_DETERMINE,
317  PETSC_DETERMINE,
318  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
319  &mat_A);
320  LIBMESH_CHKERR(ierr);
321 
322  PetscMatrix<T> * matrix_B = dynamic_cast<PetscMatrix<T> *>(&matrix_B_in);
323 
324  if (!matrix_B)
325  libmesh_error_msg("Error: inputs to solve_generalized() must be of type PetscMatrix.");
326 
327  // Close the matrix and vectors in case this wasn't already done.
328  if (this->_close_matrix_before_solve)
329  matrix_B->close ();
330 
331  ierr = MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
332  LIBMESH_CHKERR(ierr);
333  ierr = MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
334  LIBMESH_CHKERR(ierr);
335 
336  return _solve_generalized_helper (mat_A, matrix_B->mat(), nev, ncv, tol, m_its);
337 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
static PetscErrorCode _petsc_shell_matrix_get_diagonal(Mat mat, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s get_diagonal funct...
PetscErrorCode ierr
const Parallel::Communicator & comm() const
static PetscErrorCode _petsc_shell_matrix_mult(Mat mat, Vec arg, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s matrix multiplicat...
virtual void init() libmesh_override
Initialize data structures if not done so already.
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_generalized ( SparseMatrix< T > &  matrix_A,
ShellMatrix< T > &  matrix_B,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
virtual

Solve generalized eigenproblem when matrix_A is of type SparseMatrix, matrix_B is of type ShellMatrix.

When using this function, one should use the command line options: -st_ksp_type gmres -st_pc_type none or -st_ksp_type gmres -st_pc_type jacobi or similar.

Implements libMesh::EigenSolver< T >.

Definition at line 341 of file slepc_eigen_solver.C.

References ierr, libMesh::TriangleWrapper::init(), libMesh::ShellMatrix< T >::m(), and libMesh::ShellMatrix< T >::n().

347 {
348  this->init ();
349 
350  PetscErrorCode ierr=0;
351 
352  PetscMatrix<T> * matrix_A = dynamic_cast<PetscMatrix<T> *>(&matrix_A_in);
353 
354  if (!matrix_A)
355  libmesh_error_msg("Error: inputs to solve_generalized() must be of type PetscMatrix.");
356 
357  // Close the matrix and vectors in case this wasn't already done.
358  if (this->_close_matrix_before_solve)
359  matrix_A->close ();
360 
361  // Prepare the matrix. Note that the const_cast is only necessary
362  // because PETSc does not accept a const void *. Inside the member
363  // function _petsc_shell_matrix() below, the pointer is casted back
364  // to a const ShellMatrix<T> *.
365  Mat mat_B;
366  ierr = MatCreateShell(this->comm().get(),
367  shell_matrix_B.m(), // Specify the number of local rows
368  shell_matrix_B.n(), // Specify the number of local columns
369  PETSC_DETERMINE,
370  PETSC_DETERMINE,
371  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
372  &mat_B);
373  LIBMESH_CHKERR(ierr);
374 
375 
376  ierr = MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
377  LIBMESH_CHKERR(ierr);
378  ierr = MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
379  LIBMESH_CHKERR(ierr);
380 
381  return _solve_generalized_helper (matrix_A->mat(), mat_B, nev, ncv, tol, m_its);
382 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
static PetscErrorCode _petsc_shell_matrix_get_diagonal(Mat mat, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s get_diagonal funct...
PetscErrorCode ierr
const Parallel::Communicator & comm() const
static PetscErrorCode _petsc_shell_matrix_mult(Mat mat, Vec arg, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s matrix multiplicat...
virtual void init() libmesh_override
Initialize data structures if not done so already.
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_generalized ( ShellMatrix< T > &  matrix_A,
ShellMatrix< T > &  matrix_B,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
virtual

Solve generalized eigenproblem when both matrix_A and matrix_B are of type ShellMatrix.

When using this function, one should use the command line options: -st_ksp_type gmres -st_pc_type none or -st_ksp_type gmres -st_pc_type jacobi or similar.

Implements libMesh::EigenSolver< T >.

Definition at line 386 of file slepc_eigen_solver.C.

References ierr, libMesh::TriangleWrapper::init(), libMesh::ShellMatrix< T >::m(), and libMesh::ShellMatrix< T >::n().

392 {
393  this->init ();
394 
395  PetscErrorCode ierr=0;
396 
397  // Prepare the matrices. Note that the const_casts are only
398  // necessary because PETSc does not accept a const void *. Inside
399  // the member function _petsc_shell_matrix() below, the pointer is
400  // casted back to a const ShellMatrix<T> *.
401  Mat mat_A;
402  ierr = MatCreateShell(this->comm().get(),
403  shell_matrix_A.m(), // Specify the number of local rows
404  shell_matrix_A.n(), // Specify the number of local columns
405  PETSC_DETERMINE,
406  PETSC_DETERMINE,
407  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
408  &mat_A);
409  LIBMESH_CHKERR(ierr);
410 
411  Mat mat_B;
412  ierr = MatCreateShell(this->comm().get(),
413  shell_matrix_B.m(), // Specify the number of local rows
414  shell_matrix_B.n(), // Specify the number of local columns
415  PETSC_DETERMINE,
416  PETSC_DETERMINE,
417  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
418  &mat_B);
419  LIBMESH_CHKERR(ierr);
420 
421  ierr = MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
422  LIBMESH_CHKERR(ierr);
423  ierr = MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
424  LIBMESH_CHKERR(ierr);
425 
426  ierr = MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
427  LIBMESH_CHKERR(ierr);
428  ierr = MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
429  LIBMESH_CHKERR(ierr);
430 
431  return _solve_generalized_helper (mat_A, mat_B, nev, ncv, tol, m_its);
432 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
static PetscErrorCode _petsc_shell_matrix_get_diagonal(Mat mat, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s get_diagonal funct...
PetscErrorCode ierr
const Parallel::Communicator & comm() const
static PetscErrorCode _petsc_shell_matrix_mult(Mat mat, Vec arg, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s matrix multiplicat...
virtual void init() libmesh_override
Initialize data structures if not done so already.
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_standard ( SparseMatrix< T > &  matrix_A,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
virtual

This function calls the SLEPc solver to compute the eigenpairs of the SparseMatrix matrix_A.

nev is the number of eigenpairs to be computed and ncv is the number of basis vectors to be used in the solution procedure. Return values are the number of converged eigen values and the number of the iterations carried out by the eigen solver.

Implements libMesh::EigenSolver< T >.

Definition at line 82 of file slepc_eigen_solver.C.

References libMesh::TriangleWrapper::init().

87 {
88  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
89 
90  this->init ();
91 
92  // Make sure the SparseMatrix passed in is really a PetscMatrix
93  PetscMatrix<T> * matrix_A = dynamic_cast<PetscMatrix<T> *>(&matrix_A_in);
94 
95  if (!matrix_A)
96  libmesh_error_msg("Error: input matrix to solve_standard() must be a PetscMatrix.");
97 
98  // Close the matrix and vectors in case this wasn't already done.
100  matrix_A->close ();
101 
102  return _solve_standard_helper(matrix_A->mat(), nev, ncv, tol, m_its);
103 }
std::pair< unsigned int, unsigned int > _solve_standard_helper(Mat mat, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the standard eigensolve.
virtual void init() libmesh_override
Initialize data structures if not done so already.
template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_standard ( ShellMatrix< T > &  shell_matrix,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
virtual

Same as above except that matrix_A is a ShellMatrix in this case.

Implements libMesh::EigenSolver< T >.

Definition at line 108 of file slepc_eigen_solver.C.

References ierr, libMesh::TriangleWrapper::init(), libMesh::ShellMatrix< T >::m(), and libMesh::ShellMatrix< T >::n().

113 {
114  this->init ();
115 
116  PetscErrorCode ierr=0;
117 
118  // Prepare the matrix. Note that the const_cast is only necessary
119  // because PETSc does not accept a const void *. Inside the member
120  // function _petsc_shell_matrix() below, the pointer is casted back
121  // to a const ShellMatrix<T> *.
122  Mat mat;
123  ierr = MatCreateShell(this->comm().get(),
124  shell_matrix.m(), // Specify the number of local rows
125  shell_matrix.n(), // Specify the number of local columns
126  PETSC_DETERMINE,
127  PETSC_DETERMINE,
128  const_cast<void *>(static_cast<const void *>(&shell_matrix)),
129  &mat);
130  LIBMESH_CHKERR(ierr);
131 
132  ierr = MatShellSetOperation(mat,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
133  LIBMESH_CHKERR(ierr);
134  ierr = MatShellSetOperation(mat,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
135  LIBMESH_CHKERR(ierr);
136 
137  return _solve_standard_helper(mat, nev, ncv, tol, m_its);
138 }
static PetscErrorCode _petsc_shell_matrix_get_diagonal(Mat mat, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s get_diagonal funct...
PetscErrorCode ierr
const Parallel::Communicator & comm() const
static PetscErrorCode _petsc_shell_matrix_mult(Mat mat, Vec arg, Vec dest)
Internal function if shell matrix mode is used, this just calls the shell matrix&#39;s matrix multiplicat...
std::pair< unsigned int, unsigned int > _solve_standard_helper(Mat mat, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the standard eigensolve.
virtual void init() libmesh_override
Initialize data structures if not done so already.

Member Data Documentation

template<typename T >
bool libMesh::EigenSolver< T >::_close_matrix_before_solve
protectedinherited
const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited
ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
template<typename T >
EigenProblemType libMesh::EigenSolver< T >::_eigen_problem_type
protectedinherited

Enum stating which type of eigen problem we deal with.

Definition at line 273 of file eigen_solver.h.

Referenced by libMesh::EigenSolver< T >::eigen_problem_type(), libMesh::EigenSolver< T >::set_eigenproblem_type(), and libMesh::SlepcEigenSolver< T >::SlepcEigenSolver().

template<typename T >
EigenSolverType libMesh::EigenSolver< T >::_eigen_solver_type
protectedinherited
bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

template<typename T >
EPS libMesh::SlepcEigenSolver< T >::_eps
private

Eigenproblem solver context.

Definition at line 271 of file slepc_eigen_solver.h.

Referenced by libMesh::SlepcEigenSolver< T >::eps().

template<typename T >
bool libMesh::EigenSolver< T >::_is_initialized
protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 283 of file eigen_solver.h.

Referenced by libMesh::EigenSolver< T >::initialized().

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

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

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

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

template<typename T >
PositionOfSpectrum libMesh::EigenSolver< T >::_position_of_spectrum
protectedinherited

Enum stating where to evaluate the spectrum.

Definition at line 278 of file eigen_solver.h.

Referenced by libMesh::EigenSolver< T >::position_of_spectrum(), and libMesh::EigenSolver< T >::set_position_of_spectrum().

template<typename T >
SolverConfiguration* libMesh::EigenSolver< T >::_solver_configuration
protectedinherited

Optionally store a SolverOptions object that can be used to set parameters like solver type, tolerances and iteration limits.

Definition at line 289 of file eigen_solver.h.

template<typename T >
Real libMesh::EigenSolver< T >::_target_val
protectedinherited

Definition at line 291 of file eigen_solver.h.


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