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