Restartable Class Reference

A class for creating restricted objects. More...

#include <Restartable.h>

Inheritance diagram for Restartable:

Classes
class	ManagedValue
	Wrapper class for restartable data that is "managed. More...

Public Member Functions
	Restartable (const MooseObject *moose_object, const std::string &system_name)
	Class constructor. More...
	Restartable (const MooseObject *moose_object, const std::string &system_name, THREAD_ID tid)
	Class constructor. More...
	Restartable (MooseApp &moose_app, const std::string &name, const std::string &system_name, THREAD_ID tid, const bool read_only=false, const RestartableDataMapName &metaname="")
	This class constructor is used for non-Moose-based objects like interfaces. More...
	Restartable (const Restartable &object, const Moose::Kokkos::FunctorCopy &key)
	Special constructor used for Kokkos functor copy during parallel dispatch. More...

Protected Member Functions
template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it. More...
template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable". More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable". More...
std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...

Protected Attributes
MooseApp &	_restartable_app
	Reference to the application. More...
const std::string	_restartable_system_name
	The system name this object is in. More...
const THREAD_ID	_restartable_tid
	The thread ID for this object. More...
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...

Private Member Functions
RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
	Helper function for actually registering the restartable data. More...
void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data. More...
template<typename T , typename... Args>
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
	Helper function for declaring restartable data. More...

Private Attributes
const RestartableDataMapName	_metaname
	Restartable metadata name. More...
std::string	_restartable_name
	The name of the object. More...

Detailed Description

A class for creating restricted objects.

See also

BlockRestartable BoundaryRestartable

Definition at line 28 of file Restartable.h.

Constructor & Destructor Documentation

Restartable() [1/4]

Restartable::Restartable	(	const MooseObject *	moose_object,
		const std::string &	system_name
	)

Class constructor.

Parameters

moose_object	The MooseObject that this interface is being implemented on.
system_name	The name of the MOOSE system. ie "Kernel", "BCs", etc. Should roughly correspond to the section in the input file so errors are easy to understand.

This method will forward the thread id if it exists in the moose_object parameters. Delegates to the "MooseApp &" constructor.

Definition at line 18 of file Restartable.C.

  : Restartable(moose_object->getMooseApp(),
                moose_object->name(),
                system_name,
                moose_object->parameters().isParamValid("_tid")
                    ? moose_object->parameters().get<THREAD_ID>("_tid")
                    : 0)
{
}

Restartable() [2/4]

Restartable::Restartable	(	const MooseObject *	moose_object,
		const std::string &	system_name,
		THREAD_ID	tid
	)

Class constructor.

Similar to the other class constructor but also accepts an individual thread ID. If this method is used, no thread ID in the parameters object is used. Delegates to the "MooseApp &" constructor.

Definition at line 28 of file Restartable.C.

  : Restartable(moose_object->getMooseApp(), moose_object->name(), system_name, tid)
{
}

Restartable() [3/4]

Restartable::Restartable	(	MooseApp &	moose_app,
		const std::string &	name,
		const std::string &	system_name,
		THREAD_ID	tid,
		const bool	read_only = false,
		const RestartableDataMapName &	metaname = ""
	)

This class constructor is used for non-Moose-based objects like interfaces.

A name for the storage as well as a system name must be passed in along with the thread ID explicitly.

Parameters

moose_app	Reference to the application
name	The name which is used when constructing the full-names of the restartable data. It is used with the following logic: system_name/name/data_name. (e.g. UserObjects/diffusion_kernel/coefficient). In most of the cases this is the name of the moose object.
system_name	The name of the system where this object belongs to.
tid	The thread ID.
read_only	Switch to restrict the data for read-only.
metaname	The name of the datamap where the restartable objects should be registered to.

Definition at line 35 of file Restartable.C.

  : _restartable_app(moose_app),
    _restartable_system_name(system_name),
    _restartable_tid(tid),
    _restartable_read_only(read_only),
    _metaname(metaname),
    _restartable_name(name)
{
}

Restartable() [4/4]

Restartable::Restartable	(	const Restartable &	object,
		const Moose::Kokkos::FunctorCopy &	key
	)

Special constructor used for Kokkos functor copy during parallel dispatch.

Definition at line 51 of file Restartable.C.

  : _restartable_app(object._restartable_app),
    _restartable_system_name(object._restartable_system_name),
    _restartable_tid(object._restartable_tid),
    _restartable_read_only(object._restartable_read_only),
    _metaname(object._metaname),
    _restartable_name(object._restartable_name)
{
}

Member Function Documentation

declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protected

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData ( const std::string &  data_name, Args &&...  args  )

protected

Declare a piece of data as "recoverable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);

  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);

  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData ( const std::string &  data_name, Args &&...  args  )

protected

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataHelper()

template<typename T , typename... Args>

RestartableData< T > & Restartable::declareRestartableDataHelper ( const std::string &  data_name, void *  context, Args &&...  args  ) const

private

Helper function for declaring restartable data.

We use this function to reduce code duplication when returning const/nonconst references to the data.

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 310 of file Restartable.h.

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

declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protected

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const std::string &  object_name, Args &&...  args  )

protected

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
args	Arguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const std::string &  object_name, void *  context, Args &&...  args  )

protected

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

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

getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string &  data_name ) const

protected

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

NOTE: This returns a const reference! Make sure you store it in a const reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

registerRestartableDataOnApp()

RestartableDataValue & Restartable::registerRestartableDataOnApp ( std::unique_ptr< RestartableDataValue >  data, THREAD_ID  tid  ) const

private

Helper function for actually registering the restartable data.

Definition at line 63 of file Restartable.C.

Referenced by declareRestartableDataHelper().

{
  return _restartable_app.registerRestartableData(
      std::move(data), tid, _restartable_read_only, _metaname);
}

registerRestartableNameWithFilterOnApp()

void Restartable::registerRestartableNameWithFilterOnApp ( const std::string &  name, Moose::RESTARTABLE_FILTER  filter  )

private

Helper function for actually registering the restartable data.

Definition at line 71 of file Restartable.C.

Referenced by declareRecoverableData().

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

restartableName()

std::string Restartable::restartableName ( const std::string &  data_name ) const

protected

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

Referenced by declareRecoverableData(), and declareRestartableDataHelper().

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

Member Data Documentation

_metaname

const RestartableDataMapName Restartable::_metaname

private

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by registerRestartableDataOnApp().

_restartable_app

MooseApp& Restartable::_restartable_app

protected

Reference to the application.

Definition at line 234 of file Restartable.h.

Referenced by registerRestartableDataOnApp(), and registerRestartableNameWithFilterOnApp().

_restartable_name

std::string Restartable::_restartable_name

private

The name of the object.

Definition at line 250 of file Restartable.h.

Referenced by declareRestartableDataWithObjectNameWithContext(), and restartableName().

_restartable_read_only

const bool Restartable::_restartable_read_only

protected

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by registerRestartableDataOnApp().

_restartable_system_name

const std::string Restartable::_restartable_system_name

protected

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by restartableName().

_restartable_tid

const THREAD_ID Restartable::_restartable_tid

protected

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by declareRestartableDataHelper().

---

The documentation for this class was generated from the following files:

• include/restart/Restartable.h
• src/restart/Restartable.C