MultiApp.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 "SetupInterface.h"
#include "Restartable.h"

#include "libmesh/communicator.h"
#include "libmesh/point.h"

class MultiApp;
class UserObject;
class FEProblemBase;
class FEProblem;
class Executioner;
class MooseApp;
class Backup;

// libMesh forward declarations
namespace libMesh
{
class BoundingBox;
namespace MeshTools
{
class BoundingBox;
}
template <typename T>
class NumericVector;
} // namespace libMesh

template <>
InputParameters validParams<MultiApp>();

class SubAppBackups : public std::vector<std::shared_ptr<Backup>>
{
};

class MultiApp : public MooseObject, public SetupInterface, public Restartable
{
public:
  MultiApp(const InputParameters & parameters);

  virtual void preExecute() {}

  virtual void finalize();

  virtual void postExecute();

  void setupPositions();

  virtual void initialSetup() override;

  virtual void preTransfer(Real dt, Real target_time);

  virtual bool solveStep(Real dt, Real target_time, bool auto_advance = true) = 0;

  virtual void incrementTStep(Real /*target_time*/) {}

  virtual void finishStep() {}

  virtual void backup();

  virtual void restore();

  virtual bool needsRestoration() { return true; }

  virtual Executioner * getExecutioner(unsigned int app);

  virtual BoundingBox getBoundingBox(unsigned int app, bool displaced_mesh);

  FEProblemBase & problemBase() { return _fe_problem; }

  FEProblemBase & appProblemBase(unsigned int app);

  FEProblem & appProblem(unsigned int app);

  const UserObject & appUserObjectBase(unsigned int app, const std::string & name);

  Real appPostprocessorValue(unsigned int app, const std::string & name);

  virtual NumericVector<Number> & appTransferVector(unsigned int app, std::string var_name);

  unsigned int numGlobalApps() { return _total_num_apps; }

  unsigned int numLocalApps() { return _apps.size(); }

  unsigned int firstLocalApp() { return _first_local_app; }

  bool hasApp() { return _has_an_app; }

  bool hasLocalApp(unsigned int global_app);

  MooseApp * localApp(unsigned int local_app);

  Point position(unsigned int app) { return _positions[app]; }

  virtual void resetApp(unsigned int global_app, Real time = 0.0);

  virtual void moveApp(unsigned int global_app, Point p);

  virtual void parentOutputPositionChanged();

  MPI_Comm & comm() { return _my_comm; }

  bool isRootProcessor() { return _my_rank == 0; }

protected:
  virtual void fillPositions();

  void createApp(unsigned int i, Real start_time);

  void buildComm();

  unsigned int globalAppToLocal(unsigned int global_app);

  virtual void preRunInputFile();

  virtual std::string getCommandLineArgsParamHelper(unsigned int local_app);

  void init(unsigned int num);

  FEProblemBase & _fe_problem;

  std::string _app_type;

  std::vector<Point> _positions;

  const bool _use_positions;

  std::vector<FileName> _input_files;

  std::string _output_base;

  unsigned int _total_num_apps;

  unsigned int _my_num_apps;

  unsigned int _first_local_app;

  const MPI_Comm & _orig_comm;

  libMesh::Parallel::Communicator _my_communicator;

  MPI_Comm & _my_comm;

  int _orig_num_procs;

  int _orig_rank;

  std::string _node_name;

  int _my_rank;

  std::vector<std::shared_ptr<MooseApp>> _apps;

  std::vector<bool> _has_bounding_box;

  std::vector<BoundingBox> _bounding_box;

  Real _inflation;

  Point _bounding_box_padding;

  unsigned int _max_procs_per_app;

  bool _output_in_position;

  const Real _global_time_offset;

  Real _reset_time;

  std::vector<unsigned int> _reset_apps;

  bool _reset_happened;

  Real _move_time;

  std::vector<unsigned int> _move_apps;

  std::vector<Point> _move_positions;

  bool _move_happened;

  bool _has_an_app;

  SubAppBackups & _backups;

  const std::vector<std::string> & _cli_args;
};

template <>
inline void
dataStore(std::ostream & stream, SubAppBackups & backups, void * context)
{
  MultiApp * multi_app = static_cast<MultiApp *>(context);

  multi_app->backup();

  if (!multi_app)
    mooseError("Error storing std::vector<Backup*>");

  for (unsigned int i = 0; i < backups.size(); i++)
    dataStore(stream, backups[i], context);
}

template <>
inline void
dataLoad(std::istream & stream, SubAppBackups & backups, void * context)
{
  MultiApp * multi_app = static_cast<MultiApp *>(context);

  if (!multi_app)
    mooseError("Error loading std::vector<Backup*>");

  for (unsigned int i = 0; i < backups.size(); i++)
    dataLoad(stream, backups[i], context);

  multi_app->restore();
}