SlepcSupport.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MultiMooseEnum.h"
#include "libmesh/libmesh_config.h"
 
#ifdef LIBMESH_HAVE_SLEPC
 
#include "libmesh/petsc_macro.h"
 
#include "Moose.h"
#include "SystemBase.h"
 
/* We need this in order to implement moose PC */
#include <petsc/private/pcimpl.h>
#include <slepceps.h>
#include <slepc/private/epsimpl.h>
/* In order to use libMesh preconditioner */
#include "libmesh/linear_solver.h"
#include "libmesh/preconditioner.h"
 
class EigenProblem;
class InputParameters;
class SolverParams;
class MultiMooseEnum;
 
namespace Moose
{
namespace SlepcSupport
{
InputParameters getSlepcValidParams(InputParameters & params);
 
InputParameters getSlepcEigenProblemValidParams();
 
void storeSolveType(FEProblemBase & fe_problem, const InputParameters & params);
 
void setEigenProblemSolverParams(EigenProblem & eigen_problem, const InputParameters & params);
 
void slepcSetOptions(EigenProblem & eigen_problem,
                     SolverParams & solver_params,
                     const InputParameters & params);
 
void setSlepcEigenSolverTolerances(EigenProblem & eigen_problem,
                                   const SolverParams & solver_params,
                                   const InputParameters & params);
 
void setFreeNonlinearPowerIterations(unsigned int free_power_iterations);
 
/*
 * Set SLEPc/PETSc options to turn the eigen-solver back to a regular Newton solver
 */
void clearFreeNonlinearPowerIterations(const InputParameters & params);
 
void moosePetscSNESFormMatrixTag(
    SNES snes, Vec x, Mat eigen_mat, SparseMatrix<Number> & all_dofs_mat, void * ctx, TagID tag);
 
void moosePetscSNESFormMatricesTags(SNES snes,
                                    Vec x,
                                    std::vector<Mat> & eigen_mats,
                                    std::vector<SparseMatrix<Number> *> & all_dofs_mats,
                                    void * ctx,
                                    const std::set<TagID> & tags);
 
PetscErrorCode mooseSlepcEigenFormJacobianA(SNES snes, Vec x, Mat jac, Mat pc, void * ctx);
 
PetscErrorCode mooseSlepcEigenFormJacobianB(SNES snes, Vec x, Mat jac, Mat pc, void * ctx);
 
PetscErrorCode mooseSlepcEigenFormFunctionA(SNES snes, Vec x, Vec r, void * ctx);
 
PetscErrorCode mooseSlepcEigenFormFunctionB(SNES snes, Vec x, Vec r, void * ctx);
 
PetscErrorCode mooseSlepcEigenFormFunctionAB(SNES snes, Vec x, Vec Ax, Vec Bx, void * ctx);
 
PetscErrorCode mooseSlepcStoppingTest(EPS eps,
                                      PetscInt its,
                                      PetscInt max_it,
                                      PetscInt nconv,
                                      PetscInt nev,
                                      EPSConvergedReason * reason,
                                      void * ctx);
 
PetscErrorCode mooseSlepcEPSGetSNES(EPS eps, SNES * snes);
 
PetscErrorCode mooseSlepcEPSMonitor(EPS eps,
                                    PetscInt its,
                                    PetscInt nconv,
                                    PetscScalar * eigr,
                                    PetscScalar * eigi,
                                    PetscReal * errest,
                                    PetscInt nest,
                                    void * mctx);
 
PetscErrorCode mooseSlepcEPSSNESSetUpOptionPrefix(EPS eps);
 
PetscErrorCode mooseSlepcEPSSNESSetCustomizePC(EPS eps);
 
PetscErrorCode mooseSlepcEPSSNESKSPSetPCSide(FEProblemBase & problem, EPS eps);
 
void attachCallbacksToMat(EigenProblem & eigen_problem, Mat mat, bool eigen);
 
PetscErrorCode mooseMatMult_Eigen(Mat mat, Vec x, Vec y);
 
PetscErrorCode mooseMatMult_NonEigen(Mat mat, Vec x, Vec y);
 
void setOperationsForShellMat(EigenProblem & eigen_problem, Mat mat, bool eigen);
 
PETSC_EXTERN PetscErrorCode PCCreate_MoosePC(PC pc);
 
PETSC_EXTERN PetscErrorCode registerPCToPETSc();
 
PetscErrorCode PCDestroy_MoosePC(PC pc);
 
PetscErrorCode PCView_MoosePC(PC pc, PetscViewer viewer);
 
PetscErrorCode PCApply_MoosePC(PC pc, Vec x, Vec y);
 
PetscErrorCode PCSetUp_MoosePC(PC pc);
 
PetscErrorCode mooseSlepcEigenFormFunctionMFFD(void * ctx, Vec x, Vec r);
 
} // namespace SlepcSupport
} // namespace moose
 
#endif // LIBMESH_HAVE_SLEPC