EigenProblem.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
 
// MOOSE Includes
#include "FEProblemBase.h"
#include "Eigenvalue.h"
 
class NonlinearEigenSystem;
 
class EigenProblem : public FEProblemBase
{
public:
  static InputParameters validParams();
 
  EigenProblem(const InputParameters & parameters);
 
  virtual std::string solverTypeString(unsigned int solver_sys_num = 0) override;
 
#ifdef LIBMESH_HAVE_SLEPC
  virtual void solve(const unsigned int nl_sys_num) override;
 
  virtual void init() override;
 
  virtual bool solverSystemConverged(const unsigned int solver_sys_num) override;
 
  unsigned int getNEigenPairsRequired() const { return _n_eigen_pairs_required; }
  void setNEigenPairsRequired(unsigned int n_eigen_pairs)
  {
    _n_eigen_pairs_required = n_eigen_pairs;
  }
  bool isGeneralizedEigenvalueProblem() const { return _generalized_eigenvalue_problem; }
  bool isNonlinearEigenvalueSolver(unsigned int eigen_sys_num) const;
  // silences warning in debug mode about the other computeJacobian signature being hidden
  using FEProblemBase::computeJacobian;
 
  NonlinearEigenSystem & getNonlinearEigenSystem(const unsigned int nl_sys_num);
  NonlinearEigenSystem & getCurrentNonlinearEigenSystem();
 
  virtual void checkProblemIntegrity() override;
 
  bool negativeSignEigenKernel() const { return _negative_sign_eigen_kernel; }
 
  void setNormalization(const PostprocessorName & pp,
                        const Real value = std::numeric_limits<Real>::max());
 
  void setInitialEigenvalue(const Real initial_eigenvalue)
  {
    _initial_eigenvalue = initial_eigenvalue;
  }
 
  bool doFreePowerIteration() const { return _do_free_power_iteration; }
 
  void doFreePowerIteration(bool do_power) { _do_free_power_iteration = do_power; }
 
  void preScaleEigenVector(const std::pair<Real, Real> & eig);
 
  void postScaleEigenVector();
 
  void scaleEigenvector(const Real scaling_factor);
 
  void setEigenproblemType(Moose::EigenProblemType eigen_problem_type);
 
  virtual Real computeResidualL2Norm() override;
 
  virtual void computeJacobianTag(const NumericVector<Number> & soln,
                                  SparseMatrix<Number> & jacobian,
                                  TagID tag) override;
 
  void computeMatricesTags(const NumericVector<Number> & soln,
                           const std::vector<SparseMatrix<Number> *> & jacobians,
                           const std::set<TagID> & tags);
 
  void computeJacobianAB(const NumericVector<Number> & soln,
                         SparseMatrix<Number> & jacobianA,
                         SparseMatrix<Number> & jacobianB,
                         TagID tagA,
                         TagID tagB);
 
  virtual void computeJacobianBlocks(std::vector<JacobianBlock *> & blocks,
                                     const unsigned int nl_sys_num) override;
 
  virtual void computeResidualTag(const NumericVector<Number> & soln,
                                  NumericVector<Number> & residual,
                                  TagID tag) override;
 
  void computeResidualAB(const NumericVector<Number> & soln,
                         NumericVector<Number> & residualA,
                         NumericVector<Number> & residualB,
                         TagID tagA,
                         TagID tagB);
 
  virtual void execute(const ExecFlagType & exec_type) override;
 
  void initEigenvector(const Real initial_value);
 
  unsigned int activeEigenvalueIndex() const { return _active_eigen_index; }
 
  virtual void initPetscOutputAndSomeSolverSettings() override;
 
  bool outputInverseEigenvalue() const { return _output_inverse_eigenvalue; }
 
  void outputInverseEigenvalue(bool inverse) { _output_inverse_eigenvalue = inverse; }
 
  bool onLinearSolver() const { return _on_linear_solver; }
 
  void onLinearSolver(bool ols) { _on_linear_solver = ols; }
 
  bool constantMatrices() const { return _constant_matrices; }
 
  void constantMatrices(bool cm) { _constant_matrices = cm; }
 
  bool wereMatricesFormed() const { return _matrices_formed; }
 
  void wereMatricesFormed(bool mf) { _matrices_formed = mf; }
 
  Real formNorm();
 
  bool bxNormProvided() const { return _bx_norm_name.has_value(); }
 
  void setBxNorm(const PostprocessorName & bx_norm) { _bx_norm_name = bx_norm; }
 
protected:
  unsigned int _n_eigen_pairs_required;
  bool _generalized_eigenvalue_problem;
  std::shared_ptr<NonlinearEigenSystem> _nl_eigen;
 
  bool _negative_sign_eigen_kernel;
  unsigned int _active_eigen_index;
 
  bool _do_free_power_iteration;
  bool _output_inverse_eigenvalue;
  bool _on_linear_solver;
  bool _matrices_formed;
  bool _constant_matrices;
  bool _has_normalization;
  PostprocessorName _normalization;
  Real _normal_factor;
  bool & _first_solve;
  Real _initial_eigenvalue;
 
private:
  void doFreeNonlinearPowerIterations(unsigned int free_power_iterations);
 
  void adjustEigenVector(const Real value, bool scaling);
 
  std::optional<PostprocessorName> _bx_norm_name;
 
#endif
 
  using FEProblemBase::_nl;
};
 
#ifdef LIBMESH_HAVE_SLEPC
 
inline NonlinearEigenSystem &
EigenProblem::getNonlinearEigenSystem(const unsigned int nl_sys_num)
{
  if (nl_sys_num > 0)
    mooseError("eigen problems do not currently support multiple nonlinear eigen systems");
  return *_nl_eigen;
}
 
inline NonlinearEigenSystem &
EigenProblem::getCurrentNonlinearEigenSystem()
{
  return *_nl_eigen;
}
 
#endif