EigenExecutionerBase.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 "Executioner.h"

class MooseEigenSystem;
class FEProblemBase;

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();

  // 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);
};