#include <SlepcEigenSolverConfiguration.h>

Inheritance diagram for SlepcEigenSolverConfiguration:

Public Member Functions
	SlepcEigenSolverConfiguration (EigenProblem &eigen_problem, libMesh::SlepcEigenSolver< libMesh::Number > &slepc_eigen_solver, const NonlinearEigenSystem &nl_eigen_sys)
	Constructur: get a reference to the `SlepcEigenSolver` variable to be able to manipulate it.

virtual void	configure_solver () override

virtual void	set_options_during_init ()

virtual void	respond_to_solve_failure (unsigned int)

Static Public Member Functions
static std::string	get_info ()

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

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

Public Attributes
std::map< std::string, Real >	real_valued_data

std::map< std::string, int >	int_valued_data

std::map< std::string, std::string >	string_data

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts

Protected Member Functions
void	increment_constructor_count (const std::string &name) noexcept

void	increment_destructor_count (const std::string &name) noexcept

Static Protected Attributes
static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter

Private Attributes
EigenProblem &	_eigen_problem

libMesh::SlepcEigenSolver< libMesh::Number > &	_slepc_solver
	The slepc eigen solver object that we are configuring.

const NonlinearEigenSystem &	_nl_eigen_sys
	The system that owns the SLEPc solver.

Detailed Description

Definition at line 26 of file SlepcEigenSolverConfiguration.h.

Constructor & Destructor Documentation

◆ SlepcEigenSolverConfiguration()

SlepcEigenSolverConfiguration::SlepcEigenSolverConfiguration	(	EigenProblem &	eigen_problem,
		libMesh::SlepcEigenSolver< libMesh::Number > &	slepc_eigen_solver,
		const NonlinearEigenSystem &	nl_eigen_sys
	)

Constructur: get a reference to the SlepcEigenSolver variable to be able to manipulate it.

Constructor: get a reference to the SlepcEigenSolver variable to be able to manipulate it.

Definition at line 25 of file SlepcEigenSolverConfiguration.C.

  : SolverConfiguration(),
    _eigen_problem(eigen_problem),
    _slepc_solver(slepc_eigen_solver),
    _nl_eigen_sys(nl_eigen_sys)
{
}

Member Function Documentation

◆ configure_solver()

void SlepcEigenSolverConfiguration::configure_solver ( )

overridevirtual

Implements libMesh::SolverConfiguration.

Definition at line 37 of file SlepcEigenSolverConfiguration.C.

{
  if (_eigen_problem.isNonlinearEigenvalueSolver(_nl_eigen_sys.number()))
  {
    // Set custom monitors for SNES and KSP
    _eigen_problem.initPetscOutputAndSomeSolverSettings();
    // Let us remove extra "eps_power" from SNES since users do not like it
    LibmeshPetscCallA(_eigen_problem.comm().get(),
                      Moose::SlepcSupport::mooseSlepcEPSSNESSetUpOptionPrefix(_slepc_solver.eps()));
    // Let us hook up a customize PC if users ask. Users still can use PETSc options to override
    // this setting
    if (_eigen_problem.solverParams(_nl_eigen_sys.number())._customized_pc_for_eigen)
      LibmeshPetscCallA(_eigen_problem.comm().get(),
                        Moose::SlepcSupport::mooseSlepcEPSSNESSetCustomizePC(_slepc_solver.eps()));
    // Let set a default PC side. I would like to have the setting be consistent with
    // what we do in regular nonlinear executioner. Petsc options are able to override
    // this setting
    LibmeshPetscCallA(
        _eigen_problem.comm().get(),
        Moose::SlepcSupport::mooseSlepcEPSSNESKSPSetPCSide(_eigen_problem, _slepc_solver.eps()));
    // A customized stopping test for nonlinear free power iterations.
    // Nonlinear power iterations need to be marked as converged in EPS to
    // retrieve solution from SLEPc EPS.
    LibmeshPetscCallA(_eigen_problem.comm().get(),
                      EPSSetStoppingTestFunction(_slepc_solver.eps(),
                                                 Moose::SlepcSupport::mooseSlepcStoppingTest,
                                                 &_eigen_problem,
                                                 NULL));
 
    // Remove all SLEPc monitors.
    LibmeshPetscCallA(_eigen_problem.comm().get(), EPSMonitorCancel(_slepc_solver.eps()));
    // A customized EPS monitor in moose. We need to print only eigenvalue
    LibmeshPetscCallA(
        _eigen_problem.comm().get(),
        EPSMonitorSet(
            _slepc_solver.eps(), Moose::SlepcSupport::mooseSlepcEPSMonitor, &_eigen_problem, NULL));
  }
 
  // The default BV type (BVMAT) stores the basis in a single dense matrix and does not support
  // Kokkos vectors, so store the basis as individual vectors instead unless the user chose a type
  const auto comm = _eigen_problem.comm().get();
  EPS eps = _slepc_solver.eps();
  const char * prefix = nullptr;
  LibmeshPetscCallA(comm, EPSGetOptionsPrefix(eps, &prefix));
  PetscBool bv_type_set = PETSC_FALSE;
  LibmeshPetscCallA(comm, PetscOptionsHasName(nullptr, prefix, "-bv_type", &bv_type_set));
  if (!bv_type_set)
  {
    const auto & solution =
        cast_ref<const libMesh::PetscVector<libMesh::Number> &>(_nl_eigen_sys.solution());
    PetscBool is_kokkos = PETSC_FALSE;
    LibmeshPetscCallA(comm,
                      PetscObjectTypeCompareAny(
                          (PetscObject)solution.vec(), &is_kokkos, VECSEQKOKKOS, VECMPIKOKKOS, ""));
    if (is_kokkos)
    {
      BV bv;
      LibmeshPetscCallA(comm, EPSGetBV(eps, &bv));
      LibmeshPetscCallA(comm, BVSetType(bv, BVVECS));
    }
  }
}