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 ()
 
void print_eigenvalues () const
 Print the eigenvalues and associated error. More...
 
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 838 of file slepc_eigen_solver.C.

839 {
840  PetscFunctionBegin;
841 
842  // Get the matrix context.
843  void * ctx;
844  LibmeshPetscCallQ(MatShellGetContext(mat,&ctx));
845 
846  // Get user shell matrix object.
847  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
848 
849  // Make \p NumericVector instances around the vector.
850  PetscVector<T> dest_global(dest, shell_matrix.comm());
851 
852  // Call the user function.
853  shell_matrix.get_diagonal(dest_global);
854 
855  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
856 }
LibmeshPetscCallQ(DMShellGetContext(dm, &ctx))
void * ctx
PetscFunctionReturn(LIBMESH_PETSC_SUCCESS)

◆ _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 816 of file slepc_eigen_solver.C.

817 {
818  PetscFunctionBegin;
819 
820  // Get the matrix context.
821  void * ctx;
822  LibmeshPetscCallQ(MatShellGetContext(mat,&ctx));
823 
824  // Get user shell matrix object.
825  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
826 
827  // Make \p NumericVector instances around the vectors.
828  PetscVector<T> arg_global(arg, shell_matrix.comm());
829  PetscVector<T> dest_global(dest, shell_matrix.comm());
830 
831  // Call the user function.
832  shell_matrix.vector_mult(dest_global,arg_global);
833 
834  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
835 }
LibmeshPetscCallQ(DMShellGetContext(dm, &ctx))
void * ctx
PetscFunctionReturn(LIBMESH_PETSC_SUCCESS)

◆ _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 448 of file slepc_eigen_solver.C.

455 {
456  LOG_SCOPE("solve_generalized()", "SlepcEigenSolver");
457 
458  // Set operators.
459  LibmeshPetscCall(EPSSetOperators (_eps, mat_A, mat_B));
460 
461  return this->_solve_helper(precond, nev, ncv, tol, m_its);
462 }
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 468 of file slepc_eigen_solver.C.

473 {
474  // converged eigen pairs and number of iterations
475  PetscInt nconv=0;
476  PetscInt its=0;
477  ST st=nullptr;
478 
479  //set the problem type and the position of the spectrum
482 
483  // Set eigenvalues to be computed.
484 #if SLEPC_VERSION_LESS_THAN(3,0,0)
485  LibmeshPetscCall(EPSSetDimensions (_eps, nev, ncv));
486 #else
487  LibmeshPetscCall(EPSSetDimensions (_eps, nev, ncv, PETSC_DECIDE));
488 #endif
489  // Set the tolerance and maximum iterations.
490  LibmeshPetscCall(EPSSetTolerances (_eps, tol, m_its));
491 
492  // Set runtime options, e.g.,
493  // -eps_type <type>, -eps_nev <nev>, -eps_ncv <ncv>
494  // Similar to PETSc, these options will override those specified
495  // above as long as EPSSetFromOptions() is called _after_ any
496  // other customization routines.
497  LibmeshPetscCall(EPSSetFromOptions (_eps));
498 
499  // Set a preconditioning matrix to ST
500  if (precond) {
501  LibmeshPetscCall(EPSGetST(_eps,&st));
502 #if SLEPC_VERSION_LESS_THAN(3,15,0)
503  LibmeshPetscCall(STPrecondSetMatForPC(st, precond));
504 #else
505  LibmeshPetscCall(STSetPreconditionerMat(st, precond));
506 #endif
507  }
508 
509  // If the SolverConfiguration object is provided, use it to override
510  // solver options.
511  if (this->_solver_configuration)
512  {
514  }
515 
516  // If an initial space is provided, let us attach it to EPS
517  if (_initial_space) {
518  // Get a handle for the underlying Vec.
519  Vec initial_vector = _initial_space->vec();
520 
521  LibmeshPetscCall(EPSSetInitialSpace(_eps, 1, &initial_vector));
522  }
523 
524  // Solve the eigenproblem.
525  LibmeshPetscCall(EPSSolve (_eps));
526 
527  // Get the number of iterations.
528  LibmeshPetscCall(EPSGetIterationNumber (_eps, &its));
529 
530  // Get number of converged eigenpairs.
531  LibmeshPetscCall(EPSGetConverged(_eps,&nconv));
532 
533  // return the number of converged eigenpairs
534  // and the number of iterations
535  return std::make_pair(nconv, its);
536 }
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.
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 215 of file slepc_eigen_solver.C.

221 {
222  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
223 
224  // Set operators.
225  LibmeshPetscCall(EPSSetOperators (_eps, mat, LIBMESH_PETSC_NULLPTR));
226 
227  return this->_solve_helper(precond, nev, ncv, tol, m_its);
228 }
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 783 of file slepc_eigen_solver.C.

784 {
785  this->init();
786 
787  // Make sure the input vector is actually a PetscVector
788  PetscVector<T> * deflation_vector_petsc_vec =
789  dynamic_cast<PetscVector<T> *>(&deflation_vector_in);
790 
791  libmesh_error_msg_if(!deflation_vector_petsc_vec, "Error attaching deflation space: input vector must be a PetscVector.");
792 
793  // Get a handle for the underlying Vec.
794  Vec deflation_vector = deflation_vector_petsc_vec->vec();
795 
796 #if SLEPC_VERSION_LESS_THAN(3,1,0)
797  LibmeshPetscCall(EPSAttachDeflationSpace(_eps, 1, &deflation_vector, PETSC_FALSE));
798 #else
799  LibmeshPetscCall(EPSSetDeflationSpace(_eps, 1, &deflation_vector));
800 #endif
801 }
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::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::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::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), 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::AdvectionSystem::assemble_claw_rhs(), 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::Partitioner::build_graph(), 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::CondensedEigenSystem::copy_super_to_sub(), 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< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), 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::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), 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::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_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_constraint_rows(), 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::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), 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::MeshBase::print_constraint_rows(), 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::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), 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::VariationalMeshSmoother::smooth(), libMesh::ClawSystem::solve_conservation_law(), 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(), VolumeTest::testC0PolygonMethods(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), 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(), update_current_local_solution(), 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::MeshTools::volume(), libMesh::STLIO::write(), 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 715 of file slepc_eigen_solver.C.

717 {
718  PetscReal re, im;
719 
720  // Make sure the NumericVector passed in is really a PetscVector
721  PetscVector<T> * solution = dynamic_cast<PetscVector<T> *>(&solution_in);
722 
723  libmesh_error_msg_if(!solution, "Error getting eigenvector: input vector must be a PetscVector.");
724 
725  // real and imaginary part of the ith eigenvalue.
726  PetscScalar kr, ki;
727 
728  solution->close();
729 
730  LibmeshPetscCall(EPSGetEigenpair(_eps, i, &kr, &ki, solution->vec(),
731  LIBMESH_PETSC_NULLPTR));
732 
733 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
734  re = PetscRealPart(kr);
735  im = PetscImaginaryPart(kr);
736 #else
737  re = kr;
738  im = ki;
739 #endif
740 
741  return std::make_pair(re, im);
742 }
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 746 of file slepc_eigen_solver.C.

747 {
748  PetscReal re, im;
749 
750  // real and imaginary part of the ith eigenvalue.
751  PetscScalar kr, ki;
752 
753  LibmeshPetscCall(EPSGetEigenvalue(_eps, i, &kr, &ki));
754 
755 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
756  re = PetscRealPart(kr);
757  im = PetscImaginaryPart(kr);
758 #else
759  re = kr;
760  im = ki;
761 #endif
762 
763  return std::make_pair(re, im);
764 }
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 768 of file slepc_eigen_solver.C.

769 {
770  PetscReal error;
771 
772 #if SLEPC_VERSION_LESS_THAN(3,6,0)
773  LibmeshPetscCall(EPSComputeRelativeError(_eps, i, &error));
774 #else
775  LibmeshPetscCall(EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error));
776 #endif
777 
778  return error;
779 }
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  // Initialize the data structures if not done so already.
89  if (!this->initialized())
90  {
91  this->_is_initialized = true;
92 
93  // Create the eigenproblem solver context
94  LibmeshPetscCall(EPSCreate (this->comm().get(), &_eps));
95 
96  // Set user-specified solver
98  }
99 }
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::Partitioner::build_graph(), 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::UnstructuredMesh::copy_nodes_and_elements(), 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::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_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::DofMap::n_dofs_per_processor(), 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::MeshBase::print_constraint_rows(), 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_eigenvalues()

template<typename T >
void libMesh::SlepcEigenSolver< T >::print_eigenvalues ( ) const

Print the eigenvalues and associated error.

Definition at line 540 of file slepc_eigen_solver.C.

541 {
542  // converged eigen pairs and number of iterations
543  PetscInt nconv=0;
544 
545  // The relative error.
546  PetscReal error, re, im;
547 
548  // Pointer to vectors of the real parts, imaginary parts.
549  PetscScalar kr, ki;
550 
551  // Get number of converged eigenpairs.
552  LibmeshPetscCall(EPSGetConverged(_eps,&nconv));
553 
554  // Display eigenvalues and relative errors.
555  LibmeshPetscCall(PetscPrintf(this->comm().get(),
556  " k ||Ax-kx||/|kx|\n"
557  " ----------------- -----------------\n" ));
558 
559  for (PetscInt i=0; i<nconv; i++ )
560  {
561  LibmeshPetscCall(EPSGetEigenpair(_eps, i, &kr, &ki, LIBMESH_PETSC_NULLPTR,
562  LIBMESH_PETSC_NULLPTR));
563 
564 #if SLEPC_VERSION_LESS_THAN(3,6,0)
565  LibmeshPetscCall(EPSComputeRelativeError(_eps, i, &error));
566 #else
567  LibmeshPetscCall(EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error));
568 #endif
569 
570 #ifdef LIBMESH_USE_COMPLEX_NUMBERS
571  re = PetscRealPart(kr);
572  im = PetscImaginaryPart(kr);
573 #else
574  re = kr;
575  im = ki;
576 #endif
577 
578  if (im != .0)
579  LibmeshPetscCall(PetscPrintf(this->comm().get()," %9f%+9f i %12f\n", double(re), double(im), double(error)));
580  else
581  LibmeshPetscCall(PetscPrintf(this->comm().get()," %12f %12f\n", double(re), double(error)));
582  }
583 
584  LibmeshPetscCall(PetscPrintf(this->comm().get(),"\n" ));
585 }
const Parallel::Communicator & comm() const
EPS _eps
Eigenproblem solver context.

◆ 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::MeshFunction::check_found_elem(), 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_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::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::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::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(), 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::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::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::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::MeshBase::print_constraint_rows(), 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::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), 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::testBadGmsh(), 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::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), 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 804 of file slepc_eigen_solver.C.

805 {
806 #if SLEPC_VERSION_LESS_THAN(3,1,0)
807  libmesh_error_msg("SLEPc 3.1 is required to call EigenSolver::set_initial_space()");
808 #else
809  // Make sure the input vector (which is still owned by caller) is
810  // actually a PetscVector
811  _initial_space = cast_ptr<PetscVector<T> *>(&initial_space_in);
812 #endif
813 }
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 647 of file slepc_eigen_solver.C.

648 {
649  switch (this->_position_of_spectrum)
650  {
651  case LARGEST_MAGNITUDE:
652  {
653  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_LARGEST_MAGNITUDE));
654  return;
655  }
656  case SMALLEST_MAGNITUDE:
657  {
658  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_MAGNITUDE));
659  return;
660  }
661  case LARGEST_REAL:
662  {
663  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_LARGEST_REAL));
664  return;
665  }
666  case SMALLEST_REAL:
667  {
668  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_REAL));
669  return;
670  }
671  case LARGEST_IMAGINARY:
672  {
673  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_LARGEST_IMAGINARY));
674  return;
675  }
676  case SMALLEST_IMAGINARY:
677  {
678  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_IMAGINARY));
679  return;
680  }
681 
682  // The EPS_TARGET_XXX enums were added in SLEPc 3.1
683 #if !SLEPC_VERSION_LESS_THAN(3,1,0)
684  case TARGET_MAGNITUDE:
685  {
686  LibmeshPetscCall(EPSSetTarget(_eps, PS(this->_target_val)));
687  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_TARGET_MAGNITUDE));
688  return;
689  }
690  case TARGET_REAL:
691  {
692  LibmeshPetscCall(EPSSetTarget(_eps, PS(this->_target_val)));
693  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_TARGET_REAL));
694  return;
695  }
696  case TARGET_IMAGINARY:
697  {
698  LibmeshPetscCall(EPSSetTarget(_eps, PS(this->_target_val)));
699  LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_TARGET_IMAGINARY));
700  return;
701  }
702 #endif
703 
704  default:
705  libmesh_error_msg("ERROR: Unsupported SLEPc position of spectrum: " << this->_position_of_spectrum);
706  }
707 }
PositionOfSpectrum _position_of_spectrum
Enum stating where to evaluate the spectrum.
Definition: eigen_solver.h:337
PetscScalar PS(T val)
Definition: petsc_macro.h:168
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 619 of file slepc_eigen_solver.C.

620 {
621  switch (this->_eigen_problem_type)
622  {
623  case NHEP:
624  LibmeshPetscCall(EPSSetProblemType (_eps, EPS_NHEP)); return;
625  case GNHEP:
626  LibmeshPetscCall(EPSSetProblemType (_eps, EPS_GNHEP)); return;
627  case HEP:
628  LibmeshPetscCall(EPSSetProblemType (_eps, EPS_HEP)); return;
629  case GHEP:
630  LibmeshPetscCall(EPSSetProblemType (_eps, EPS_GHEP)); return;
631 #if !SLEPC_VERSION_LESS_THAN(3,3,0)
632  // EPS_GHIEP added in 3.3.0
633  case GHIEP:
634  LibmeshPetscCall(EPSSetProblemType (_eps, EPS_GHIEP)); return;
635 #endif
636 
637  default:
638  libMesh::err << "ERROR: Unsupported SLEPc Eigen Problem: "
639  << this->_eigen_problem_type << std::endl
640  << "Continuing with SLEPc defaults" << std::endl;
641  }
642 }
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 589 of file slepc_eigen_solver.C.

590 {
591  switch (this->_eigen_solver_type)
592  {
593  case POWER:
594  LibmeshPetscCall(EPSSetType (_eps, EPSPOWER)); return;
595  case SUBSPACE:
596  LibmeshPetscCall(EPSSetType (_eps, EPSSUBSPACE)); return;
597  case LAPACK:
598  LibmeshPetscCall(EPSSetType (_eps, EPSLAPACK)); return;
599  case ARNOLDI:
600  LibmeshPetscCall(EPSSetType (_eps, EPSARNOLDI)); return;
601  case LANCZOS:
602  LibmeshPetscCall(EPSSetType (_eps, EPSLANCZOS)); return;
603  case KRYLOVSCHUR:
604  LibmeshPetscCall(EPSSetType (_eps, EPSKRYLOVSCHUR)); return;
605  // case ARPACK:
606  // LibmeshPetscCall(EPSSetType (_eps, (char *) EPSARPACK)); return;
607 
608  default:
609  libMesh::err << "ERROR: Unsupported SLEPc Eigen Solver: "
610  << Utility::enum_to_string(this->_eigen_solver_type) << std::endl
611  << "Continuing with SLEPc defaults" << std::endl;
612  }
613 }
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 234 of file slepc_eigen_solver.C.

240 {
241  this->clear ();
242 
243  this->init ();
244 
245  // Make sure the data passed in are really of Petsc types
246  auto * const matrix_A = cast_ptr<PetscMatrixBase<T> *>(&matrix_A_in);
247  auto * const matrix_B = cast_ptr<PetscMatrixBase<T> *>(&matrix_B_in);
248 
249  libmesh_error_msg_if(!matrix_A || !matrix_B,
250  "Error: inputs to solve_generalized() must be of type PetscMatrixBase.");
251 
252  // Close the matrix and vectors in case this wasn't already done.
253  if (this->_close_matrix_before_solve)
254  {
255  matrix_A->close ();
256  matrix_B->close ();
257  }
258 
259  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), nullptr, nev, ncv, tol, m_its);
260 }
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 264 of file slepc_eigen_solver.C.

270 {
271  this->clear();
272 
273  this->init ();
274 
275  // Prepare the matrix. Note that the const_cast is only necessary
276  // because PETSc does not accept a const void *. Inside the member
277  // function _petsc_shell_matrix() below, the pointer is casted back
278  // to a const ShellMatrix<T> *.
279  Mat mat_A;
280  LibmeshPetscCall(MatCreateShell(this->comm().get(),
281  shell_matrix_A.m(), // Specify the number of local rows
282  shell_matrix_A.n(), // Specify the number of local columns
283  PETSC_DETERMINE,
284  PETSC_DETERMINE,
285  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
286  &mat_A));
287 
288  auto * const matrix_B = cast_ptr<PetscMatrixBase<T> *>(&matrix_B_in);
289 
290  libmesh_error_msg_if(!matrix_B, "Error: inputs to solve_generalized() must be of type PetscMatrixBase.");
291 
292  // Close the matrix and vectors in case this wasn't already done.
293  if (this->_close_matrix_before_solve)
294  matrix_B->close ();
295 
296  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
297  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
298 
299  return _solve_generalized_helper (mat_A, matrix_B->mat(), nullptr, nev, ncv, tol, m_its);
300 }
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 304 of file slepc_eigen_solver.C.

310 {
311  this->clear();
312 
313  this->init ();
314 
315  auto * const matrix_A = cast_ptr<PetscMatrixBase<T> *>(&matrix_A_in);
316 
317  libmesh_error_msg_if(!matrix_A, "Error: inputs to solve_generalized() must be of type PetscMatrixBase.");
318 
319  // Close the matrix and vectors in case this wasn't already done.
320  if (this->_close_matrix_before_solve)
321  matrix_A->close ();
322 
323  // Prepare the matrix. Note that the const_cast is only necessary
324  // because PETSc does not accept a const void *. Inside the member
325  // function _petsc_shell_matrix() below, the pointer is casted back
326  // to a const ShellMatrix<T> *.
327  Mat mat_B;
328  LibmeshPetscCall(MatCreateShell(this->comm().get(),
329  shell_matrix_B.m(), // Specify the number of local rows
330  shell_matrix_B.n(), // Specify the number of local columns
331  PETSC_DETERMINE,
332  PETSC_DETERMINE,
333  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
334  &mat_B));
335 
336  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
337  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
338 
339  return _solve_generalized_helper (matrix_A->mat(), mat_B, nullptr, nev, ncv, tol, m_its);
340 }
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 344 of file slepc_eigen_solver.C.

350 {
351  this->clear();
352 
353  this->init ();
354 
355  // Prepare the matrices. Note that the const_casts are only
356  // necessary because PETSc does not accept a const void *. Inside
357  // the member function _petsc_shell_matrix() below, the pointer is
358  // casted back to a const ShellMatrix<T> *.
359  Mat mat_A;
360  LibmeshPetscCall(MatCreateShell(this->comm().get(),
361  shell_matrix_A.m(), // Specify the number of local rows
362  shell_matrix_A.n(), // Specify the number of local columns
363  PETSC_DETERMINE,
364  PETSC_DETERMINE,
365  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
366  &mat_A));
367 
368  Mat mat_B;
369  LibmeshPetscCall(MatCreateShell(this->comm().get(),
370  shell_matrix_B.m(), // Specify the number of local rows
371  shell_matrix_B.n(), // Specify the number of local columns
372  PETSC_DETERMINE,
373  PETSC_DETERMINE,
374  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
375  &mat_B));
376 
377  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
378  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
379 
380  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
381  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
382 
383  return _solve_generalized_helper (mat_A, mat_B, nullptr, nev, ncv, tol, m_its);
384 }
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 388 of file slepc_eigen_solver.C.

395 {
396  this->clear();
397 
398  this->init ();
399 
400  // Make sure the SparseMatrix passed in is really a PetscMatrix
401  auto * const precond = cast_ptr<PetscMatrixBase<T> *>(&precond_in);
402 
403  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_generalized() must be of type PetscMatrixBase.");
404 
405  auto * const matrix_A = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_A);
406 
407  libmesh_error_msg_if(!matrix_A, "Error: input operator A to solve_generalized() must be of type PetscShellMatrix.");
408 
409  auto * const matrix_B = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_B);
410 
411  libmesh_error_msg_if(!matrix_B, "Error: input operator B to solve_generalized() must be of type PetscShellMatrix.");
412 
413  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), precond->mat(), nev, ncv, tol, m_its);
414 }
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 418 of file slepc_eigen_solver.C.

425 {
426  this->clear();
427 
428  this->init ();
429 
430  // Make sure the ShellMatrix passed in is really a PetscShellMatrix
431  auto * const precond = cast_ptr<PetscShellMatrix<T> *>(&precond_in);
432 
433  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_generalized() must be of type PetscShellMatrix.");
434 
435  auto * const matrix_A = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_A);
436 
437  libmesh_error_msg_if(!matrix_A, "Error: input operator A to solve_generalized() must be of type PetscShellMatrix.");
438 
439  auto * const matrix_B = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_B);
440 
441  libmesh_error_msg_if(!matrix_B, "Error: input operator B to solve_generalized() must be of type PetscShellMatrix.");
442 
443  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), precond->mat(), nev, ncv, tol, m_its);
444 }
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 105 of file slepc_eigen_solver.C.

110 {
111  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
112 
113  this->clear ();
114 
115  this->init ();
116 
117  // Make sure the SparseMatrix passed in is really a PetscMatrix
118  auto * const matrix_A = cast_ptr<PetscMatrixBase<T> *>(&matrix_A_in);
119 
120  libmesh_error_msg_if(!matrix_A, "Error: input matrix to solve_standard() must be a PetscMatrixBase.");
121 
122  // Close the matrix and vectors in case this wasn't already done.
123  if (this->_close_matrix_before_solve)
124  matrix_A->close ();
125 
126  return _solve_standard_helper(matrix_A->mat(), nullptr, nev, ncv, tol, m_its);
127 }
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 132 of file slepc_eigen_solver.C.

137 {
138  this->clear ();
139 
140  this->init ();
141 
142  // Prepare the matrix. Note that the const_cast is only necessary
143  // because PETSc does not accept a const void *. Inside the member
144  // function _petsc_shell_matrix() below, the pointer is casted back
145  // to a const ShellMatrix<T> *.
146  Mat mat;
147  LibmeshPetscCall(MatCreateShell(this->comm().get(),
148  shell_matrix.m(), // Specify the number of local rows
149  shell_matrix.n(), // Specify the number of local columns
150  PETSC_DETERMINE,
151  PETSC_DETERMINE,
152  const_cast<void *>(static_cast<const void *>(&shell_matrix)),
153  &mat));
154 
155  LibmeshPetscCall(MatShellSetOperation(mat,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
156  LibmeshPetscCall(MatShellSetOperation(mat,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
157 
158  return _solve_standard_helper(mat, nullptr, nev, ncv, tol, m_its);
159 }
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 163 of file slepc_eigen_solver.C.

169 {
170  this->clear ();
171 
172  this->init ();
173 
174  // Make sure the SparseMatrix passed in is really a PetscMatrix
175  auto * const precond = cast_ptr<PetscMatrixBase<T> *>(&precond_in);
176 
177  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_standard() must be a PetscMatrixBase.");
178 
179  auto * const matrix = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix);
180 
181  libmesh_error_msg_if(!matrix, "Error: input operator matrix to solve_standard() must be a PetscShellMatrix.");
182 
183  return _solve_standard_helper(matrix->mat(), precond->mat(), nev, ncv, tol, m_its);
184 }
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 188 of file slepc_eigen_solver.C.

194 {
195  this->clear ();
196 
197  this->init ();
198 
199  // Make sure the SparseMatrix passed in is really a PetscMatrix
200  auto * const precond = cast_ptr<PetscShellMatrix<T> *>(&precond_in);
201 
202  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_standard() must be a PetscShellMatrix.");
203 
204  auto * const matrix = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix);
205 
206  libmesh_error_msg_if(!matrix, "Error: input operator matrix to solve_standard() must be a PetscShellMatrix.");
207 
208  return _solve_standard_helper(matrix->mat(), precond->mat(), nev, ncv, tol, m_its);
209 }
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 331 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 336 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: