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