Executor.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"
#include "ExecutorInterface.h"

#include <string>

class Problem;
class Executor;

class Executor : public Executioner, public ExecutorInterface
{
public:
  struct Result
  {
    Result() : converged(true), _name("NO_NAME") {}
    Result(const std::string & name) : converged(true), _name(name) {}
    Result(const MooseObject * obj) : converged(true), _name(obj->name()) {}

    bool converged = true;

    std::string reason;

    std::map<std::string, Result> subs;

    std::string
    str(bool success_msg = false, const std::string & indent = "", const std::string & subname = "")
    {
      std::string s = indent + label(success_msg, subname) + "\n";
      for (auto & entry : subs)
        s += entry.second.str(success_msg, indent + "    ", entry.first);
      return s;
    }

    void pass(const std::string & msg, bool overwrite = false)
    {
      mooseAssert(converged || overwrite,
                  "cannot override nonconverged executioner result with a passing one");
      ((void)(overwrite)); // avoid unused error due to assert
      reason = msg;
      converged = true;
    }

    void fail(const std::string & msg)
    {
      reason = msg;
      converged = false;
    }

    bool record(const std::string & name, const Result & r)
    {
      subs[name] = r;
      return r.convergedAll();
    }

    bool convergedAll() const
    {
      if (!converged)
        return false;
      for (auto & entry : subs)
        if (!entry.second.convergedAll())
          return false;
      return true;
    }

  private:
    std::string label(bool success_msg, const std::string & subname = "")
    {
      std::string state_str =
          success_msg || !converged ? (std::string("(") + (converged ? "pass" : "FAIL") + ")") : "";
      return subname + (subname.empty() ? "" : ":") + _name + state_str +
             ((success_msg || !converged) && !reason.empty() ? ": " + reason : "");
    }
    std::string _name;
  };

  Executor(const InputParameters & parameters);

  virtual ~Executor() {}

  static InputParameters validParams();

  Result exec();

  virtual void execute() override final {}

  Result & newResult()
  {
    _result = Result(this);
    return _result;
  }

  virtual bool lastSolveConverged() const override { return _result.convergedAll(); }

protected:
  virtual Result run() = 0;

  ExecFlagType _begin_flag;
  ExecFlagType _end_flag;

private:
  Result _result;
};