EigenExecutionerBase.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 "Executioner.h"
 
class MooseEigenSystem;
class FEProblemBase;
class DefaultNonlinearConvergence;
 
class EigenExecutionerBase : public Executioner
{
public:
  static InputParameters validParams();
 
  EigenExecutionerBase(const InputParameters & parameters);
 
  virtual void init() override;
 
  const Real & eigenvalueOld();
 
  virtual void makeBXConsistent(Real k);
 
  virtual void checkIntegrity();
 
  virtual bool inversePowerIteration(unsigned int min_iter,
                                     unsigned int max_iter,
                                     Real pfactor,
                                     bool cheb_on,
                                     Real tol_eig,
                                     bool echo,
                                     PostprocessorName xdiff,
                                     Real tol_x,
                                     Real & k,
                                     Real & initial_res);
 
  virtual void preIteration();
 
  virtual void postIteration();
 
  virtual void postExecute() override;
 
  virtual Real normalizeSolution(bool force = true);
 
  virtual bool nonlinearSolve(Real rel_tol, Real abs_tol, Real pfactor, Real & k);
 
  Real & eigenValue() { return _eigenvalue; }
 
protected:
  virtual void printEigenvalue();
 
  DefaultNonlinearConvergence * getEigenSystemConvergence();
 
  // the fe problem
  FEProblemBase & _problem;
  MooseEigenSystem & _eigen_sys;
 
  FEProblemSolve _feproblem_solve;
 
  PostprocessorValue & _eigenvalue;
 
  // postprocessor for eigenvalue
  const Real & _source_integral;
  Real _source_integral_old;
 
  const Real & _normalization;
  ExecFlagEnum _norm_exec;
 
  // Chebyshev acceleration
  class Chebyshev_Parameters
  {
  public:
    Chebyshev_Parameters();
    void reinit();
 
    const unsigned int n_iter;  // minimum number of accelerated iteration each cycle
    const unsigned int fsmooth; // number of unaccelerated iteration each cycle
    unsigned int finit;         // number of unaccelerated iteration before Chebyshev
 
    unsigned int lgac;          // doing acceleration or not
    unsigned int icheb;         // number of acceleration in current cycle
    unsigned int iter_begin;    // starting number of current acceleration cycle
    double error_begin;         // starting flux error of current acceleration cycle
    double flux_error_norm_old; // flux error of previous power iteration
    double ratio;               // estimation of dominant ratio
    double ratio_new;           // new estimated dominant ratio
    unsigned int icho;          // improved ratio estimation
  };
  void chebyshev(Chebyshev_Parameters & params,
                 unsigned int iter,
                 const PostprocessorValue * solution_diff);
 
private:
  DefaultNonlinearConvergence * _eigen_sys_conv;
};