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)
 Constructor. More...
 
 ~SlepcEigenSolver ()
 Destructor. More...
 
virtual void clear () noexcept override
 Release all memory and clear data structures. More...
 
virtual void init () 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) 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) override
 Same as above except that matrix_A is a ShellMatrix in this case. More...
 
virtual std::pair< unsigned int, unsigned intsolve_standard (ShellMatrix< T > &shell_matrix, SparseMatrix< T > &precond, int nev, int ncv, const double tol, const unsigned int m_its) override
 Same as above except that matrix_A is a ShellMatrix in this case. More...
 
virtual std::pair< unsigned int, unsigned intsolve_standard (ShellMatrix< T > &shell_matrix, ShellMatrix< T > &precond, int nev, int ncv, const double tol, const unsigned int m_its) override
 Same as above except that precond 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) 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) 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) 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) override
 Solve generalized eigenproblem when both matrix_A and matrix_B are of type ShellMatrix. More...
 
virtual std::pair< unsigned int, unsigned intsolve_generalized (ShellMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, SparseMatrix< T > &precond, int nev, int ncv, const double tol, const unsigned int m_its) override
 Solves the generalized eigenproblem involving ShellMatrices matrix_A, matrix_B and the SparseMatrix precond. More...
 
virtual std::pair< unsigned int, unsigned intsolve_generalized (ShellMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, ShellMatrix< T > &precond, int nev, int ncv, const double tol, const unsigned int m_its) override
 Solves the generalized eigenproblem involving ShellMatrices matrix_A, matrix_B and the shell preconditioning matrix. More...
 
virtual std::pair< Real, Realget_eigenpair (dof_id_type i, NumericVector< T > &solution_in) override
 
virtual std::pair< Real, Realget_eigenvalue (dof_id_type i) 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) override
 Attach a deflation space defined by a single vector. More...
 
virtual void set_initial_space (NumericVector< T > &initial_space_in) 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 std::unique_ptr< EigenSolver< T > > build (const Parallel::Communicator &comm_in, 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_stream=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) noexcept
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name) noexcept
 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, Mat precond, 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, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
 Helper function that actually performs the generalized eigensolve. More...
 
std::pair< unsigned int, unsigned int_solve_helper (Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
 Helper function that actually performs either 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...
 
PetscVector< T > * _initial_space
 A vector used for initial space. 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 51 of file slepc_eigen_solver.h.

Member Typedef Documentation

◆ Counts

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

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

◆ SlepcEigenSolver()

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

Constructor.

Initializes Petsc data structures

Definition at line 49 of file slepc_eigen_solver.C.

49  :
50  EigenSolver<T>(comm_in),
51  _initial_space(nullptr)
52 {
54  this->_eigen_problem_type = NHEP;
55 }
PetscVector< T > * _initial_space
A vector used for initial space.
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:327
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:332

◆ ~SlepcEigenSolver()

template<typename T >
libMesh::SlepcEigenSolver< T >::~SlepcEigenSolver ( )

Destructor.

Definition at line 60 of file slepc_eigen_solver.C.

61 {
62  this->SlepcEigenSolver::clear ();
63 }
virtual void clear() noexcept override
Release all memory and clear data structures.

Member Function Documentation

◆ _petsc_shell_matrix_get_diagonal()

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 928 of file slepc_eigen_solver.C.

929 {
930  // Get the matrix context.
931  PetscErrorCode ierr=0;
932  void * ctx;
933  ierr = MatShellGetContext(mat,&ctx);
934 
935  Parallel::communicator comm;
936  PetscObjectGetComm((PetscObject)mat,&comm);
937  CHKERRABORT(comm,ierr);
938 
939  // Get user shell matrix object.
940  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
941 
942  // Make \p NumericVector instances around the vector.
943  PetscVector<T> dest_global(dest, shell_matrix.comm());
944 
945  // Call the user function.
946  shell_matrix.get_diagonal(dest_global);
947 
948  return ierr;
949 }
const Parallel::Communicator & comm() const
void * ctx

◆ _petsc_shell_matrix_mult()

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 903 of file slepc_eigen_solver.C.

904 {
905  // Get the matrix context.
906  PetscErrorCode ierr=0;
907  void * ctx;
908  ierr = MatShellGetContext(mat,&ctx);
909 
910  Parallel::communicator comm;
911  PetscObjectGetComm((PetscObject)mat,&comm);
912  CHKERRABORT(comm,ierr);
913 
914  // Get user shell matrix object.
915  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
916 
917  // Make \p NumericVector instances around the vectors.
918  PetscVector<T> arg_global(arg, shell_matrix.comm());
919  PetscVector<T> dest_global(dest, shell_matrix.comm());
920 
921  // Call the user function.
922  shell_matrix.vector_mult(dest_global,arg_global);
923 
924  return ierr;
925 }
const Parallel::Communicator & comm() const
void * ctx

◆ _solve_generalized_helper()

template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::_solve_generalized_helper ( Mat  mat_A,
Mat  mat_B,
Mat  precond,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
private

Helper function that actually performs the generalized eigensolve.

Definition at line 477 of file slepc_eigen_solver.C.

484 {
485  LOG_SCOPE("solve_generalized()", "SlepcEigenSolver");
486 
487  // Set operators.
488  PetscErrorCode ierr = EPSSetOperators (_eps, mat_A, mat_B);
489  LIBMESH_CHKERR(ierr);
490 
491  return this->_solve_helper(precond, nev, ncv, tol, m_its);
492 }
std::pair< unsigned int, unsigned int > _solve_helper(Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs either eigensolve.
EPS _eps
Eigenproblem solver context.

◆ _solve_helper()

template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::_solve_helper ( Mat  precond,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
private

Helper function that actually performs either eigensolve.

Definition at line 498 of file slepc_eigen_solver.C.

503 {
504  PetscErrorCode ierr=0;
505 
506  // converged eigen pairs and number of iterations
507  PetscInt nconv=0;
508  PetscInt its=0;
509  ST st=nullptr;
510 
511 #ifdef DEBUG
512  // The relative error.
513  PetscReal error, re, im;
514 
515  // Pointer to vectors of the real parts, imaginary parts.
516  PetscScalar kr, ki;
517 #endif
518 
519  //set the problem type and the position of the spectrum
522 
523  // Set eigenvalues to be computed.
524 #if SLEPC_VERSION_LESS_THAN(3,0,0)
525  ierr = EPSSetDimensions (_eps, nev, ncv);
526 #else
527  ierr = EPSSetDimensions (_eps, nev, ncv, PETSC_DECIDE);
528 #endif
529  LIBMESH_CHKERR(ierr);
530  // Set the tolerance and maximum iterations.
531  ierr = EPSSetTolerances (_eps, tol, m_its);
532  LIBMESH_CHKERR(ierr);
533 
534  // Set runtime options, e.g.,
535  // -eps_type <type>, -eps_nev <nev>, -eps_ncv <ncv>
536  // Similar to PETSc, these options will override those specified
537  // above as long as EPSSetFromOptions() is called _after_ any
538  // other customization routines.
539  ierr = EPSSetFromOptions (_eps);
540  LIBMESH_CHKERR(ierr);
541 
542  // Set a preconditioning matrix to ST
543  if (precond) {
544  ierr = EPSGetST(_eps,&st);LIBMESH_CHKERR(ierr);
545 #if SLEPC_VERSION_LESS_THAN(3,15,0)
546  ierr = STPrecondSetMatForPC(st, precond);
547 #else
548  ierr = STSetPreconditionerMat(st, precond);
549 #endif
550  LIBMESH_CHKERR(ierr);
551  }
552 
553  // If the SolverConfiguration object is provided, use it to override
554  // solver options.
555  if (this->_solver_configuration)
556  {
558  }
559 
560  // If an initial space is provided, let us attach it to EPS
561  if (_initial_space) {
562  // Get a handle for the underlying Vec.
563  Vec initial_vector = _initial_space->vec();
564 
565  ierr = EPSSetInitialSpace(_eps, 1, &initial_vector);
566  LIBMESH_CHKERR(ierr);
567  }
568 
569  // Solve the eigenproblem.
570  ierr = EPSSolve (_eps);
571  LIBMESH_CHKERR(ierr);
572 
573  // Get the number of iterations.
574  ierr = EPSGetIterationNumber (_eps, &its);
575  LIBMESH_CHKERR(ierr);
576 
577  // Get number of converged eigenpairs.
578  ierr = EPSGetConverged(_eps,&nconv);
579  LIBMESH_CHKERR(ierr);
580 
581 
582 #ifdef DEBUG
583  // ierr = PetscPrintf(this->comm().get(),
584  // "\n Number of iterations: %d\n"
585  // " Number of converged eigenpairs: %d\n\n", its, nconv);
586 
587  // Display eigenvalues and relative errors.
588  ierr = PetscPrintf(this->comm().get(),
589  " k ||Ax-kx||/|kx|\n"
590  " ----------------- -----------------\n" );
591  LIBMESH_CHKERR(ierr);
592 
593  for (PetscInt i=0; i<nconv; i++ )
594  {
595  ierr = EPSGetEigenpair(_eps, i, &kr, &ki, LIBMESH_PETSC_NULLPTR,
596  LIBMESH_PETSC_NULLPTR);
597  LIBMESH_CHKERR(ierr);
598 
599 #if SLEPC_VERSION_LESS_THAN(3,6,0)
600  ierr = EPSComputeRelativeError(_eps, i, &error);
601 #else
602  ierr = EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error);
603 #endif
604  LIBMESH_CHKERR(ierr);
605 
606 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
607  re = PetscRealPart(kr);
608  im = PetscImaginaryPart(kr);
609 #else
610  re = kr;
611  im = ki;
612 #endif
613 
614  if (im != .0)
615  {
616  ierr = PetscPrintf(this->comm().get()," %9f%+9f i %12f\n", re, im, error);
617  LIBMESH_CHKERR(ierr);
618  }
619  else
620  {
621  ierr = PetscPrintf(this->comm().get()," %12f %12f\n", re, error);
622  LIBMESH_CHKERR(ierr);
623  }
624  }
625 
626  ierr = PetscPrintf(this->comm().get(),"\n" );
627  LIBMESH_CHKERR(ierr);
628 #endif // DEBUG
629 
630  // return the number of converged eigenpairs
631  // and the number of iterations
632  return std::make_pair(nconv, its);
633 }
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
Definition: eigen_solver.h:348
PetscVector< T > * _initial_space
A vector used for initial space.
const Parallel::Communicator & comm() const
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.
void set_slepc_position_of_spectrum()
Tells Slepc to compute the spectrum at the position stored in _position_of_spectrum.

◆ _solve_standard_helper()

template<typename T >
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::_solve_standard_helper ( Mat  mat,
Mat  precond,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
private

Helper function that actually performs the standard eigensolve.

Definition at line 224 of file slepc_eigen_solver.C.

230 {
231  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
232 
233  // Set operators.
234  PetscErrorCode ierr = EPSSetOperators (_eps, mat, LIBMESH_PETSC_NULLPTR);
235  LIBMESH_CHKERR(ierr);
236 
237  return this->_solve_helper(precond, nev, ncv, tol, m_its);
238 }
std::pair< unsigned int, unsigned int > _solve_helper(Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs either eigensolve.
EPS _eps
Eigenproblem solver context.

◆ attach_deflation_space()

template<typename T>
void libMesh::SlepcEigenSolver< T >::attach_deflation_space ( NumericVector< T > &  deflation_vector)
overridevirtual

Attach a deflation space defined by a single vector.

Implements libMesh::EigenSolver< T >.

Definition at line 867 of file slepc_eigen_solver.C.

868 {
869  this->init();
870 
871  PetscErrorCode ierr = 0;
872 
873  // Make sure the input vector is actually a PetscVector
874  PetscVector<T> * deflation_vector_petsc_vec =
875  dynamic_cast<PetscVector<T> *>(&deflation_vector_in);
876 
877  libmesh_error_msg_if(!deflation_vector_petsc_vec, "Error attaching deflation space: input vector must be a PetscVector.");
878 
879  // Get a handle for the underlying Vec.
880  Vec deflation_vector = deflation_vector_petsc_vec->vec();
881 
882 #if SLEPC_VERSION_LESS_THAN(3,1,0)
883  ierr = EPSAttachDeflationSpace(_eps, 1, &deflation_vector, PETSC_FALSE);
884 #else
885  ierr = EPSSetDeflationSpace(_eps, 1, &deflation_vector);
886 #endif
887  LIBMESH_CHKERR(ierr);
888 }
EPS _eps
Eigenproblem solver context.
virtual void init() override
Initialize data structures if not done so already.

◆ build()

template<typename T >
std::unique_ptr< EigenSolver< T > > libMesh::EigenSolver< T >::build ( const Parallel::Communicator comm_in,
const SolverPackage  solver_package = SLEPC_SOLVERS 
)
staticinherited

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

Definition at line 58 of file eigen_solver.C.

60 {
61  // Build the appropriate solver
62  switch (solver_package)
63  {
64 
65 #ifdef LIBMESH_HAVE_SLEPC
66  case SLEPC_SOLVERS:
67  return std::make_unique<SlepcEigenSolver<T>>(comm);
68 #endif
69 
70  default:
71  libmesh_error_msg("ERROR: Unrecognized eigen solver package: " << solver_package);
72  }
73 
74  return std::unique_ptr<EigenSolver<T>>();
75 }
const Parallel::Communicator & comm() const

◆ clear()

template<typename T >
void libMesh::SlepcEigenSolver< T >::clear ( )
overridevirtualnoexcept

Release all memory and clear data structures.

clear() is called from the destructor, so it should not throw.

Reimplemented from libMesh::EigenSolver< T >.

Definition at line 68 of file slepc_eigen_solver.C.

69 {
70  if (this->initialized())
71  {
72  this->_is_initialized = false;
73 
74  PetscErrorCode ierr = LibMeshEPSDestroy(&_eps);
75  if (ierr)
76  libmesh_warning("Warning: EPSDestroy returned a non-zero error code which we ignored.");
77 
78  // SLEPc default eigenproblem solver
80  }
81 }
bool _is_initialized
Flag indicating if the data structures have been initialized.
Definition: eigen_solver.h:342
bool initialized() const
Definition: eigen_solver.h:84
EPS _eps
Eigenproblem solver context.
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:327

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< libMesh::Number >::create_submatrix_nosort(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), 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_bcids_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::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), 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::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), 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::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

98  { return _communicator; }
const Parallel::Communicator & _communicator

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ eigen_problem_type()

template<typename T>
EigenProblemType libMesh::EigenSolver< T >::eigen_problem_type ( ) const
inlineinherited
Returns
The type of the eigen problem.

Definition at line 125 of file eigen_solver.h.

125 { return _eigen_problem_type;}
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:332

◆ eigen_solver_type()

template<typename T>
EigenSolverType libMesh::EigenSolver< T >::eigen_solver_type ( ) const
inlineinherited
Returns
The type of eigensolver to use.

Definition at line 120 of file eigen_solver.h.

120 { return _eigen_solver_type; }
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:327

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ eps()

template<typename T>
EPS libMesh::SlepcEigenSolver< T >::eps ( )
inline
Returns
The raw SLEPc EPS pointer.

Definition at line 257 of file slepc_eigen_solver.h.

257 { this->init(); return _eps; }
EPS _eps
Eigenproblem solver context.
virtual void init() override
Initialize data structures if not done so already.

◆ get_close_matrix_before_solve()

template<typename T>
bool libMesh::EigenSolver< T >::get_close_matrix_before_solve ( ) const
inlineinherited
Returns
The value of the flag which controls whether libmesh closes the eigenproblem matrices before solving. true by default.

Definition at line 91 of file eigen_solver.h.

92  {
93  libmesh_experimental();
95  }

◆ get_eigenpair()

template<typename T>
std::pair< Real, Real > libMesh::SlepcEigenSolver< T >::get_eigenpair ( dof_id_type  i,
NumericVector< T > &  solution_in 
)
overridevirtual
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 791 of file slepc_eigen_solver.C.

793 {
794  PetscErrorCode ierr=0;
795 
796  PetscReal re, im;
797 
798  // Make sure the NumericVector passed in is really a PetscVector
799  PetscVector<T> * solution = dynamic_cast<PetscVector<T> *>(&solution_in);
800 
801  libmesh_error_msg_if(!solution, "Error getting eigenvector: input vector must be a PetscVector.");
802 
803  // real and imaginary part of the ith eigenvalue.
804  PetscScalar kr, ki;
805 
806  solution->close();
807 
808  ierr = EPSGetEigenpair(_eps, i, &kr, &ki, solution->vec(),
809  LIBMESH_PETSC_NULLPTR);
810  LIBMESH_CHKERR(ierr);
811 
812 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
813  re = PetscRealPart(kr);
814  im = PetscImaginaryPart(kr);
815 #else
816  re = kr;
817  im = ki;
818 #endif
819 
820  return std::make_pair(re, im);
821 }
EPS _eps
Eigenproblem solver context.

◆ get_eigenvalue()

template<typename T >
std::pair< Real, Real > libMesh::SlepcEigenSolver< T >::get_eigenvalue ( dof_id_type  i)
overridevirtual

Same as above, but does not copy the eigenvector.

Implements libMesh::EigenSolver< T >.

Definition at line 825 of file slepc_eigen_solver.C.

826 {
827  PetscErrorCode ierr=0;
828 
829  PetscReal re, im;
830 
831  // real and imaginary part of the ith eigenvalue.
832  PetscScalar kr, ki;
833 
834  ierr = EPSGetEigenvalue(_eps, i, &kr, &ki);
835  LIBMESH_CHKERR(ierr);
836 
837 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
838  re = PetscRealPart(kr);
839  im = PetscImaginaryPart(kr);
840 #else
841  re = kr;
842  im = ki;
843 #endif
844 
845  return std::make_pair(re, im);
846 }
EPS _eps
Eigenproblem solver context.

◆ get_info()

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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 (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static Counts _counts
Actually holds the data.

◆ get_relative_error()

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 850 of file slepc_eigen_solver.C.

851 {
852  PetscErrorCode ierr=0;
853  PetscReal error;
854 
855 #if SLEPC_VERSION_LESS_THAN(3,6,0)
856  ierr = EPSComputeRelativeError(_eps, i, &error);
857 #else
858  ierr = EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error);
859 #endif
860  LIBMESH_CHKERR(ierr);
861 
862  return error;
863 }
EPS _eps
Eigenproblem solver context.

◆ increment_constructor_count()

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

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ increment_destructor_count()

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

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ init()

template<typename T >
void libMesh::SlepcEigenSolver< T >::init ( )
overridevirtual

Initialize data structures if not done so already.

Implements libMesh::EigenSolver< T >.

Definition at line 86 of file slepc_eigen_solver.C.

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

87 {
88 
89  PetscErrorCode ierr=0;
90 
91  // Initialize the data structures if not done so already.
92  if (!this->initialized())
93  {
94  this->_is_initialized = true;
95 
96  // Create the eigenproblem solver context
97  ierr = EPSCreate (this->comm().get(), &_eps);
98  LIBMESH_CHKERR(ierr);
99 
100  // Set user-specified solver
102  }
103 }
bool _is_initialized
Flag indicating if the data structures have been initialized.
Definition: eigen_solver.h:342
const Parallel::Communicator & comm() const
void set_slepc_solver_type()
Tells Slepc to use the user-specified solver stored in _eigen_solver_type.
bool initialized() const
Definition: eigen_solver.h:84
EPS _eps
Eigenproblem solver context.

◆ initialized()

template<typename T>
bool libMesh::EigenSolver< T >::initialized ( ) const
inlineinherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 84 of file eigen_solver.h.

84 { return _is_initialized; }
bool _is_initialized
Flag indicating if the data structures have been initialized.
Definition: eigen_solver.h:342

◆ n_objects()

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

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

86  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 103 of file parallel_object.h.

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

104  {
105  processor_id_type returnval =
106  cast_int<processor_id_type>(_communicator.size());
107  libmesh_assert(returnval); // We never have an empty comm
108  return returnval;
109  }
const Parallel::Communicator & _communicator
processor_id_type size() const
uint8_t processor_id_type
libmesh_assert(ctx)

◆ position_of_spectrum()

template<typename T>
PositionOfSpectrum libMesh::EigenSolver< T >::position_of_spectrum ( ) const
inlineinherited
Returns
The position of the spectrum to compute.

Definition at line 130 of file eigen_solver.h.

131  { return _position_of_spectrum;}
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:337

◆ print_info()

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

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

Definition at line 81 of file reference_counter.C.

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

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

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
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()

processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), 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::DofMap::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

115  { return cast_int<processor_id_type>(_communicator.rank()); }
processor_id_type rank() const
const Parallel::Communicator & _communicator

◆ set_close_matrix_before_solve()

template<typename T>
void libMesh::EigenSolver< T >::set_close_matrix_before_solve ( bool  val)
inlineinherited

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

Definition at line 101 of file eigen_solver.h.

102  {
103  libmesh_experimental();
105  }

◆ set_eigenproblem_type()

template<typename T>
void libMesh::EigenSolver< T >::set_eigenproblem_type ( EigenProblemType  ept)
inlineinherited

Sets the type of the eigenproblem.

Definition at line 142 of file eigen_solver.h.

143  {_eigen_problem_type = ept;}
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:332

◆ set_eigensolver_type()

template<typename T>
void libMesh::EigenSolver< T >::set_eigensolver_type ( const EigenSolverType  est)
inlineinherited

Sets the type of eigensolver to use.

Definition at line 136 of file eigen_solver.h.

137  { _eigen_solver_type = est; }
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:327

◆ set_initial_space()

template<typename T>
void libMesh::SlepcEigenSolver< T >::set_initial_space ( NumericVector< T > &  initial_space_in)
overridevirtual

Use initial_space_in as the initial guess.

Implements libMesh::EigenSolver< T >.

Definition at line 891 of file slepc_eigen_solver.C.

892 {
893 #if SLEPC_VERSION_LESS_THAN(3,1,0)
894  libmesh_error_msg("SLEPc 3.1 is required to call EigenSolver::set_initial_space()");
895 #else
896  // Make sure the input vector (which is still owned by caller) is
897  // actually a PetscVector
898  _initial_space = cast_ptr<PetscVector<T> *>(&initial_space_in);
899 #endif
900 }
PetscVector< T > * _initial_space
A vector used for initial space.

◆ set_position_of_spectrum() [1/3]

template<typename T>
void libMesh::EigenSolver< T >::set_position_of_spectrum ( PositionOfSpectrum  pos)
inlineinherited

Sets the position of the spectrum.

Definition at line 148 of file eigen_solver.h.

149  {_position_of_spectrum= pos;}
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:337

◆ set_position_of_spectrum() [2/3]

template<typename T >
void libMesh::EigenSolver< T >::set_position_of_spectrum ( Real  pos)
inherited

Definition at line 85 of file eigen_solver.C.

86 {
87  if (pos >= 0)
89  else
91 
92  _target_val = pos;
93 }
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:337

◆ set_position_of_spectrum() [3/3]

template<typename T >
void libMesh::EigenSolver< T >::set_position_of_spectrum ( Real  pos,
PositionOfSpectrum  target 
)
inherited

Definition at line 96 of file eigen_solver.C.

97 {
98  _position_of_spectrum = target;
99  _target_val = pos;
100 }
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:337

◆ set_slepc_position_of_spectrum()

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 709 of file slepc_eigen_solver.C.

710 {
711  PetscErrorCode ierr = 0;
712 
713  switch (this->_position_of_spectrum)
714  {
715  case LARGEST_MAGNITUDE:
716  {
717  ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_MAGNITUDE);
718  LIBMESH_CHKERR(ierr);
719  return;
720  }
721  case SMALLEST_MAGNITUDE:
722  {
723  ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_MAGNITUDE);
724  LIBMESH_CHKERR(ierr);
725  return;
726  }
727  case LARGEST_REAL:
728  {
729  ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_REAL);
730  LIBMESH_CHKERR(ierr);
731  return;
732  }
733  case SMALLEST_REAL:
734  {
735  ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_REAL);
736  LIBMESH_CHKERR(ierr);
737  return;
738  }
739  case LARGEST_IMAGINARY:
740  {
741  ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_IMAGINARY);
742  LIBMESH_CHKERR(ierr);
743  return;
744  }
745  case SMALLEST_IMAGINARY:
746  {
747  ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_IMAGINARY);
748  LIBMESH_CHKERR(ierr);
749  return;
750  }
751 
752  // The EPS_TARGET_XXX enums were added in SLEPc 3.1
753 #if !SLEPC_VERSION_LESS_THAN(3,1,0)
754  case TARGET_MAGNITUDE:
755  {
756  ierr = EPSSetTarget(_eps, PS(this->_target_val));
757  LIBMESH_CHKERR(ierr);
758  ierr = EPSSetWhichEigenpairs (_eps, EPS_TARGET_MAGNITUDE);
759  LIBMESH_CHKERR(ierr);
760  return;
761  }
762  case TARGET_REAL:
763  {
764  ierr = EPSSetTarget(_eps, PS(this->_target_val));
765  LIBMESH_CHKERR(ierr);
766  ierr = EPSSetWhichEigenpairs (_eps, EPS_TARGET_REAL);
767  LIBMESH_CHKERR(ierr);
768  return;
769  }
770  case TARGET_IMAGINARY:
771  {
772  ierr = EPSSetTarget(_eps, PS(this->_target_val));
773  LIBMESH_CHKERR(ierr);
774  ierr = EPSSetWhichEigenpairs (_eps, EPS_TARGET_IMAGINARY);
775  LIBMESH_CHKERR(ierr);
776  return;
777  }
778 #endif
779 
780  default:
781  libmesh_error_msg("ERROR: Unsupported SLEPc position of spectrum: " << this->_position_of_spectrum);
782  }
783 }
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:337
PetscScalar PS(T val)
Definition: petsc_macro.h:166
EPS _eps
Eigenproblem solver context.

◆ set_slepc_problem_type()

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 679 of file slepc_eigen_solver.C.

680 {
681  PetscErrorCode ierr = 0;
682 
683  switch (this->_eigen_problem_type)
684  {
685  case NHEP:
686  ierr = EPSSetProblemType (_eps, EPS_NHEP); LIBMESH_CHKERR(ierr); return;
687  case GNHEP:
688  ierr = EPSSetProblemType (_eps, EPS_GNHEP); LIBMESH_CHKERR(ierr); return;
689  case HEP:
690  ierr = EPSSetProblemType (_eps, EPS_HEP); LIBMESH_CHKERR(ierr); return;
691  case GHEP:
692  ierr = EPSSetProblemType (_eps, EPS_GHEP); LIBMESH_CHKERR(ierr); return;
693 #if !SLEPC_VERSION_LESS_THAN(3,3,0)
694  // EPS_GHIEP added in 3.3.0
695  case GHIEP:
696  ierr = EPSSetProblemType (_eps, EPS_GHIEP); LIBMESH_CHKERR(ierr); return;
697 #endif
698 
699  default:
700  libMesh::err << "ERROR: Unsupported SLEPc Eigen Problem: "
701  << this->_eigen_problem_type << std::endl
702  << "Continuing with SLEPc defaults" << std::endl;
703  }
704 }
OStreamProxy err
EPS _eps
Eigenproblem solver context.
EigenProblemType _eigen_problem_type
Enum stating which type of eigen problem we deal with.
Definition: eigen_solver.h:332

◆ set_slepc_solver_type()

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 647 of file slepc_eigen_solver.C.

648 {
649  PetscErrorCode ierr = 0;
650 
651  switch (this->_eigen_solver_type)
652  {
653  case POWER:
654  ierr = EPSSetType (_eps, EPSPOWER); LIBMESH_CHKERR(ierr); return;
655  case SUBSPACE:
656  ierr = EPSSetType (_eps, EPSSUBSPACE); LIBMESH_CHKERR(ierr); return;
657  case LAPACK:
658  ierr = EPSSetType (_eps, EPSLAPACK); LIBMESH_CHKERR(ierr); return;
659  case ARNOLDI:
660  ierr = EPSSetType (_eps, EPSARNOLDI); LIBMESH_CHKERR(ierr); return;
661  case LANCZOS:
662  ierr = EPSSetType (_eps, EPSLANCZOS); LIBMESH_CHKERR(ierr); return;
663  case KRYLOVSCHUR:
664  ierr = EPSSetType (_eps, EPSKRYLOVSCHUR); LIBMESH_CHKERR(ierr); return;
665  // case ARPACK:
666  // ierr = EPSSetType (_eps, (char *) EPSARPACK); LIBMESH_CHKERR(ierr); return;
667 
668  default:
669  libMesh::err << "ERROR: Unsupported SLEPc Eigen Solver: "
670  << Utility::enum_to_string(this->_eigen_solver_type) << std::endl
671  << "Continuing with SLEPc defaults" << std::endl;
672  }
673 }
OStreamProxy err
std::string enum_to_string(const T e)
EPS _eps
Eigenproblem solver context.
EigenSolverType _eigen_solver_type
Enum stating which type of eigensolver to use.
Definition: eigen_solver.h:327

◆ set_solver_configuration()

template<typename T >
void libMesh::EigenSolver< T >::set_solver_configuration ( SolverConfiguration solver_configuration)
inherited

Set the solver configuration object.

Definition at line 79 of file eigen_solver.C.

Referenced by main().

80 {
81  _solver_configuration = &solver_configuration;
82 }
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
Definition: eigen_solver.h:348

◆ solve_generalized() [1/6]

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

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 244 of file slepc_eigen_solver.C.

250 {
251  this->clear ();
252 
253  this->init ();
254 
255  // Make sure the data passed in are really of Petsc types
256  PetscMatrix<T> * matrix_A = dynamic_cast<PetscMatrix<T> *>(&matrix_A_in);
257  PetscMatrix<T> * matrix_B = dynamic_cast<PetscMatrix<T> *>(&matrix_B_in);
258 
259  libmesh_error_msg_if(!matrix_A || !matrix_B,
260  "Error: inputs to solve_generalized() must be of type PetscMatrix.");
261 
262  // Close the matrix and vectors in case this wasn't already done.
263  if (this->_close_matrix_before_solve)
264  {
265  matrix_A->close ();
266  matrix_B->close ();
267  }
268 
269  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), nullptr, nev, ncv, tol, m_its);
270 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
virtual void clear() noexcept override
Release all memory and clear data structures.
virtual void init() override
Initialize data structures if not done so already.

◆ solve_generalized() [2/6]

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

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

Implements libMesh::EigenSolver< T >.

Definition at line 274 of file slepc_eigen_solver.C.

280 {
281  this->clear();
282 
283  this->init ();
284 
285  PetscErrorCode ierr=0;
286 
287  // Prepare the matrix. Note that the const_cast is only necessary
288  // because PETSc does not accept a const void *. Inside the member
289  // function _petsc_shell_matrix() below, the pointer is casted back
290  // to a const ShellMatrix<T> *.
291  Mat mat_A;
292  ierr = MatCreateShell(this->comm().get(),
293  shell_matrix_A.m(), // Specify the number of local rows
294  shell_matrix_A.n(), // Specify the number of local columns
295  PETSC_DETERMINE,
296  PETSC_DETERMINE,
297  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
298  &mat_A);
299  LIBMESH_CHKERR(ierr);
300 
301  PetscMatrix<T> * matrix_B = dynamic_cast<PetscMatrix<T> *>(&matrix_B_in);
302 
303  libmesh_error_msg_if(!matrix_B, "Error: inputs to solve_generalized() must be of type PetscMatrix.");
304 
305  // Close the matrix and vectors in case this wasn't already done.
306  if (this->_close_matrix_before_solve)
307  matrix_B->close ();
308 
309  ierr = MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
310  LIBMESH_CHKERR(ierr);
311  ierr = MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
312  LIBMESH_CHKERR(ierr);
313 
314  return _solve_generalized_helper (mat_A, matrix_B->mat(), nullptr, nev, ncv, tol, m_its);
315 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
const Parallel::Communicator & comm() const
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...
virtual void clear() noexcept override
Release all memory and clear data structures.
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() override
Initialize data structures if not done so already.

◆ solve_generalized() [3/6]

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

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 319 of file slepc_eigen_solver.C.

325 {
326  this->clear();
327 
328  this->init ();
329 
330  PetscErrorCode ierr=0;
331 
332  PetscMatrix<T> * matrix_A = dynamic_cast<PetscMatrix<T> *>(&matrix_A_in);
333 
334  libmesh_error_msg_if(!matrix_A, "Error: inputs to solve_generalized() must be of type PetscMatrix.");
335 
336  // Close the matrix and vectors in case this wasn't already done.
337  if (this->_close_matrix_before_solve)
338  matrix_A->close ();
339 
340  // Prepare the matrix. Note that the const_cast is only necessary
341  // because PETSc does not accept a const void *. Inside the member
342  // function _petsc_shell_matrix() below, the pointer is casted back
343  // to a const ShellMatrix<T> *.
344  Mat mat_B;
345  ierr = MatCreateShell(this->comm().get(),
346  shell_matrix_B.m(), // Specify the number of local rows
347  shell_matrix_B.n(), // Specify the number of local columns
348  PETSC_DETERMINE,
349  PETSC_DETERMINE,
350  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
351  &mat_B);
352  LIBMESH_CHKERR(ierr);
353 
354 
355  ierr = MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
356  LIBMESH_CHKERR(ierr);
357  ierr = MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
358  LIBMESH_CHKERR(ierr);
359 
360  return _solve_generalized_helper (matrix_A->mat(), mat_B, nullptr, nev, ncv, tol, m_its);
361 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
const Parallel::Communicator & comm() const
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...
virtual void clear() noexcept override
Release all memory and clear data structures.
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() override
Initialize data structures if not done so already.

◆ solve_generalized() [4/6]

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

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 365 of file slepc_eigen_solver.C.

371 {
372  this->clear();
373 
374  this->init ();
375 
376  PetscErrorCode ierr=0;
377 
378  // Prepare the matrices. Note that the const_casts are only
379  // necessary because PETSc does not accept a const void *. Inside
380  // the member function _petsc_shell_matrix() below, the pointer is
381  // casted back to a const ShellMatrix<T> *.
382  Mat mat_A;
383  ierr = MatCreateShell(this->comm().get(),
384  shell_matrix_A.m(), // Specify the number of local rows
385  shell_matrix_A.n(), // Specify the number of local columns
386  PETSC_DETERMINE,
387  PETSC_DETERMINE,
388  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
389  &mat_A);
390  LIBMESH_CHKERR(ierr);
391 
392  Mat mat_B;
393  ierr = MatCreateShell(this->comm().get(),
394  shell_matrix_B.m(), // Specify the number of local rows
395  shell_matrix_B.n(), // Specify the number of local columns
396  PETSC_DETERMINE,
397  PETSC_DETERMINE,
398  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
399  &mat_B);
400  LIBMESH_CHKERR(ierr);
401 
402  ierr = MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
403  LIBMESH_CHKERR(ierr);
404  ierr = MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
405  LIBMESH_CHKERR(ierr);
406 
407  ierr = MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
408  LIBMESH_CHKERR(ierr);
409  ierr = MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
410  LIBMESH_CHKERR(ierr);
411 
412  return _solve_generalized_helper (mat_A, mat_B, nullptr, nev, ncv, tol, m_its);
413 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
const Parallel::Communicator & comm() const
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...
virtual void clear() noexcept override
Release all memory and clear data structures.
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() override
Initialize data structures if not done so already.

◆ solve_generalized() [5/6]

template<typename T>
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_generalized ( ShellMatrix< T > &  matrix_A,
ShellMatrix< T > &  matrix_B,
SparseMatrix< T > &  precond,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
overridevirtual

Solves the generalized eigenproblem involving ShellMatrices matrix_A, matrix_B and the SparseMatrix precond.

Returns
The number of converged eigenpairs and the number of iterations.

Implements libMesh::EigenSolver< T >.

Definition at line 417 of file slepc_eigen_solver.C.

424 {
425  this->clear();
426 
427  this->init ();
428 
429  // Make sure the SparseMatrix passed in is really a PetscMatrix
430  PetscMatrix<T> * precond = dynamic_cast<PetscMatrix<T> *>(&precond_in);
431 
432  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_generalized() must be of type PetscMatrix.");
433 
434  PetscShellMatrix<T> * matrix_A = dynamic_cast<PetscShellMatrix<T> *> (&shell_matrix_A);
435 
436  libmesh_error_msg_if(!matrix_A, "Error: input operator A to solve_generalized() must be of type PetscShellMatrix.");
437 
438  PetscShellMatrix<T> * matrix_B = dynamic_cast<PetscShellMatrix<T> *> (&shell_matrix_B);
439 
440  libmesh_error_msg_if(!matrix_B, "Error: input operator B to solve_generalized() must be of type PetscShellMatrix.");
441 
442  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), precond->mat(), nev, ncv, tol, m_its);
443 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
virtual void clear() noexcept override
Release all memory and clear data structures.
virtual void init() override
Initialize data structures if not done so already.

◆ solve_generalized() [6/6]

template<typename T>
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_generalized ( ShellMatrix< T > &  matrix_A,
ShellMatrix< T > &  matrix_B,
ShellMatrix< T > &  precond,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
overridevirtual

Solves the generalized eigenproblem involving ShellMatrices matrix_A, matrix_B and the shell preconditioning matrix.

Returns
The number of converged eigenpairs and the number of iterations.

Implements libMesh::EigenSolver< T >.

Definition at line 447 of file slepc_eigen_solver.C.

454 {
455  this->clear();
456 
457  this->init ();
458 
459  // Make sure the ShellMatrix passed in is really a PetscShellMatrix
460  PetscShellMatrix<T> * precond = dynamic_cast<PetscShellMatrix<T> *>(&precond_in);
461 
462  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_generalized() must be of type PetscShellMatrix.");
463 
464  PetscShellMatrix<T> * matrix_A = dynamic_cast<PetscShellMatrix<T> *> (&shell_matrix_A);
465 
466  libmesh_error_msg_if(!matrix_A, "Error: input operator A to solve_generalized() must be of type PetscShellMatrix.");
467 
468  PetscShellMatrix<T> * matrix_B = dynamic_cast<PetscShellMatrix<T> *> (&shell_matrix_B);
469 
470  libmesh_error_msg_if(!matrix_B, "Error: input operator B to solve_generalized() must be of type PetscShellMatrix.");
471 
472  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), precond->mat(), nev, ncv, tol, m_its);
473 }
std::pair< unsigned int, unsigned int > _solve_generalized_helper(Mat mat_A, Mat mat_B, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the generalized eigensolve.
virtual void clear() noexcept override
Release all memory and clear data structures.
virtual void init() override
Initialize data structures if not done so already.

◆ solve_standard() [1/4]

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

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 109 of file slepc_eigen_solver.C.

114 {
115  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
116 
117  this->clear ();
118 
119  this->init ();
120 
121  // Make sure the SparseMatrix passed in is really a PetscMatrix
122  PetscMatrix<T> * matrix_A = dynamic_cast<PetscMatrix<T> *>(&matrix_A_in);
123 
124  libmesh_error_msg_if(!matrix_A, "Error: input matrix to solve_standard() must be a PetscMatrix.");
125 
126  // Close the matrix and vectors in case this wasn't already done.
127  if (this->_close_matrix_before_solve)
128  matrix_A->close ();
129 
130  return _solve_standard_helper(matrix_A->mat(), nullptr, nev, ncv, tol, m_its);
131 }
std::pair< unsigned int, unsigned int > _solve_standard_helper(Mat mat, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the standard eigensolve.
virtual void clear() noexcept override
Release all memory and clear data structures.
virtual void init() override
Initialize data structures if not done so already.

◆ solve_standard() [2/4]

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

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

Implements libMesh::EigenSolver< T >.

Definition at line 136 of file slepc_eigen_solver.C.

141 {
142  this->clear ();
143 
144  this->init ();
145 
146  PetscErrorCode ierr=0;
147 
148  // Prepare the matrix. Note that the const_cast is only necessary
149  // because PETSc does not accept a const void *. Inside the member
150  // function _petsc_shell_matrix() below, the pointer is casted back
151  // to a const ShellMatrix<T> *.
152  Mat mat;
153  ierr = MatCreateShell(this->comm().get(),
154  shell_matrix.m(), // Specify the number of local rows
155  shell_matrix.n(), // Specify the number of local columns
156  PETSC_DETERMINE,
157  PETSC_DETERMINE,
158  const_cast<void *>(static_cast<const void *>(&shell_matrix)),
159  &mat);
160  LIBMESH_CHKERR(ierr);
161 
162  ierr = MatShellSetOperation(mat,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
163  LIBMESH_CHKERR(ierr);
164  ierr = MatShellSetOperation(mat,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
165  LIBMESH_CHKERR(ierr);
166 
167  return _solve_standard_helper(mat, nullptr, nev, ncv, tol, m_its);
168 }
const Parallel::Communicator & comm() const
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...
std::pair< unsigned int, unsigned int > _solve_standard_helper(Mat mat, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the standard eigensolve.
virtual void clear() noexcept override
Release all memory and clear data structures.
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() override
Initialize data structures if not done so already.

◆ solve_standard() [3/4]

template<typename T>
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_standard ( ShellMatrix< T > &  shell_matrix,
SparseMatrix< T > &  precond,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
overridevirtual

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

Implements libMesh::EigenSolver< T >.

Definition at line 172 of file slepc_eigen_solver.C.

178 {
179  this->clear ();
180 
181  this->init ();
182 
183  // Make sure the SparseMatrix passed in is really a PetscMatrix
184  PetscMatrix<T> * precond = dynamic_cast<PetscMatrix<T> *>(&precond_in);
185 
186  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_standard() must be a PetscMatrix.");
187 
188  PetscShellMatrix<T> * matrix = dynamic_cast<PetscShellMatrix<T> *> (&shell_matrix);
189 
190  libmesh_error_msg_if(!matrix, "Error: input operator matrix to solve_standard() must be a PetscShellMatrix.");
191 
192  return _solve_standard_helper(matrix->mat(), precond->mat(), nev, ncv, tol, m_its);
193 }
std::pair< unsigned int, unsigned int > _solve_standard_helper(Mat mat, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the standard eigensolve.
virtual void clear() noexcept override
Release all memory and clear data structures.
virtual void init() override
Initialize data structures if not done so already.

◆ solve_standard() [4/4]

template<typename T>
std::pair< unsigned int, unsigned int > libMesh::SlepcEigenSolver< T >::solve_standard ( ShellMatrix< T > &  shell_matrix,
ShellMatrix< T > &  precond,
int  nev,
int  ncv,
const double  tol,
const unsigned int  m_its 
)
overridevirtual

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

Implements libMesh::EigenSolver< T >.

Definition at line 197 of file slepc_eigen_solver.C.

203 {
204  this->clear ();
205 
206  this->init ();
207 
208  // Make sure the SparseMatrix passed in is really a PetscMatrix
209  PetscShellMatrix<T> * precond = dynamic_cast<PetscShellMatrix<T> *>(&precond_in);
210 
211  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_standard() must be a PetscShellMatrix.");
212 
213  PetscShellMatrix<T> * matrix = dynamic_cast<PetscShellMatrix<T> *> (&shell_matrix);
214 
215  libmesh_error_msg_if(!matrix, "Error: input operator matrix to solve_standard() must be a PetscShellMatrix.");
216 
217  return _solve_standard_helper(matrix->mat(), precond->mat(), nev, ncv, tol, m_its);
218 }
std::pair< unsigned int, unsigned int > _solve_standard_helper(Mat mat, Mat precond, int nev, int ncv, const double tol, const unsigned int m_its)
Helper function that actually performs the standard eigensolve.
virtual void clear() noexcept override
Release all memory and clear data structures.
virtual void init() override
Initialize data structures if not done so already.

Member Data Documentation

◆ _close_matrix_before_solve

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

◆ _communicator

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

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _eigen_problem_type

template<typename T>
EigenProblemType libMesh::EigenSolver< T >::_eigen_problem_type
protectedinherited

Enum stating which type of eigen problem we deal with.

Definition at line 332 of file eigen_solver.h.

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

◆ _eigen_solver_type

template<typename T>
EigenSolverType libMesh::EigenSolver< T >::_eigen_solver_type
protectedinherited

Enum stating which type of eigensolver to use.

Definition at line 327 of file eigen_solver.h.

Referenced by libMesh::EigenSolver< libMesh::Number >::eigen_solver_type(), and libMesh::EigenSolver< libMesh::Number >::set_eigensolver_type().

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

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

◆ _eps

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

Eigenproblem solver context.

Definition at line 326 of file slepc_eigen_solver.h.

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

◆ _initial_space

template<typename T>
PetscVector<T>* libMesh::SlepcEigenSolver< T >::_initial_space
private

A vector used for initial space.

The vector will be used as the basis for EPS.

Definition at line 331 of file slepc_eigen_solver.h.

◆ _is_initialized

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

Flag indicating if the data structures have been initialized.

Definition at line 342 of file eigen_solver.h.

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

◆ _mutex

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.

◆ _n_objects

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

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

◆ _position_of_spectrum

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

Enum stating where to evaluate the spectrum.

Definition at line 337 of file eigen_solver.h.

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

◆ _solver_configuration

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 348 of file eigen_solver.h.

◆ _target_val

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

Definition at line 350 of file eigen_solver.h.


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