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;

  PicardSolve & picardSolve()
  {
    mooseDeprecated("picardSolve() is deprecated. Use fixedPointSolve() instead.");
    if (_iteration_method == "picard")
      return *(dynamic_cast<PicardSolve *>(_fixed_point_solve.get()));
    else
      mooseError("Cannot return a PicardSolve if the iteration method is not Picard.");
  }

  FixedPointSolve & fixedPointSolve() { return *_fixed_point_solve; }

  virtual bool augmentedPicardConvergenceCheck() const
  {
    mooseDeprecated(
        "augmentedPicardConvergenceCheck() is deprecated. Use augmentedCouplingConvergenceCheck.");
    return false;
  }

  const bool & verbose() const { return _verbose; }

  static MooseEnum iterationMethods() { return MooseEnum("picard secant steffensen", "picard"); }

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