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