Restartable.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
 
// MOOSE includes
#include "MooseTypes.h"
#include "RestartableData.h"
 
// Forward declarations
class PostprocessorData;
class SubProblem;
class InputParameters;
class MooseObject;
class MooseApp;
class MooseMesh;
 
class Restartable
{
public:
  template <typename T>
  class ManagedValue
  {
  public:
    ManagedValue(RestartableData<T> & value) : _value(value) {}
 
    ~ManagedValue() { _value.reset(); }
 
    const T & get() const { return _value.get(); }
    T & set() { return _value.set(); }
 
  private:
    RestartableData<T> & _value;
  };
 
  Restartable(const MooseObject * moose_object, const std::string & system_name);
 
  Restartable(const MooseObject * moose_object, const std::string & system_name, THREAD_ID tid);
 
  Restartable(MooseApp & moose_app,
              const std::string & name,
              const std::string & system_name,
              THREAD_ID tid,
              const bool read_only = false,
              const RestartableDataMapName & metaname = "");
 
#ifdef MOOSE_KOKKOS_ENABLED
  Restartable(const Restartable & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
protected:
  template <typename T, typename... Args>
  T & declareRestartableData(const std::string & data_name, Args &&... args);
 
  template <typename T, typename... Args>
  ManagedValue<T> declareManagedRestartableDataWithContext(const std::string & data_name,
                                                           void * context,
                                                           Args &&... args);
 
  template <typename T, typename... Args>
  const T & getRestartableData(const std::string & data_name) const;
 
  template <typename T, typename... Args>
  T &
  declareRestartableDataWithContext(const std::string & data_name, void * context, Args &&... args);
 
  template <typename T, typename... Args>
  T & declareRecoverableData(const std::string & data_name, Args &&... args);
 
  template <typename T, typename... Args>
  T & declareRestartableDataWithObjectName(const std::string & data_name,
                                           const std::string & object_name,
                                           Args &&... args);
 
  template <typename T, typename... Args>
  T & declareRestartableDataWithObjectNameWithContext(const std::string & data_name,
                                                      const std::string & object_name,
                                                      void * context,
                                                      Args &&... args);
 
  std::string restartableName(const std::string & data_name) const;
 
  MooseApp & _restartable_app;
 
  const std::string _restartable_system_name;
 
  const THREAD_ID _restartable_tid;
 
  const bool _restartable_read_only;
 
private:
  const RestartableDataMapName _metaname;
 
  std::string _restartable_name;
 
  RestartableDataValue & registerRestartableDataOnApp(std::unique_ptr<RestartableDataValue> data,
                                                      THREAD_ID tid) const;
 
  void registerRestartableNameWithFilterOnApp(const std::string & name,
                                              Moose::RESTARTABLE_FILTER filter);
 
  template <typename T, typename... Args>
  RestartableData<T> & declareRestartableDataHelper(const std::string & data_name,
                                                    void * context,
                                                    Args &&... args) const;
};
 
template <typename T, typename... Args>
T &
Restartable::declareRestartableData(const std::string & data_name, Args &&... args)
{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}
 
template <typename T, typename... Args>
Restartable::ManagedValue<T>
Restartable::declareManagedRestartableDataWithContext(const std::string & data_name,
                                                      void * context,
                                                      Args &&... args)
{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}
 
template <typename T, typename... Args>
const T &
Restartable::getRestartableData(const std::string & data_name) const
{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}
 
template <typename T, typename... Args>
T &
Restartable::declareRestartableDataWithContext(const std::string & data_name,
                                               void * context,
                                               Args &&... args)
{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}
 
template <typename T, typename... Args>
RestartableData<T> &
Restartable::declareRestartableDataHelper(const std::string & data_name,
                                          void * context,
                                          Args &&... args) const
{
  const auto full_name = restartableName(data_name);
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr =
      std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref;
}
 
template <typename T, typename... Args>
T &
Restartable::declareRestartableDataWithObjectName(const std::string & data_name,
                                                  const std::string & object_name,
                                                  Args &&... args)
{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}
 
template <typename T, typename... Args>
T &
Restartable::declareRestartableDataWithObjectNameWithContext(const std::string & data_name,
                                                             const std::string & object_name,
                                                             void * context,
                                                             Args &&... args)
{
  std::string old_name = _restartable_name;
 
  _restartable_name = object_name;
 
  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
 
  _restartable_name = old_name;
 
  return value;
}
 
template <typename T, typename... Args>
T &
Restartable::declareRecoverableData(const std::string & data_name, Args &&... args)
{
  const auto full_name = restartableName(data_name);
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}