NonlinearEigenSystem.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "libmesh/transient_system.h"
#include "libmesh/eigen_system.h"

// forward declarations
class EigenProblem;
class KernelBase;

#if LIBMESH_HAVE_SLEPC

class NonlinearEigenSystem : public NonlinearSystemBase
{
public:
  NonlinearEigenSystem(EigenProblem & problem, const std::string & name);

  virtual void solve() override;

  virtual void stopSolve() override;

  virtual unsigned int getCurrentNonlinearIterationNumber() override;

  virtual void setupFiniteDifferencedPreconditioner() override;

  virtual bool converged() override;

  virtual NumericVector<Number> & RHS() override;

  template <typename T>
  void addEigenTagToMooseObjects(MooseObjectTagWarehouse<T> & warehouse);

  virtual void initialSetup() override;

  virtual unsigned int getNumConvergedEigenvalues() const
  {
    return _transient_sys.get_n_converged();
  };

  virtual NonlinearSolver<Number> * nonlinearSolver() override;

  NumericVector<Number> & solutionOld() override { return *_transient_sys.old_local_solution; }

  NumericVector<Number> & solutionOlder() override { return *_transient_sys.older_local_solution; }

  const NumericVector<Number> & solutionOld() const override
  {
    return *_transient_sys.old_local_solution;
  }

  const NumericVector<Number> & solutionOlder() const override
  {
    return *_transient_sys.older_local_solution;
  }

  virtual TransientEigenSystem & sys() { return _transient_sys; }

  void checkIntegrity();

  virtual const std::pair<Real, Real> getNthConvergedEigenvalue(dof_id_type n);

  virtual const std::vector<std::pair<Real, Real>> & getAllConvergedEigenvalues()
  {
    return _eigen_values;
  }

  TagID eigenVectorTag() { return _Bx_tag; }

  TagID nonEigenVectorTag() { return _Ax_tag; }

  TagID eigenMatrixTag() { return _B_tag; }

  TagID nonEigenMatrixTag() { return _A_tag; }

protected:
  TransientEigenSystem & _transient_sys;
  EigenProblem & _eigen_problem;
  std::vector<std::pair<Real, Real>> _eigen_values;
  unsigned int _n_eigen_pairs_required;
  TagID _Ax_tag;
  TagID _Bx_tag;
  TagID _A_tag;
  TagID _B_tag;
};

#else

class NonlinearEigenSystem : public libMesh::ParallelObject
{
public:
  NonlinearEigenSystem(EigenProblem & problem, const std::string & name);

  bool converged() { return false; }

  void checkIntegrity() {}
};

#endif