Executioner.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 "MooseObject.h"
#include "UserObjectInterface.h"
#include "PostprocessorInterface.h"
#include "Restartable.h"
#include "PerfGraphInterface.h"
#include "FEProblemSolve.h"
#include "FixedPointSolve.h"
#include "PicardSolve.h"
#include "Reporter.h"
#include "ReporterInterface.h"
 
// System includes
#include <string>
 
class Problem;
class Executioner : public MooseObject,
                    private Reporter,          // see addAttributeReporter
                    private ReporterInterface, // see addAttributeReporter
                    public UserObjectInterface,
                    public PostprocessorInterface,
                    public Restartable,
                    public PerfGraphInterface
{
public:
  Executioner(const InputParameters & parameters);
 
  Executioner(const InputParameters & parameters, bool);
 
  virtual ~Executioner() {}
 
  static InputParameters validParams();
 
  virtual void preProblemInit() {}
 
  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() const { return std::string(); }
 
  virtual std::vector<std::string> getTimeIntegratorNames() const { return {}; }
 
  virtual void parentOutputPositionChanged() {}
 
  virtual bool lastSolveConverged() const = 0;
 
  FixedPointSolve & fixedPointSolve() { return *_fixed_point_solve; }
 
  const bool & verbose() const { return _verbose; }
 
  static MooseEnum iterationMethods() { return MooseEnum("picard secant steffensen", "picard"); }
 
  void registerSolveObject(const SolveObject & so) { _solve_objects.push_back(&so); }
 
  template <class T>
  bool hasSolveObject() const
  {
    for (const auto & so : _solve_objects)
    {
      const T * tso = dynamic_cast<const T *>(so);
      if (tso)
        return true;
    }
    return false;
  }
 
protected:
  virtual PostprocessorValue & addAttributeReporter(const std::string & name,
                                                    Real initial_value = 0);
 
  FEProblemBase & _fe_problem;
 
  MooseEnum _iteration_method;
  std::unique_ptr<FixedPointSolve> _fixed_point_solve;
 
  // Restart
  std::string _restart_file_base;
 
  const bool & _verbose;
 
private:
  std::vector<const SolveObject *> _solve_objects;
};