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

Public Member Functions
	SlepcEigenSolver (const Parallel::Communicator &comm_in)
	Constructor.
	~SlepcEigenSolver ()
	Destructor.
virtual void	clear () noexcept override
	Release all memory and clear data structures.
virtual void	init () override
	Initialize data structures if not done so already.
virtual std::pair< unsigned int, unsigned int >	solve_standard (SparseMatrix< T > &matrix_A, int nev, int ncv, const double tol, const unsigned int m_its) override
	This function calls the SLEPc solver to compute the eigenpairs of the SparseMatrix matrix_A.
virtual std::pair< unsigned int, unsigned int >	solve_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.
virtual std::pair< unsigned int, unsigned int >	solve_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.
virtual std::pair< unsigned int, unsigned int >	solve_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.
virtual std::pair< unsigned int, unsigned int >	solve_generalized (SparseMatrix< T > &matrix_A, SparseMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) 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.
virtual std::pair< unsigned int, unsigned int >	solve_generalized (ShellMatrix< T > &matrix_A, SparseMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) override
	Solve generalized eigenproblem when matrix_A is of type ShellMatrix, matrix_B is of type SparseMatrix.
virtual std::pair< unsigned int, unsigned int >	solve_generalized (SparseMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) override
	Solve generalized eigenproblem when matrix_A is of type SparseMatrix, matrix_B is of type ShellMatrix.
virtual std::pair< unsigned int, unsigned int >	solve_generalized (ShellMatrix< T > &matrix_A, ShellMatrix< T > &matrix_B, int nev, int ncv, const double tol, const unsigned int m_its) override
	Solve generalized eigenproblem when both matrix_A and matrix_B are of type ShellMatrix.
virtual std::pair< unsigned int, unsigned int >	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) override
	Solves the generalized eigenproblem involving ShellMatrices matrix_A, matrix_B and the SparseMatrix precond.
virtual std::pair< unsigned int, unsigned int >	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) override
	Solves the generalized eigenproblem involving ShellMatrices matrix_A, matrix_B and the shell preconditioning matrix.
virtual std::pair< Real, Real >	get_eigenpair (dof_id_type i, NumericVector< T > &solution_in) override
virtual std::pair< Real, Real >	get_eigenvalue (dof_id_type i) override
	Same as above, but does not copy the eigenvector.
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.
virtual void	set_initial_space (NumericVector< T > &initial_space_in) override
	Use initial_space_in as the initial guess.
EPS	eps ()
void	print_eigenvalues () const
	Print the eigenvalues and associated error.
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.
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.
void	set_eigenproblem_type (EigenProblemType ept)
	Sets the type of the eigenproblem.
void	set_position_of_spectrum (PositionOfSpectrum pos)
	Sets the position of the spectrum.
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.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< 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.
static std::string	get_info ()
	Gets a string containing the reference information.
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out.
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().
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.

Protected Member Functions
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
EigenSolverType	_eigen_solver_type
	Enum stating which type of eigensolver to use.
EigenProblemType	_eigen_problem_type
	Enum stating which type of eigen problem we deal with.
PositionOfSpectrum	_position_of_spectrum
	Enum stating where to evaluate the spectrum.
bool	_is_initialized
	Flag indicating if the data structures have been initialized.
SolverConfiguration *	_solver_configuration
	Optionally store a SolverOptions object that can be used to set parameters like solver type, tolerances and iteration limits.
Real	_target_val
bool	_close_matrix_before_solve
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.
static Threads::atomic< unsigned int >	_n_objects
	The number of objects.
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

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.
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.
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.
void	set_slepc_solver_type ()
	Tells Slepc to use the user-specified solver stored in _eigen_solver_type.
void	set_slepc_problem_type ()
	Tells Slepc to deal with the type of problem stored in _eigen_problem_type.
void	set_slepc_position_of_spectrum ()
	Tells Slepc to compute the spectrum at the position stored in _position_of_spectrum.

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

Private Attributes
EPS	_eps
	Eigenproblem solver context.
PetscVector< T > *	_initial_space
	A vector used for initial space.

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.

                                                                           :
  EigenSolver<T>(comm_in),
  _initial_space(nullptr)
{
  this->_eigen_solver_type  = ARNOLDI;
  this->_eigen_problem_type = NHEP;
}

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

~SlepcEigenSolver()

template<typename T >

libMesh::SlepcEigenSolver< T >::~SlepcEigenSolver

(

)

Destructor.

Definition at line 60 of file slepc_eigen_solver.C.

{
  this->SlepcEigenSolver::clear ();
}

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

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.

{
  PetscFunctionBegin;
 
  // Get the matrix context.
  void * ctx;
  LibmeshPetscCallQ(MatShellGetContext(mat,&ctx));
 
  // Get user shell matrix object.
  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
 
  // Make \p NumericVector instances around the vector.
  PetscVector<T> dest_global(dest, shell_matrix.comm());
 
  // Call the user function.
  shell_matrix.get_diagonal(dest_global);
 
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

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

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

{
  PetscFunctionBegin;
 
  // Get the matrix context.
  void * ctx;
  LibmeshPetscCallQ(MatShellGetContext(mat,&ctx));
 
  // Get user shell matrix object.
  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
 
  // Make \p NumericVector instances around the vectors.
  PetscVector<T> arg_global(arg,   shell_matrix.comm());
  PetscVector<T> dest_global(dest, shell_matrix.comm());
 
  // Call the user function.
  shell_matrix.vector_mult(dest_global,arg_global);
 
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

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

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

{
  LOG_SCOPE("solve_generalized()", "SlepcEigenSolver");
 
  // Set operators.
  LibmeshPetscCall(EPSSetOperators (_eps, mat_A, mat_B));
 
  return this->_solve_helper(precond, nev, ncv, tol, m_its);
}

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

{
  // converged eigen pairs and number of iterations
  PetscInt nconv=0;
  PetscInt its=0;
  ST st=nullptr;
 
  //set the problem type and the position of the spectrum
  set_slepc_problem_type();
  set_slepc_position_of_spectrum();
 
  // Set eigenvalues to be computed.
#if SLEPC_VERSION_LESS_THAN(3,0,0)
  LibmeshPetscCall(EPSSetDimensions (_eps, nev, ncv));
#else
  LibmeshPetscCall(EPSSetDimensions (_eps, nev, ncv, PETSC_DECIDE));
#endif
  // Set the tolerance and maximum iterations.
  LibmeshPetscCall(EPSSetTolerances (_eps, tol, m_its));
 
  // Set runtime options, e.g.,
  //      -eps_type <type>, -eps_nev <nev>, -eps_ncv <ncv>
  // Similar to PETSc, these options will override those specified
  // above as long as EPSSetFromOptions() is called _after_ any
  // other customization routines.
  LibmeshPetscCall(EPSSetFromOptions (_eps));
 
  // Set a preconditioning matrix to ST
  if (precond) {
    LibmeshPetscCall(EPSGetST(_eps,&st));
#if SLEPC_VERSION_LESS_THAN(3,15,0)
    LibmeshPetscCall(STPrecondSetMatForPC(st, precond));
#else
    LibmeshPetscCall(STSetPreconditionerMat(st, precond));
#endif
  }
 
  // If the SolverConfiguration object is provided, use it to override
  // solver options.
  if (this->_solver_configuration)
    {
      this->_solver_configuration->configure_solver();
    }
 
  // If an initial space is provided, let us attach it to EPS
  if (_initial_space) {
    // Get a handle for the underlying Vec.
    Vec initial_vector = _initial_space->vec();
 
    LibmeshPetscCall(EPSSetInitialSpace(_eps, 1, &initial_vector));
  }
 
  // Solve the eigenproblem.
  LibmeshPetscCall(EPSSolve (_eps));
 
  // Get the number of iterations.
  LibmeshPetscCall(EPSGetIterationNumber (_eps, &its));
 
  // Get number of converged eigenpairs.
  LibmeshPetscCall(EPSGetConverged(_eps,&nconv));
 
  // return the number of converged eigenpairs
  // and the number of iterations
  return std::make_pair(nconv, its);
}

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

{
  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
 
  // Set operators.
  LibmeshPetscCall(EPSSetOperators (_eps, mat, LIBMESH_PETSC_NULLPTR));
 
  return this->_solve_helper(precond, nev, ncv, tol, m_its);
}

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.

{
  this->init();
 
  // Make sure the input vector is actually a PetscVector
  PetscVector<T> * deflation_vector_petsc_vec =
    dynamic_cast<PetscVector<T> *>(&deflation_vector_in);
 
  libmesh_error_msg_if(!deflation_vector_petsc_vec, "Error attaching deflation space: input vector must be a PetscVector.");
 
  // Get a handle for the underlying Vec.
  Vec deflation_vector = deflation_vector_petsc_vec->vec();
 
#if SLEPC_VERSION_LESS_THAN(3,1,0)
  LibmeshPetscCall(EPSAttachDeflationSpace(_eps, 1, &deflation_vector, PETSC_FALSE));
#else
  LibmeshPetscCall(EPSSetDeflationSpace(_eps, 1, &deflation_vector));
#endif
}

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

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.

{
  // Build the appropriate solver
  switch (solver_package)
    {
 
#ifdef LIBMESH_HAVE_SLEPC
    case SLEPC_SOLVERS:
      return std::make_unique<SlepcEigenSolver<T>>(comm);
#endif
 
    default:
      libmesh_error_msg("ERROR:  Unrecognized eigen solver package: " << solver_package);
    }
 
  return std::unique_ptr<EigenSolver<T>>();
}

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.

{
  if (this->initialized())
    {
      this->_is_initialized = false;
 
      PetscErrorCode ierr = LibMeshEPSDestroy(&_eps);
      if (ierr)
        libmesh_warning("Warning: EPSDestroy returned a non-zero error code which we ignored.");
 
      // SLEPc default eigenproblem solver
      this->_eigen_solver_type = KRYLOVSCHUR;
    }
}

References libMesh::initialized().

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

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.

  { return _communicator; }

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::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::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::System::add_matrix(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::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::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::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshBase::complete_preparation(), 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::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), PetscSolverConfiguration::configure_solver(), 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::MeshBase::detect_interior_parents(), 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::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), 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::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(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::MeshTetInterface::improve_hull_integrity(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::LocationMap< T >::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), ElasticitySystem::init_data(), 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::Modification::interpolate_surface(), 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_snes_mffd_interface(), libMesh::libmesh_petsc_snes_postcheck(), 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::MeshCommunication::make_elems_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::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::PetscVector< T >::operator=(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::ReplicatedMesh::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(), LaplaceSystem::postprocess(), PoissonSystem::postprocess(), 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(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), FEMParameters::read(), libMesh::EquationSystems::read(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::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::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::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(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::BoundaryInfo::remove_edge_id(), libMesh::BoundaryInfo::remove_node_id(), libMesh::BoundaryInfo::remove_shellface_id(), libMesh::BoundaryInfo::remove_side_id(), 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::NoxNonlinearSolver< Number >::solve(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshBase::sync_subdomain_name_map(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), CheckpointIOTest::testC0PolygonCheckpoint(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), SystemsTest::testProjectScalarCoarsening(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), BoundaryMeshSubdomainTest::testSingleSubdomain(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::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::RBConstruction::write_riesz_representors_to_files(), libMesh::TransientRBConstruction::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().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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.

{ return _eigen_problem_type;}

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

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.

{ return _eigen_solver_type; }

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

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

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.

{ this->init(); return _eps; }

References libMesh::SlepcEigenSolver< T >::_eps, and libMesh::SlepcEigenSolver< T >::init().

Referenced by SlepcSolverConfiguration::configure_solver().

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.

  {
    libmesh_experimental();
    return _close_matrix_before_solve;
  }

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

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.

{
  PetscReal re, im;
 
  // Make sure the NumericVector passed in is really a PetscVector
  PetscVector<T> * solution = dynamic_cast<PetscVector<T> *>(&solution_in);
 
  libmesh_error_msg_if(!solution, "Error getting eigenvector: input vector must be a PetscVector.");
 
  // real and imaginary part of the ith eigenvalue.
  PetscScalar kr, ki;
 
  solution->close();
 
  LibmeshPetscCall(EPSGetEigenpair(_eps, i, &kr, &ki, solution->vec(),
                                   LIBMESH_PETSC_NULLPTR));
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
  re = PetscRealPart(kr);
  im = PetscImaginaryPart(kr);
#else
  re = kr;
  im = ki;
#endif
 
  return std::make_pair(re, im);
}

References libMesh::PetscVector< T >::close(), and libMesh::PetscVector< T >::vec().

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.

{
  PetscReal re, im;
 
  // real and imaginary part of the ith eigenvalue.
  PetscScalar kr, ki;
 
  LibmeshPetscCall(EPSGetEigenvalue(_eps, i, &kr, &ki));
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
  re = PetscRealPart(kr);
  im = PetscImaginaryPart(kr);
#else
  re = kr;
  im = ki;
#endif
 
  return std::make_pair(re, im);
}

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.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

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.

{
  PetscReal error;
 
#if SLEPC_VERSION_LESS_THAN(3,6,0)
  LibmeshPetscCall(EPSComputeRelativeError(_eps, i, &error));
#else
  LibmeshPetscCall(EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error));
#endif
 
  return error;
}

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.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

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.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

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.

{
  // Initialize the data structures if not done so already.
  if (!this->initialized())
    {
      this->_is_initialized = true;
 
      // Create the eigenproblem solver context
      LibmeshPetscCall(EPSCreate (this->comm().get(), &_eps));
 
      // Set user-specified  solver
      set_slepc_solver_type();
    }
}

References libMesh::initialized().

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

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.

{ return _is_initialized; }

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

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.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

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

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.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and libMesh::Parallel::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::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::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), 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::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::MeshBase::partition(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::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::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::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().

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.

  { return _position_of_spectrum;}

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

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.

{
  // converged eigen pairs and number of iterations
  PetscInt nconv=0;
 
  // The relative error.
  PetscReal error, re, im;
 
  // Pointer to vectors of the real parts, imaginary parts.
  PetscScalar kr, ki;
 
  // Get number of converged eigenpairs.
  LibmeshPetscCall(EPSGetConverged(_eps,&nconv));
 
  // Display eigenvalues and relative errors.
  LibmeshPetscCall(PetscPrintf(this->comm().get(),
                               "           k           ||Ax-kx||/|kx|\n"
                               "   ----------------- -----------------\n" ));
 
  for (PetscInt i=0; i<nconv; i++ )
    {
      LibmeshPetscCall(EPSGetEigenpair(_eps, i, &kr, &ki, LIBMESH_PETSC_NULLPTR,
                                       LIBMESH_PETSC_NULLPTR));
 
#if SLEPC_VERSION_LESS_THAN(3,6,0)
      LibmeshPetscCall(EPSComputeRelativeError(_eps, i, &error));
#else
      LibmeshPetscCall(EPSComputeError(_eps, i, EPS_ERROR_RELATIVE, &error));
#endif
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      re = PetscRealPart(kr);
      im = PetscImaginaryPart(kr);
#else
      re = kr;
      im = ki;
#endif
 
      if (im != .0)
        LibmeshPetscCall(PetscPrintf(this->comm().get()," %9f%+9f i %12f\n", double(re), double(im), double(error)));
      else
        LibmeshPetscCall(PetscPrintf(this->comm().get(),"   %12f       %12f\n", double(re), double(error)));
    }
 
  LibmeshPetscCall(PetscPrintf(this->comm().get(),"\n" ));
}

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.

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

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

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

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.

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

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), 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::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), 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::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::MeshTools::Modification::interpolate_surface(), libMesh::SparsityPattern::Build::join(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::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(), main(), 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::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::XdrIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::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::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(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), BoundaryInfoTest::testBoundaryIDs(), 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(), BoundaryInfoTest::testInternalBoundary(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), BoundaryMeshSubdomainTest::testSingleSubdomain(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_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::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::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::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_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::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

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.

  {
    libmesh_experimental();
    _close_matrix_before_solve = val;
  }

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

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.

  {_eigen_problem_type = ept;}

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

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.

  { _eigen_solver_type = est; }

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

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.

{
#if SLEPC_VERSION_LESS_THAN(3,1,0)
  libmesh_error_msg("SLEPc 3.1 is required to call EigenSolver::set_initial_space()");
#else
  // Make sure the input vector (which is still owned by caller) is
  // actually a PetscVector
  _initial_space = cast_ptr<PetscVector<T> *>(&initial_space_in);
#endif
}

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.

  {_position_of_spectrum= pos;}

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

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.

{
  if (pos >= 0)
    _position_of_spectrum = TARGET_MAGNITUDE;
  else
    _position_of_spectrum = TARGET_REAL;
 
  _target_val = pos;
}

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

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.

{
  _position_of_spectrum = target;
  _target_val = pos;
}

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.

{
  switch (this->_position_of_spectrum)
    {
    case LARGEST_MAGNITUDE:
      {
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_LARGEST_MAGNITUDE));
        return;
      }
    case SMALLEST_MAGNITUDE:
      {
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_MAGNITUDE));
        return;
      }
    case LARGEST_REAL:
      {
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_LARGEST_REAL));
        return;
      }
    case SMALLEST_REAL:
      {
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_REAL));
        return;
      }
    case LARGEST_IMAGINARY:
      {
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_LARGEST_IMAGINARY));
        return;
      }
    case SMALLEST_IMAGINARY:
      {
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_IMAGINARY));
        return;
      }
 
      // The EPS_TARGET_XXX enums were added in SLEPc 3.1
#if !SLEPC_VERSION_LESS_THAN(3,1,0)
    case TARGET_MAGNITUDE:
      {
        LibmeshPetscCall(EPSSetTarget(_eps, PS(this->_target_val)));
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_TARGET_MAGNITUDE));
        return;
      }
    case TARGET_REAL:
      {
        LibmeshPetscCall(EPSSetTarget(_eps, PS(this->_target_val)));
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_TARGET_REAL));
        return;
      }
    case TARGET_IMAGINARY:
      {
        LibmeshPetscCall(EPSSetTarget(_eps, PS(this->_target_val)));
        LibmeshPetscCall(EPSSetWhichEigenpairs (_eps, EPS_TARGET_IMAGINARY));
        return;
      }
#endif
 
    default:
      libmesh_error_msg("ERROR:  Unsupported SLEPc position of spectrum: " << this->_position_of_spectrum);
    }
}

References libMesh::LARGEST_IMAGINARY, libMesh::LARGEST_MAGNITUDE, libMesh::LARGEST_REAL, libMesh::PS(), libMesh::SMALLEST_IMAGINARY, libMesh::SMALLEST_MAGNITUDE, libMesh::SMALLEST_REAL, libMesh::TARGET_IMAGINARY, libMesh::TARGET_MAGNITUDE, and libMesh::TARGET_REAL.

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.

{
  switch (this->_eigen_problem_type)
    {
    case NHEP:
      LibmeshPetscCall(EPSSetProblemType (_eps, EPS_NHEP)); return;
    case GNHEP:
      LibmeshPetscCall(EPSSetProblemType (_eps, EPS_GNHEP)); return;
    case HEP:
      LibmeshPetscCall(EPSSetProblemType (_eps, EPS_HEP)); return;
    case GHEP:
      LibmeshPetscCall(EPSSetProblemType (_eps, EPS_GHEP)); return;
#if !SLEPC_VERSION_LESS_THAN(3,3,0)
      // EPS_GHIEP added in 3.3.0
    case GHIEP:
      LibmeshPetscCall(EPSSetProblemType (_eps, EPS_GHIEP)); return;
#endif
 
    default:
      libMesh::err << "ERROR:  Unsupported SLEPc Eigen Problem: "
                   << this->_eigen_problem_type        << std::endl
                   << "Continuing with SLEPc defaults" << std::endl;
    }
}

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

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.

{
  switch (this->_eigen_solver_type)
    {
    case POWER:
      LibmeshPetscCall(EPSSetType (_eps, EPSPOWER)); return;
    case SUBSPACE:
      LibmeshPetscCall(EPSSetType (_eps, EPSSUBSPACE)); return;
    case LAPACK:
      LibmeshPetscCall(EPSSetType (_eps, EPSLAPACK)); return;
    case ARNOLDI:
      LibmeshPetscCall(EPSSetType (_eps, EPSARNOLDI)); return;
    case LANCZOS:
      LibmeshPetscCall(EPSSetType (_eps, EPSLANCZOS)); return;
    case KRYLOVSCHUR:
      LibmeshPetscCall(EPSSetType (_eps, EPSKRYLOVSCHUR)); return;
      // case ARPACK:
      // LibmeshPetscCall(EPSSetType (_eps, (char *) EPSARPACK)); return;
 
    default:
      libMesh::err << "ERROR:  Unsupported SLEPc Eigen Solver: "
                   << Utility::enum_to_string(this->_eigen_solver_type) << std::endl
                   << "Continuing with SLEPc defaults" << std::endl;
    }
}

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

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.

{
  _solver_configuration = &solver_configuration;
}

Referenced by main().

solve_generalized() [1/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.

{
  this->clear();
 
  this->init ();
 
  // Prepare the matrices.  Note that the const_casts are only
  // necessary because PETSc does not accept a const void *.  Inside
  // the member function _petsc_shell_matrix() below, the pointer is
  // casted back to a const ShellMatrix<T> *.
  Mat mat_A;
  LibmeshPetscCall(MatCreateShell(this->comm().get(),
                                  shell_matrix_A.m(), // Specify the number of local rows
                                  shell_matrix_A.n(), // Specify the number of local columns
                                  PETSC_DETERMINE,
                                  PETSC_DETERMINE,
                                  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
                                  &mat_A));
 
  Mat mat_B;
  LibmeshPetscCall(MatCreateShell(this->comm().get(),
                                  shell_matrix_B.m(), // Specify the number of local rows
                                  shell_matrix_B.n(), // Specify the number of local columns
                                  PETSC_DETERMINE,
                                  PETSC_DETERMINE,
                                  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
                                  &mat_B));
 
  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
 
  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
 
  return _solve_generalized_helper (mat_A, mat_B, nullptr, nev, ncv, tol, m_its);
}

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

solve_generalized() [2/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.

{
  this->clear();
 
  this->init ();
 
  // Make sure the ShellMatrix passed in is really a PetscShellMatrix
  auto * const precond = cast_ptr<PetscShellMatrix<T> *>(&precond_in);
 
  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_generalized() must be of type PetscShellMatrix.");
 
  auto * const matrix_A = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_A);
 
  libmesh_error_msg_if(!matrix_A, "Error: input operator A to solve_generalized() must be of type PetscShellMatrix.");
 
  auto * const matrix_B = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_B);
 
  libmesh_error_msg_if(!matrix_B, "Error: input operator B to solve_generalized() must be of type PetscShellMatrix.");
 
  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), precond->mat(), nev, ncv, tol, m_its);
}

solve_generalized() [3/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.

{
  this->clear();
 
  this->init ();
 
  // Make sure the SparseMatrix passed in is really a PetscMatrix
  auto * const precond = cast_ptr<PetscMatrixBase<T> *>(&precond_in);
 
  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_generalized() must be of type PetscMatrixBase.");
 
  auto * const matrix_A = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_A);
 
  libmesh_error_msg_if(!matrix_A, "Error: input operator A to solve_generalized() must be of type PetscShellMatrix.");
 
  auto * const matrix_B = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix_B);
 
  libmesh_error_msg_if(!matrix_B, "Error: input operator B to solve_generalized() must be of type PetscShellMatrix.");
 
  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), precond->mat(), nev, ncv, tol, m_its);
}

solve_generalized() [4/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.

{
  this->clear();
 
  this->init ();
 
  // Prepare the matrix. Note that the const_cast is only necessary
  // because PETSc does not accept a const void *.  Inside the member
  // function _petsc_shell_matrix() below, the pointer is casted back
  // to a const ShellMatrix<T> *.
  Mat mat_A;
  LibmeshPetscCall(MatCreateShell(this->comm().get(),
                                  shell_matrix_A.m(), // Specify the number of local rows
                                  shell_matrix_A.n(), // Specify the number of local columns
                                  PETSC_DETERMINE,
                                  PETSC_DETERMINE,
                                  const_cast<void *>(static_cast<const void *>(&shell_matrix_A)),
                                  &mat_A));
 
  auto * const matrix_B = cast_ptr<PetscMatrixBase<T> *>(&matrix_B_in);
 
  libmesh_error_msg_if(!matrix_B, "Error: inputs to solve_generalized() must be of type PetscMatrixBase.");
 
  // Close the matrix and vectors in case this wasn't already done.
  if (this->_close_matrix_before_solve)
    matrix_B->close ();
 
  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
  LibmeshPetscCall(MatShellSetOperation(mat_A,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
 
  return _solve_generalized_helper (mat_A, matrix_B->mat(), nullptr, nev, ncv, tol, m_its);
}

solve_generalized() [5/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.

{
  this->clear();
 
  this->init ();
 
  auto * const matrix_A = cast_ptr<PetscMatrixBase<T> *>(&matrix_A_in);
 
  libmesh_error_msg_if(!matrix_A, "Error: inputs to solve_generalized() must be of type PetscMatrixBase.");
 
  // Close the matrix and vectors in case this wasn't already done.
  if (this->_close_matrix_before_solve)
    matrix_A->close ();
 
  // Prepare the matrix.  Note that the const_cast is only necessary
  // because PETSc does not accept a const void *.  Inside the member
  // function _petsc_shell_matrix() below, the pointer is casted back
  // to a const ShellMatrix<T> *.
  Mat mat_B;
  LibmeshPetscCall(MatCreateShell(this->comm().get(),
                                  shell_matrix_B.m(), // Specify the number of local rows
                                  shell_matrix_B.n(), // Specify the number of local columns
                                  PETSC_DETERMINE,
                                  PETSC_DETERMINE,
                                  const_cast<void *>(static_cast<const void *>(&shell_matrix_B)),
                                  &mat_B));
 
  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
  LibmeshPetscCall(MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
 
  return _solve_generalized_helper (matrix_A->mat(), mat_B, nullptr, nev, ncv, tol, m_its);
}

solve_generalized() [6/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.

{
  this->clear ();
 
  this->init ();
 
  // Make sure the data passed in are really of Petsc types
  auto * const matrix_A = cast_ptr<PetscMatrixBase<T> *>(&matrix_A_in);
  auto * const matrix_B = cast_ptr<PetscMatrixBase<T> *>(&matrix_B_in);
 
  libmesh_error_msg_if(!matrix_A || !matrix_B,
                       "Error: inputs to solve_generalized() must be of type PetscMatrixBase.");
 
  // Close the matrix and vectors in case this wasn't already done.
  if (this->_close_matrix_before_solve)
    {
      matrix_A->close ();
      matrix_B->close ();
    }
 
  return _solve_generalized_helper (matrix_A->mat(), matrix_B->mat(), nullptr, nev, ncv, tol, m_its);
}

solve_standard() [1/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.

{
  this->clear ();
 
  this->init ();
 
  // Prepare the matrix.  Note that the const_cast is only necessary
  // because PETSc does not accept a const void *.  Inside the member
  // function _petsc_shell_matrix() below, the pointer is casted back
  // to a const ShellMatrix<T> *.
  Mat mat;
  LibmeshPetscCall(MatCreateShell(this->comm().get(),
                                  shell_matrix.m(), // Specify the number of local rows
                                  shell_matrix.n(), // Specify the number of local columns
                                  PETSC_DETERMINE,
                                  PETSC_DETERMINE,
                                  const_cast<void *>(static_cast<const void *>(&shell_matrix)),
                                  &mat));
 
  LibmeshPetscCall(MatShellSetOperation(mat,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
  LibmeshPetscCall(MatShellSetOperation(mat,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
 
  return _solve_standard_helper(mat, nullptr, nev, ncv, tol, m_its);
}

solve_standard() [2/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.

{
  this->clear ();
 
  this->init ();
 
  // Make sure the SparseMatrix passed in is really a PetscMatrix
  auto * const precond = cast_ptr<PetscShellMatrix<T> *>(&precond_in);
 
  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_standard() must be a PetscShellMatrix.");
 
  auto * const matrix = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix);
 
  libmesh_error_msg_if(!matrix, "Error: input operator matrix to solve_standard() must be a PetscShellMatrix.");
 
  return _solve_standard_helper(matrix->mat(), precond->mat(), nev, ncv, tol, m_its);
}

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.

{
  this->clear ();
 
  this->init ();
 
  // Make sure the SparseMatrix passed in is really a PetscMatrix
  auto * const precond = cast_ptr<PetscMatrixBase<T> *>(&precond_in);
 
  libmesh_error_msg_if(!precond, "Error: input preconditioning matrix to solve_standard() must be a PetscMatrixBase.");
 
  auto * const matrix = cast_ptr<PetscShellMatrix<T> *> (&shell_matrix);
 
  libmesh_error_msg_if(!matrix, "Error: input operator matrix to solve_standard() must be a PetscShellMatrix.");
 
  return _solve_standard_helper(matrix->mat(), precond->mat(), nev, ncv, tol, m_its);
}

solve_standard() [4/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.

{
  LOG_SCOPE("solve_standard()", "SlepcEigenSolver");
 
  this->clear ();
 
  this->init ();
 
  // Make sure the SparseMatrix passed in is really a PetscMatrix
  auto * const matrix_A = cast_ptr<PetscMatrixBase<T> *>(&matrix_A_in);
 
  libmesh_error_msg_if(!matrix_A, "Error: input matrix to solve_standard() must be a PetscMatrixBase.");
 
  // Close the matrix and vectors in case this wasn't already done.
  if (this->_close_matrix_before_solve)
    matrix_A->close ();
 
  return _solve_standard_helper(matrix_A->mat(), nullptr, nev, ncv, tol, m_its);
}

Member Data Documentation

_close_matrix_before_solve

template<typename T >

bool libMesh::EigenSolver< T >::_close_matrix_before_solve

protectedinherited

Definition at line 352 of file eigen_solver.h.

Referenced by libMesh::EigenSolver< T >::get_close_matrix_before_solve(), and libMesh::EigenSolver< T >::set_close_matrix_before_solve().

_communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

_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< T >::eigen_problem_type(), libMesh::EigenSolver< T >::set_eigenproblem_type(), and libMesh::SlepcEigenSolver< T >::SlepcEigenSolver().

_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< T >::eigen_solver_type(), libMesh::EigenSolver< T >::set_eigensolver_type(), and libMesh::SlepcEigenSolver< T >::SlepcEigenSolver().

_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< T >::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< T >::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(), libMesh::ReferenceCounter::ReferenceCounter(), 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< T >::position_of_spectrum(), and libMesh::EigenSolver< T >::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:

• include/solvers/slepc_eigen_solver.h
• src/solvers/slepc_eigen_solver.C