ActionWarehouse.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 <string>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <ostream>
 
// MOOSE includes
#include "Action.h"
#include "ConsoleStreamInterface.h"
 
using ActionIterator = std::list<Action *>::iterator;
 
class MooseMesh;
class Syntax;
class ActionFactory;
class FEProblem;
class PhysicsBase;
 
class ActionWarehouse : public ConsoleStreamInterface
{
public:
  ActionWarehouse(MooseApp & app, Syntax & syntax, ActionFactory & factory);
  ~ActionWarehouse();
 
  void build();
 
  void clear();
 
  bool empty() const { return _action_blocks.empty(); }
 
  void addActionBlock(std::shared_ptr<Action> blk);
 
  void checkUnsatisfiedActions() const;
 
  void printActionDependencySets() const;
 
  void printInputFile(std::ostream & out);
 
 
  ActionIterator actionBlocksWithActionBegin(const std::string & task);
  ActionIterator actionBlocksWithActionEnd(const std::string & task);
 
  const std::vector<std::shared_ptr<Action>> & allActionBlocks() const;
 
  const std::list<Action *> & getActionListByName(const std::string & task) const;
 
  template <class T>
  const T & getAction(const std::string & name) const
  {
    typename std::shared_ptr<T> p;
    for (auto act_ptr : _all_ptrs)
    {
      if (act_ptr->name() == name)
      {
        p = std::dynamic_pointer_cast<T>(act_ptr);
        if (p)
          break;
      }
    }
    if (!p)
    {
      std::vector<std::string> all_names;
      for (auto act_ptr : _all_ptrs)
        if (!act_ptr->name().empty())
          all_names.push_back(act_ptr->name());
        else
          all_names.push_back("unnamed");
      mooseError("Action with name '",
                 name,
                 "' does not exist.\n These are the Actions that do exist:",
                 Moose::stringify(all_names));
    }
    return *p;
  }
  template <class T>
  T & getAction(const std::string & name)
  {
    return const_cast<T &>(static_cast<const ActionWarehouse *>(this)->getAction<T>(name));
  }
 
  template <class T>
  T * getPhysics(const std::string & name) const
  {
    auto physics = const_cast<T *>(&getAction<T>(name));
    if (!dynamic_cast<const PhysicsBase *>(physics))
      mooseError("The Physics requested of type '",
                 MooseUtils::prettyCppType<T>(),
                 "' and name '",
                 name,
                 "' is not derived from the PhysicsBase class");
    return physics;
  }
 
  template <class T>
  std::vector<const T *> getActions()
  {
    // we need to create the map first to ensure that all actions in the map are unique
    // and the actions are sorted by their names
    typename std::map<std::string, const std::shared_ptr<T>> actions;
    for (auto act_ptr : _all_ptrs)
    {
      auto p = std::dynamic_pointer_cast<T>(act_ptr);
      if (p)
        actions.insert(std::make_pair(act_ptr->name(), p));
    }
    // construct the vector from the map entries
    std::vector<const T *> action_vector;
    for (auto & pair : actions)
      action_vector.push_back(pair.second.get());
    return action_vector;
  }
 
  template <class T>
  std::vector<T *> getPhysics()
  {
    const auto physics_vector = getActions<T>();
    for (const auto phys_ptr : physics_vector)
      if (!dynamic_cast<const PhysicsBase *>(phys_ptr))
        mooseError("The Physics requested of type '",
                   MooseUtils::prettyCppType<T>(),
                   "' and name '",
                   phys_ptr->name(),
                   "' is not derived from the PhysicsBase class");
    return physics_vector;
  }
 
  template <class T>
  const T * getActionByTask(const std::string & task)
  {
    const auto it = _action_blocks.find(task);
    if (it == _action_blocks.end())
      return nullptr;
 
    T * p = nullptr;
    for (const auto & action : it->second)
    {
      T * tp = dynamic_cast<T *>(action);
      if (tp)
      {
        if (p)
          mooseError("More than one actions have been detected in getActionByTask for the task '",
                     task,
                     "' in the app '",
                     getMooseAppName(),
                     "'");
        else
          p = tp;
      }
    }
    return p;
  }
 
  void setFinalTask(const std::string & task);
 
  bool hasActions(const std::string & task) const;
 
  void executeAllActions();
 
  void executeActionsWithAction(const std::string & task_name);
 
  void showActionDependencies(bool state = true) { _show_action_dependencies = state; }
 
  void showActions(bool state = true) { _show_actions = state; }
 
  void showParser(bool state = true) { _show_parser = state; }
 
  Syntax & syntax() { return _syntax; }
 
  // We are not really using the reference counting capabilities of
  // shared pointers here, just their memory management capability.
  // Therefore, _mesh is actually being used more like a unique_ptr in
  // this context.  Since full support for unique_ptr is not quite
  // available yet, we've implemented it as a std::shared_ptr.
  std::shared_ptr<MooseMesh> & mesh() { return _mesh; }
  const std::shared_ptr<MooseMesh> & getMesh() const { return _mesh; }
 
  std::shared_ptr<MooseMesh> & displacedMesh() { return _displaced_mesh; }
  const std::shared_ptr<MooseMesh> & getDisplacedMesh() const { return _displaced_mesh; }
 
  std::shared_ptr<FEProblemBase> & problemBase() { return _problem; }
  std::shared_ptr<FEProblem> problem();
  MooseApp & mooseApp() { return _app; }
  const std::string & getMooseAppName();
  const std::string & getCurrentTaskName() const { return _current_task; }
 
  const Action * getCurrentAction() const { return _current_action; }
  std::string getCurrentActionName() const;
 
  bool hasTask(const std::string & task) const;
  bool isTaskComplete(const std::string & task) const;
 
protected:
  void buildBuildableActions(const std::string & task);
 
  std::vector<UserObjectName> getUserObjectParamDependencies(const InputParameters & params) const;
 
  void sortUserObjectActions(std::list<Action *> & actions) const;
 
  std::vector<std::shared_ptr<Action>> _all_ptrs;
 
  MooseApp & _app;
  Syntax & _syntax;
  ActionFactory & _action_factory;
  std::map<std::string, std::list<Action *>> _action_blocks;
  std::vector<std::string> _ordered_names;
  std::set<std::string> _completed_tasks;
  std::set<std::string> _unsatisfied_dependencies;
 
  bool _generator_valid;
 
  bool _show_action_dependencies;
  bool _show_actions;
  bool _show_parser;
 
  // When executing the actions in the warehouse, this string will always contain
  // the current task name
  std::string _current_task;
  // The current action that is running
  Action * _current_action;
 
  //
  // data created by actions
  //
 
  std::shared_ptr<MooseMesh> _mesh;
 
  std::shared_ptr<MooseMesh> _displaced_mesh;
 
  std::shared_ptr<FEProblemBase> _problem;
 
private:
  std::string _final_task;
 
  const std::list<Action *> _empty_action_list;
 
  mutable std::mutex _completed_tasks_mutex;
};