Executioner.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 "MooseObject.h"
#include "UserObjectInterface.h"
#include "PostprocessorInterface.h"
#include "Restartable.h"
#include "PerfGraphInterface.h"
#include "FEProblemSolve.h"
#include "PicardSolve.h"
 
// System includes
#include <string>
 
class Problem;
class Executioner;
 
template <>
InputParameters validParams<Executioner>();
 
class Executioner : public MooseObject,
                    public UserObjectInterface,
                    public PostprocessorInterface,
                    public Restartable,
                    public PerfGraphInterface
{
public:
  Executioner(const InputParameters & parameters);
 
  virtual ~Executioner() {}
 
  static InputParameters validParams();
 
  virtual void init() {}
 
  virtual void execute() = 0;
 
  virtual void preExecute() {}
 
  virtual void postExecute() {}
 
  virtual void preSolve() {}
 
  virtual void postSolve() {}
 
  virtual Problem & problem();
 
  FEProblemBase & feProblem();
 
  virtual std::string getTimeStepperName() { return std::string(); }
 
  virtual void parentOutputPositionChanged() {}
 
  virtual bool lastSolveConverged() const = 0;
 
  FEProblemSolve & feProblemSolve() { return _feproblem_solve; }
 
  PicardSolve & picardSolve() { return _picard_solve; }
 
  virtual bool augmentedPicardConvergenceCheck() const { return false; }
 
  const bool & verbose() const { return _verbose; }
 
  unsigned int numGridSteps() const { return _num_grid_steps; }
 
protected:
  virtual PostprocessorValue & addAttributeReporter(const std::string & name,
                                                    Real initial_value = 0);
 
  FEProblemBase & _fe_problem;
 
  FEProblemSolve _feproblem_solve;
  PicardSolve _picard_solve;
 
  // Restart
  std::string _restart_file_base;
 
  const bool & _verbose;
 
  const unsigned int _num_grid_steps;
};