NonlinearEigenSystem.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 "libmesh/libmesh_config.h"
 
#include "NonlinearSystemBase.h"
#include "SlepcEigenSolverConfiguration.h"
 
#include "libmesh/condensed_eigen_system.h"
 
// forward declarations
class EigenProblem;
class KernelBase;
class ResidualObject;
 
#ifdef LIBMESH_HAVE_SLEPC
 
#include <slepceps.h>
 
namespace Moose
{
void assemble_matrix(EquationSystems & es, const std::string & system_name);
}
 
class NonlinearEigenSystem : public NonlinearSystemBase
{
public:
  NonlinearEigenSystem(EigenProblem & problem, const std::string & name);
 
  virtual void solve() override;
 
  virtual void stopSolve(const ExecFlagType & exec_flag,
                         const std::set<TagID> & vector_tags_to_close) override;
 
  virtual unsigned int getCurrentNonlinearIterationNumber() override;
 
  virtual void setupFiniteDifferencedPreconditioner() override;
 
  virtual bool converged() override;
 
  virtual NumericVector<Number> & RHS() override;
 
  /*
   *  A residual vector at MOOSE side for AX
   */
  NumericVector<Number> & residualVectorAX();
 
  /*
   * A residual vector at MOOSE side for BX
   */
  NumericVector<Number> & residualVectorBX();
 
  void attachSLEPcCallbacks();
 
  unsigned int getNumConvergedEigenvalues() const { return _eigen_sys.get_n_converged(); };
 
  virtual unsigned int nNonlinearIterations() const override;
  virtual unsigned int nLinearIterations() const override;
  virtual Real finalNonlinearResidual() const override;
 
  virtual libMesh::NonlinearSolver<Number> * nonlinearSolver() override;
 
  virtual SNES getSNES() override;
 
  virtual EPS getEPS();
 
  libMesh::CondensedEigenSystem & sys() { return _eigen_sys; }
 
  void checkIntegrity();
 
  std::pair<Real, Real> getConvergedEigenvalue(dof_id_type n) const;
 
  std::pair<Real, Real> getConvergedEigenpair(dof_id_type n) const;
 
  const std::vector<std::pair<Real, Real>> & getAllConvergedEigenvalues() const
  {
    return _eigen_values;
  }
 
  TagID eigenVectorTag() const { return _Bx_tag; }
 
  TagID nonEigenVectorTag() const { return _Ax_tag; }
 
  TagID eigenMatrixTag() const { return _B_tag; }
 
  TagID nonEigenMatrixTag() const { return _A_tag; }
 
  std::set<TagID> defaultVectorTags() const override;
  std::set<TagID> defaultMatrixTags() const override;
 
  void precondMatrixIncludesEigenKernels(bool precond_matrix_includes_eigen)
  {
    _precond_matrix_includes_eigen = precond_matrix_includes_eigen;
  }
 
  bool precondMatrixIncludesEigenKernels() const { return _precond_matrix_includes_eigen; }
 
  TagID precondMatrixTag() const { return _precond_tag; }
 
  virtual void attachPreconditioner(libMesh::Preconditioner<Number> * preconditioner) override;
 
  libMesh::Preconditioner<Number> * preconditioner() const { return _preconditioner; }
 
  virtual void turnOffJacobian() override;
 
  void residualAndJacobianTogether() override;
 
  void initializeCondensedMatrices();
 
  virtual void postInit() override;
  virtual void reinit() override;
 
protected:
  virtual void postAddResidualObject(ResidualObject & object) override;
 
  void computeScalingJacobian() override;
  void computeScalingResidual() override;
 
  libMesh::CondensedEigenSystem & _eigen_sys;
  EigenProblem & _eigen_problem;
  std::unique_ptr<SlepcEigenSolverConfiguration> _solver_configuration;
  std::vector<std::pair<Real, Real>> _eigen_values;
  unsigned int _n_eigen_pairs_required;
  NumericVector<Number> & _work_rhs_vector_AX;
  NumericVector<Number> & _work_rhs_vector_BX;
  TagID _Ax_tag;
  TagID _Bx_tag;
  TagID _A_tag;
  TagID _B_tag;
  TagID _precond_tag;
  bool _precond_matrix_includes_eigen;
  // Libmesh preconditioner
  libMesh::Preconditioner<Number> * _preconditioner;
 
  dof_id_type _num_constrained_dofs;
};
 
#else
 
class NonlinearEigenSystem : public libMesh::ParallelObject
{
public:
  NonlinearEigenSystem(EigenProblem & problem, const std::string & name);
 
  bool converged() { return false; }
 
  void checkIntegrity() {}
};
 
#endif