MaterialPropertyStorage Class Reference

Stores the stateful material properties computed by materials. More...

#include <MaterialPropertyStorage.h>

Inheritance diagram for MaterialPropertyStorage:

Classes
struct	PropRecord
	Basic structure for storing information about a property. More...

Public Types
typedef HashMap< const Elem *, HashMap< unsigned int, MaterialProperties > >	PropsType
	Accessible type of the stored material property data.

Public Member Functions
	MaterialPropertyStorage (MaterialPropertyRegistry &registry, FEProblemBase &problem)
void	prolongStatefulProps (processor_id_type pid, const std::vector< std::vector< QpMap > > &refinement_map, const libMesh::QBase &qrule, const libMesh::QBase &qrule_face, MaterialPropertyStorage &parent_material_props, const THREAD_ID tid, const Elem &elem, const int input_parent_side, const int input_child, const int input_child_side)
	Creates storage for newly created elements from mesh Adaptivity.
void	updateStatefulPropsForPRefinement (const processor_id_type pid, const std::vector< QpMap > &p_refinement_map, const libMesh::QBase &qrule, const libMesh::QBase &qrule_face, const THREAD_ID tid, const Elem &elem, const int input_side)
	Based on the p-refinement flag of elem, either prolong (for refinement) or restrict (for coarsening) the stateful material property data.
void	restrictStatefulProps (const std::vector< std::pair< unsigned int, QpMap > > &coarsening_map, const std::vector< const Elem * > &coarsened_element_children, const libMesh::QBase &qrule, const libMesh::QBase &qrule_face, const THREAD_ID tid, const Elem &elem, int input_side=-1)
	Creates storage for newly created elements from mesh Adaptivity.
void	initStatefulProps (const THREAD_ID tid, const std::vector< std::shared_ptr< MaterialBase > > &mats, const unsigned int n_qpoints, const Elem &elem, const unsigned int side=0)
	Initialize stateful material properties.
void	shift ()
	Shift the material properties in time.
void	copy (const THREAD_ID tid, const Elem &elem_to, const Elem &elem_from, unsigned int side, unsigned int n_qpoints)
	Copy material properties from elem_from to elem_to.
void	copy (const THREAD_ID tid, const Elem *elem_to, const Elem *elem_from, unsigned int side, unsigned int n_qpoints)
	Copy material properties from elem_from to elem_to.
void	swap (const THREAD_ID tid, const Elem &elem, unsigned int side)
	Swap (shallow copy) material properties in MaterialData and MaterialPropertyStorage Thread safe.
void	swapBack (const THREAD_ID tid, const Elem &elem, unsigned int side)
	Swap (shallow copy) material properties in MaterialPropertyStorage and MaterialDat Thread safe.
bool	hasStatefulProperties () const
bool	hasOlderProperties () const
bool	hasProperty (const std::string &prop_name) const
unsigned int	addProperty (const std::string &prop_name, const std::type_info &type, const unsigned int state, const MaterialBase *const declarer)
	Adds a property with the name prop_name, type type, and state state (0 = current, 1 = old, etc)
const std::vector< unsigned int > &	statefulProps () const
const MaterialPropertyRegistry &	getMaterialPropertyRegistry () const
std::optional< std::string >	queryStatefulPropName (const unsigned int id) const
void	eraseProperty (const Elem *elem)
	Remove the property storage and element pointer from internal data structures Use this when elements are deleted so we don't end up with invalid elem pointers (for e.g.
unsigned int	maxState () const
unsigned int	numStates () const
libMesh::IntRange< unsigned int >	stateIndexRange () const
libMesh::IntRange< unsigned int >	statefulIndexRange () const
const MaterialData &	getMaterialData (const THREAD_ID tid) const
MaterialData &	getMaterialData (const THREAD_ID tid)
const std::set< const MooseObject * > &	getConsumers (Moose::MaterialDataType type) const
void	addConsumer (Moose::MaterialDataType type, const MooseObject *object)
	Add object as the consumer of storage of type type.
void	setRecovering ()
	Sets the loading of stateful material properties to recover.
void	setRestartInPlace ()
	Sets the loading of stateful material properties in place.
const PropRecord &	getPropRecord (const unsigned int id) const
	Get the property record associated with the material with id id.
bool	isRestoredProperty (const std::string &name) const
const PropsType &	props (const unsigned int state=0) const
	Access methods to the stored material property data with the given state state.
const MaterialProperties &	props (const Elem *elem, unsigned int side, const unsigned int state=0) const
MaterialProperties &	setProps (const Elem *elem, unsigned int side, const unsigned int state=0)

Protected Member Functions
void	sizeProps (MaterialProperties &mp, unsigned int size)

Protected Attributes
FEProblemBase &	_problem
	Reference to the problem.
std::array< PropsType, MaterialData::max_state+1 >	_storage
	The actual storage.
std::vector< std::optional< PropRecord > >	_prop_records
	Property records indexed by property id (may be null)
std::vector< unsigned int >	_stateful_prop_id_to_prop_id
	the vector of stateful property ids (the vector index is the map to stateful prop_id)
std::map< Moose::MaterialDataType, std::set< const MooseObject * > >	_consumers
	The consumers of this storage.

Private Types
typedef std::unordered_map< std::pair< const Elem *, unsigned int >, std::map< unsigned int, std::vector< std::stringstream > > >	RestartableMapType

Private Member Functions
std::vector< MaterialProperties * >	initProps (const THREAD_ID tid, const Elem *elem, unsigned int side, unsigned int n_qpoints)
	Initializes hashmap entries for element and side to proper qpoint and property count sizes.
MaterialProperties &	initProps (const THREAD_ID tid, const unsigned int state, const Elem *elem, unsigned int side, unsigned int n_qpoints)
	Initializes just one hashmap's entries.
PropsType &	setProps (const unsigned int state)
MaterialProperties &	initAndSetProps (const Elem *elem, const unsigned int side, const unsigned int state)

Static Private Member Functions
static void	shallowSwapData (const std::vector< unsigned int > &stateful_prop_ids, MaterialProperties &data, MaterialProperties &data_from)
	Shallow copies of material properties.
static void	shallowSwapDataBack (const std::vector< unsigned int > &stateful_prop_ids, MaterialProperties &data, MaterialProperties &data_from)

Private Attributes
unsigned int	_max_state
	The maximum state (0 = current, 1 = old, 2 = older)
libMesh::Threads::spin_mutex &	_spin_mtx
MaterialPropertyRegistry &	_registry
	Shared registry (across storage objects) for property names and IDs.
std::vector< MaterialData >	_material_data
	The threaded material data.
RestartableMapType	_restartable_map
	The restartable data to be loaded in initStatefulProps() later.
bool	_restart_in_place
	Whether or not we want to restart stateful properties in place.
bool	_recovering
	Whether or not we're recovering; enforces a one-to-one mapping of stateful properties.

Friends
class	ProjectMaterialProperties
class	RedistributeProperties
void	dataLoad (std::istream &, MaterialPropertyStorage &, void *)
void	dataStore (std::ostream &, MaterialPropertyStorage &, void *)

Detailed Description

Stores the stateful material properties computed by materials.

Thread-safe

Definition at line 43 of file MaterialPropertyStorage.h.

Member Typedef Documentation

PropsType

typedef HashMap<const Elem *, HashMap<unsigned int, MaterialProperties> > MaterialPropertyStorage::PropsType

Accessible type of the stored material property data.

This probably should have been returned as a proxy class; only access it via foo[elem][side] and maybe we'll be able to refactor it in the future without breaking your code.

Definition at line 255 of file MaterialPropertyStorage.h.

RestartableMapType

typedef std::unordered_map<std::pair<const Elem *, unsigned int>, std::map<unsigned int, std::vector<std::stringstream> > > MaterialPropertyStorage::RestartableMapType

private

Definition at line 452 of file MaterialPropertyStorage.h.

Constructor & Destructor Documentation

MaterialPropertyStorage()

MaterialPropertyStorage::MaterialPropertyStorage	(	MaterialPropertyRegistry &	registry,
		FEProblemBase &	problem
	)

Definition at line 23 of file MaterialPropertyStorage.C.

  : _problem(problem),
    _max_state(0),
    _spin_mtx(libMesh::Threads::spin_mtx),
    _registry(registry),
    _restart_in_place(false),
    _recovering(false)
{
  _material_data.reserve(libMesh::n_threads());
  for (const auto tid : make_range(libMesh::n_threads()))
    _material_data.emplace_back(*this, tid);
}

Member Function Documentation

addConsumer()

void MaterialPropertyStorage::addConsumer ( Moose::MaterialDataType  type, const MooseObject *  object  )

inline

Add object as the consumer of storage of type type.

Definition at line 342 of file MaterialPropertyStorage.h.

  {
    _consumers[type].insert(object);
  }

Referenced by FEProblemBase::getMaterialData().

addProperty()

unsigned int MaterialPropertyStorage::addProperty	(	const std::string &	prop_name,
		const std::type_info &	type,
		const unsigned int	state,
		const MaterialBase *const	declarer
	)

Adds a property with the name prop_name, type type, and state state (0 = current, 1 = old, etc)

This is idempotent - calling multiple times with the same name will provide the same id and works fine.

declarer should be specified by the object declaring the property if it is being declared.

Definition at line 493 of file MaterialPropertyStorage.C.

{
  if (state > MaterialData::max_state)
    mooseError("Material property state of ",
               state,
               " is not supported. Max state supported: ",
               MaterialData::max_state);
 
  // Increment state as needed
  if (maxState() < state)
    _max_state = state;
 
  // Register the property
  const auto prop_id = _registry.addOrGetID(prop_name, {});
 
  // Instantiate the record if needed
  if (_prop_records.size() < _registry.size())
    _prop_records.resize(_registry.size());
  if (!_prop_records[prop_id])
    _prop_records[prop_id] = PropRecord();
 
  // Fill the record
  auto & record = *_prop_records[prop_id];
  record.type = type.name();
  if (declarer)
    record.declarers.emplace(declarer->typeAndName());
  record.state = std::max(state, record.state);
 
  // Keep track of stateful props by quick access
  if (state > 0 && std::find(_stateful_prop_id_to_prop_id.begin(),
                             _stateful_prop_id_to_prop_id.end(),
                             prop_id) == _stateful_prop_id_to_prop_id.end())
  {
    _stateful_prop_id_to_prop_id.push_back(prop_id);
    record.stateful_id = _stateful_prop_id_to_prop_id.size() - 1;
  }
 
  return prop_id;
}

Referenced by MaterialData::addPropertyHelper().

copy() [1/2]

void MaterialPropertyStorage::copy	(	const THREAD_ID	tid,
		const Elem &	elem_to,
		const Elem &	elem_from,
		unsigned int	side,
		unsigned int	n_qpoints
	)

Copy material properties from elem_from to elem_to.

Thread safe.

WARNING: This is not capable of copying material data to/from elements on other processors. It only works if both elem_to and elem_from are both on the local processor. We can't currently check to ensure that they're on processor here because this isn't a ParallelObject.

Parameters

tid	The thread ID
elem_to	Element to copy data to
elem_from	Element to copy data from
side	Side number (elemental material properties have this equal to zero)
n_qpoints	number of quadrature points to work with

Definition at line 436 of file MaterialPropertyStorage.C.

{
  copy(tid, &elem_to, &elem_from, side, n_qpoints);
}

Referenced by MaterialData::copy(), and copy().

copy() [2/2]

void MaterialPropertyStorage::copy	(	const THREAD_ID	tid,
		const Elem *	elem_to,
		const Elem *	elem_from,
		unsigned int	side,
		unsigned int	n_qpoints
	)

Copy material properties from elem_from to elem_to.

Similar to the other method but using pointers to elements instead of references.

Parameters

tid	The thread ID
elem_to	Pointer to the element to copy data to
elem_from	Pointer to the element to copy data from
side	Side number (elemental material properties have this equal to zero)
n_qpoints	number of quadrature points to work with

Definition at line 446 of file MaterialPropertyStorage.C.

{
  auto to_props = initProps(tid, elem_to, side, n_qpoints);
 
  for (const auto state : stateIndexRange())
  {
    const auto & from_props = props(elem_from, side, state);
    for (const auto i : index_range(_stateful_prop_id_to_prop_id))
      for (const auto qp : make_range(n_qpoints))
        (*to_props[state])[i].qpCopy(qp, from_props[i], qp);
  }
}

eraseProperty()

void MaterialPropertyStorage::eraseProperty

(

const Elem *

elem

)

Remove the property storage and element pointer from internal data structures Use this when elements are deleted so we don't end up with invalid elem pointers (for e.g.

stateful properties) hanging around in our data structures

Definition at line 76 of file MaterialPropertyStorage.C.

{
  for (const auto state : stateIndexRange())
    setProps(state).erase(elem);
}

Referenced by MaterialData::eraseProperty(), and FEProblemBase::meshChanged().

getConsumers()

const std::set< const MooseObject * > & MaterialPropertyStorage::getConsumers

(

Moose::MaterialDataType

type

)

const

Returns

The consumers of storage of type type

Definition at line 108 of file MaterialPropertyStorage.C.

{
  static const std::set<const MooseObject *> empty;
 
  const auto it = _consumers.find(type);
 
  if (it != _consumers.end())
    return it->second;
 
  return empty;
}

Referenced by FEProblemBase::getMaterialPropertyStorageConsumers().

getMaterialData() [1/2]

MaterialData & MaterialPropertyStorage::getMaterialData ( const THREAD_ID  tid )

inline

Definition at line 332 of file MaterialPropertyStorage.h.

{ return _material_data[tid]; }

getMaterialData() [2/2]

const MaterialData & MaterialPropertyStorage::getMaterialData ( const THREAD_ID  tid ) const

inline

Returns

The MaterialData for thread tid

Definition at line 331 of file MaterialPropertyStorage.h.

{ return _material_data[tid]; }

Referenced by FEProblemBase::getMaterialData(), ComputeMaterialsObjectThread::onBoundary(), ComputeMaterialsObjectThread::onElement(), ComputeMaterialsObjectThread::onInterface(), ComputeMaterialsObjectThread::onInternalSide(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), FEProblemBase::reinitMaterialsNeighbor(), FEProblemBase::swapBackMaterials(), FEProblemBase::swapBackMaterialsFace(), and FEProblemBase::swapBackMaterialsNeighbor().

getMaterialPropertyRegistry()

const MaterialPropertyRegistry & MaterialPropertyStorage::getMaterialPropertyRegistry ( ) const

inline

Definition at line 285 of file MaterialPropertyStorage.h.

{ return _registry; }

Referenced by MaterialData::getPropertyId().

getPropRecord()

const MaterialPropertyStorage::PropRecord & MaterialPropertyStorage::getPropRecord

(

const unsigned int

id

)

const

Get the property record associated with the material with id id.

Definition at line 90 of file MaterialPropertyStorage.C.

{
  mooseAssert(_prop_records.size() > id, "Invalid ID");
  auto & prop_record_ptr = _prop_records[id];
  mooseAssert(prop_record_ptr, "Not initialized");
  return *prop_record_ptr;
}

Referenced by MaterialData::getMaxStateRequested(), MaterialBase::initStatefulProperties(), initStatefulProps(), and isRestoredProperty().

hasOlderProperties()

bool MaterialPropertyStorage::hasOlderProperties ( ) const

inline

Returns

a Boolean indicating whether or not this material has older properties declared

Definition at line 246 of file MaterialPropertyStorage.h.

{ return maxState() > 1; }

hasProperty()

bool MaterialPropertyStorage::hasProperty ( const std::string &  prop_name ) const

inline

Definition at line 267 of file MaterialPropertyStorage.h.

{ return _registry.hasProperty(prop_name); }

Referenced by MaterialData::hasProperty().

hasStatefulProperties()

bool MaterialPropertyStorage::hasStatefulProperties ( ) const

inline

Returns

a Boolean indicating whether stateful properties exist on this material

Definition at line 241 of file MaterialPropertyStorage.h.

{ return maxState() > 0; }

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::advanceState(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::meshChanged(), ProjectMaterialProperties::onBoundary(), shift(), MaterialData::swap(), and MaterialData::swapBack().

initAndSetProps()

MaterialProperties & MaterialPropertyStorage::initAndSetProps ( const Elem *  elem, const unsigned int  side, const unsigned int  state  )

inlineprivate

Returns

A writeable reference to the properties for elem elem, side side, and state state.

Similar to setProps, but will initialize (default construct) the entry if it does not exist.

Definition at line 497 of file MaterialPropertyStorage.h.

{
  return setProps(state)[elem][side];
}

Referenced by initProps(), and swap().

initProps() [1/2]

std::vector< MaterialProperties * > MaterialPropertyStorage::initProps ( const THREAD_ID  tid, const Elem *  elem, unsigned int  side, unsigned int  n_qpoints  )

private

Initializes hashmap entries for element and side to proper qpoint and property count sizes.

Definition at line 537 of file MaterialPropertyStorage.C.

{
  std::vector<MaterialProperties *> props(numStates());
  for (const auto state : stateIndexRange())
    props[state] = &this->initProps(tid, state, elem, side, n_qpoints);
  return props;
}

Referenced by copy(), initProps(), initStatefulProps(), prolongStatefulProps(), restrictStatefulProps(), and updateStatefulPropsForPRefinement().

initProps() [2/2]

MaterialProperties & MaterialPropertyStorage::initProps ( const THREAD_ID  tid, const unsigned int  state, const Elem *  elem, unsigned int  side, unsigned int  n_qpoints  )

private

Initializes just one hashmap's entries.

Definition at line 549 of file MaterialPropertyStorage.C.

{
  auto & material_data = _material_data[tid];
  material_data.resize(n_qpoints);
 
  auto & mat_props = initAndSetProps(elem, side, state);
 
  // In some special cases, material_data might be larger than n_qpoints
  if (material_data.isOnlyResizeIfSmaller())
    n_qpoints = material_data.nQPoints();
 
  const auto n_props = _stateful_prop_id_to_prop_id.size();
  if (mat_props.size() < n_props)
    mat_props.resize(n_props, {});
 
  // init properties (allocate memory. etc)
  for (const auto i : index_range(_stateful_prop_id_to_prop_id))
    if (!mat_props.hasValue(i))
    {
      const auto prop_id = _stateful_prop_id_to_prop_id[i];
      mat_props.setPointer(i, material_data.props(0)[prop_id].clone(n_qpoints), {});
      mooseAssert(mat_props[i].id() == prop_id, "Inconsistent id");
    }
 
  return mat_props;
}

initStatefulProps()

void MaterialPropertyStorage::initStatefulProps	(	const THREAD_ID	tid,
		const std::vector< std::shared_ptr< MaterialBase > > &	mats,
		const unsigned int	n_qpoints,
		const Elem &	elem,
		const unsigned int	side = 0
	)

Initialize stateful material properties.

Parameters

tid	The thread ID
mats	Materials that will compute the initial values
n_qpoints	Number of quadrature points
elem	Element we are on
side	Side of the element 'elem' (0 for volumetric material properties)

If restartable stateful information is available, this will load from restart instead of calling initStatefulProperties()

Definition at line 285 of file MaterialPropertyStorage.C.

{
  // Material -> stateful properties that need to be restarted for said material
  // We need this because we need to initialize everything in dependency the dependency ordering
  // as given in mats, which means that we can't just do these all up front
  std::unordered_map<const MaterialBase *,
                     std::vector<std::pair<unsigned int, std::vector<std::stringstream> *>>>
      materials_to_restart;
  // Find the entry in the restartable data (binary data waiting to be restarted)
  // for this [elem, side], if any
  RestartableMapType::mapped_type * restartable_entry = nullptr;
  if (_restartable_map.size())
    if (auto it = _restartable_map.find(std::make_pair(&elem, side)); it != _restartable_map.end())
      restartable_entry = &it->second;
 
  // The stateful objects that we're going to initialize. This is needed for materials that are
  // passed in as mat that are not stateful, who we don't want to call initStatefulProperties() on.
  // We unfortunately can only determine this here due to block/boundary restriction, which is
  // not known without mapping property -> material
  std::vector<MaterialBase *> stateful_mats;
  // The stateful IDs that we need to copy back
  std::vector<unsigned int> stateful_ids_to_copy;
 
#ifndef NDEBUG
  // All of the stateful IDs; used to make sure that we're not supplying one property
  // across multiple materials
  std::set<unsigned int> stateful_ids;
#endif
 
  // Work through all of the materials that we were passed to figure out which ones are stateful
  // that we need to initialize, and also to figure out which ones we need to restart
  for (const auto & mat : mats)
  {
    // For keeping track of this material in stateful_mats
    bool stateful = false;
 
    // Check each material that was declared
    for (const auto id : mat->getSuppliedPropIDs())
    {
      const auto & record = getPropRecord(id);
      if (record.stateful())
      {
        const auto stateful_id = record.stateful_id;
        stateful = true;
 
#ifndef NDEBUG
        const auto it_inserted_pair = stateful_ids.insert(stateful_id);
        mooseAssert(it_inserted_pair.second,
                    "Material property '" + _registry.getName(id) +
                        "' supplied by multiple materials at the same point");
#endif
 
        bool restarting = false;
        // We have restartable data for this [elem, side]; see if we have it for this prop
        if (restartable_entry)
        {
          if (auto id_datum_pair_it = restartable_entry->find(stateful_id);
              id_datum_pair_it != restartable_entry->end())
          {
            restarting = true;
            materials_to_restart[mat.get()].emplace_back(stateful_id, &id_datum_pair_it->second);
          }
        }
 
        if (!restarting)
          stateful_ids_to_copy.push_back(record.stateful_id);
      }
    }
 
    if (stateful || mat->forceStatefulInit())
      stateful_mats.push_back(mat.get());
  }
 
  // This currently initializes all of the stateful properties for this [elem, side],
  // even though we didn't necessarily need to init all of them. Future work?
  auto props = initProps(tid, &elem, side, n_qpoints);
 
  // Whether or not we have swapped material data from _storage to _material_data
  // When we're initializing from initStatefulProperties, the MaterialBase objects
  // need to be able to access the data in _material_data. When we're initalizing
  // from restart, we need to be able to access from _storage.
  bool swapped = false;
 
  // Initialize properties
  for (auto mat : stateful_mats)
  {
    const auto materials_to_restart_find = materials_to_restart.find(mat);
    const bool restart = materials_to_restart_find != materials_to_restart.end();
 
    if (!restart || mat->forceStatefulInit())
    {
      // Need stateful _material_data in the material to store
      if (!swapped)
      {
        swap(tid, elem, side);
        swapped = true;
      }
 
      mat->initStatefulProperties(n_qpoints);
    }
 
    if (restart)
    {
      // Need data in _storage
      if (swapped)
      {
        swapBack(tid, elem, side);
        swapped = false;
      }
 
      // Load from the cached binary backup into place
      for (auto & [stateful_id, datum_ptr] : materials_to_restart_find->second)
        for (const auto state : index_range(*datum_ptr))
        {
          (*datum_ptr)[state].seekg(0, std::ios::beg);
          dataLoad((*datum_ptr)[state], (*props[state])[stateful_id], nullptr);
        }
    }
  }
 
  // Done with accessing from _material_data
  if (swapped)
    swapBack(tid, elem, side);
 
  // Copy to older states as needed, only for non-restarted data
  for (const auto stateful_id : stateful_ids_to_copy)
    for (const auto state : statefulIndexRange())
      for (const auto qp : make_range(n_qpoints))
        (*props[state])[stateful_id].qpCopy(qp, (*props[0])[stateful_id], qp);
}

Referenced by ComputeMaterialsObjectThread::onBoundary(), ComputeMaterialsObjectThread::onElement(), ComputeMaterialsObjectThread::onInterface(), and ComputeMaterialsObjectThread::onInternalSide().

isRestoredProperty()

bool MaterialPropertyStorage::isRestoredProperty

(

const std::string &

name

)

const

Returns

Whether or not the material property with name name was restored

Definition at line 99 of file MaterialPropertyStorage.C.

{
  const auto & record = getPropRecord(_registry.getID(name));
  if (!record.stateful())
    mooseAssert(!record.restored, "Stateful properties should not be restored");
  return record.restored;
}

Referenced by MaterialBase::hasRestoredProperties().

maxState()

unsigned int MaterialPropertyStorage::maxState ( ) const

inline

Returns

The current maximum stored state (0 = none, 1 = old, 2 = older)

Definition at line 302 of file MaterialPropertyStorage.h.

  {
    mooseAssert(_max_state < _storage.size(), "Too big");
    return _max_state;
  }

Referenced by addProperty(), hasOlderProperties(), hasStatefulProperties(), numStates(), and shift().

numStates()

unsigned int MaterialPropertyStorage::numStates ( ) const

inline

Returns

The number of stored states (2 = up to old, 3 = up to older)

Definition at line 310 of file MaterialPropertyStorage.h.

{ return maxState() + 1; }

Referenced by initProps(), statefulIndexRange(), and stateIndexRange().

prolongStatefulProps()

void MaterialPropertyStorage::prolongStatefulProps	(	processor_id_type	pid,
		const std::vector< std::vector< QpMap > > &	refinement_map,
		const libMesh::QBase &	qrule,
		const libMesh::QBase &	qrule_face,
		MaterialPropertyStorage &	parent_material_props,
		const THREAD_ID	tid,
		const Elem &	elem,
		const int	input_parent_side,
		const int	input_child,
		const int	input_child_side
	)

Creates storage for newly created elements from mesh Adaptivity.

Also, copies values from the parent qps to the new children.

Note - call this on the MaterialPropertyStorage object for the children that you want to project to. ie, if you are trying to project to the sides of the children, then call this on the boundary MaterialPropertyStorage. Pass in the parent MaterialPropertyStorage you are projecting from. ie the volume one if you are projecting to "internal" child element faces.

There are 3 cases here:

1. Volume to volume (parent_side = -1, child = -1, child_side = -1) Call on volume MaterialPropertyStorage and pass volume MaterialPropertyStorage for parent_material_props
2. Parent side to child side (parent_side = 0+, child = -1, child_side = 0+) where parent_side == child_side Call on boundary MaterialPropertyStorage and pass boundary MaterialPropertyStorage for parent_material_props
3. Child side to parent volume (parent_side = -1, child = 0+, child_side = 0+) Call on boundary MaterialPropertyStorage and pass volume MaterialPropertyStorage for parent_material_props

Parameters

pid	- processor id of children to prolong to
refinement_map	- 2D array of QpMap objects
qrule	The current quadrature rule
qrule_face	The current face qrule
parent_material_props	The place to pull parent material property values from
tid	The thread ID
elem	The parent element that was just refined
input_parent_side	- the side of the parent for which material properties are prolonged
input_child	- the number of the child
input_child_side	- the side on the child where material properties will be prolonged

Definition at line 166 of file MaterialPropertyStorage.C.

{
  mooseAssert(input_child != -1 || input_parent_side == input_child_side, "Invalid inputs!");
 
  unsigned int n_qpoints = 0;
 
  // If we passed in -1 for these then we really need to store properties at 0
  unsigned int parent_side = input_parent_side == -1 ? 0 : input_parent_side;
  unsigned int child_side = input_child_side == -1 ? 0 : input_child_side;
 
  if (input_child_side == -1) // Not doing side projection (ie, doing volume projection)
    n_qpoints = qrule.n_points();
  else
    n_qpoints = qrule_face.n_points();
 
  _material_data[tid].resize(n_qpoints);
 
  unsigned int n_children = elem.n_children();
 
  std::vector<unsigned int> children;
 
  if (input_child != -1) // Passed in a child explicitly
    children.push_back(input_child);
  else
  {
    children.resize(n_children);
    for (unsigned int child = 0; child < n_children; child++)
      children[child] = child;
  }
 
  for (const auto & child : children)
  {
    // If we're not projecting an internal child side, but we are projecting sides, see if this
    // child is on that side
    if (input_child == -1 && input_child_side != -1 && !elem.is_child_on_side(child, parent_side))
      continue;
 
    const Elem * child_elem = elem.child_ptr(child);
 
    // If it's not a local child then it'll be prolonged where it is
    // local
    if (child_elem->processor_id() != pid)
      continue;
 
    mooseAssert(child < refinement_map.size(), "Refinement_map vector not initialized");
    const std::vector<QpMap> & child_map = refinement_map[child];
 
    auto child_props = initProps(tid, child_elem, child_side, n_qpoints);
 
    for (const auto state : stateIndexRange())
    {
      const auto & parent_props = parent_material_props.props(&elem, parent_side, state);
      for (const auto i : index_range(_stateful_prop_id_to_prop_id))
        for (const auto qp : index_range(refinement_map[child]))
          (*child_props[state])[i].qpCopy(qp, parent_props[i], child_map[qp]._to);
    }
  }
}

Referenced by ProjectMaterialProperties::onBoundary(), ProjectMaterialProperties::onElement(), and ProjectMaterialProperties::onInternalSide().

props() [1/2]

const MaterialProperties & MaterialPropertyStorage::props ( const Elem *  elem, unsigned int  side, const unsigned int  state = 0  ) const

inline

Definition at line 481 of file MaterialPropertyStorage.h.

{
  const auto find_elem = props(state).find(elem);
  mooseAssert(find_elem != props(state).end(), "Material property does not have elem entry");
  const auto find_side = find_elem->second.find(side);
  mooseAssert(find_side != find_elem->second.end(), "Material property does not have side entry");
  return find_side->second;
}

props() [2/2]

const MaterialPropertyStorage::PropsType & MaterialPropertyStorage::props ( const unsigned int  state = 0 ) const

inline

Access methods to the stored material property data with the given state state.

Definition at line 474 of file MaterialPropertyStorage.h.

{
  mooseAssert(state < _storage.size(), "Invalid material property state " + std::to_string(state));
  return _storage[state];
}

Referenced by copy(), initProps(), initStatefulProps(), prolongStatefulProps(), props(), restrictStatefulProps(), swap(), and swapBack().

queryStatefulPropName()

std::optional< std::string > MaterialPropertyStorage::queryStatefulPropName

(

const unsigned int

id

)

const

Returns

The name of the stateful property with id id, if any.

Definition at line 68 of file MaterialPropertyStorage.C.

{
  if (_prop_records.size() > id && _prop_records[id] && _prop_records[id]->stateful())
    return _registry.getName(id);
  return {};
}

restrictStatefulProps()

void MaterialPropertyStorage::restrictStatefulProps	(	const std::vector< std::pair< unsigned int, QpMap > > &	coarsening_map,
		const std::vector< const Elem * > &	coarsened_element_children,
		const libMesh::QBase &	qrule,
		const libMesh::QBase &	qrule_face,
		const THREAD_ID	tid,
		const Elem &	elem,
		int	input_side = -1
	)

Creates storage for newly created elements from mesh Adaptivity.

Also, copies values from the children to the parent.

Parameters

coarsening_map	- map from unsigned ints to QpMap's
coarsened_element_children	- a pointer to a vector of coarsened element children
qrule	The current quadrature rule
qrule_face	The current face qrule
tid	The thread ID
elem	The parent element that was just refined
input_side	Side of the element 'elem' (0 for volumetric material properties)

Definition at line 236 of file MaterialPropertyStorage.C.

{
  unsigned int side;
 
  bool doing_a_side = input_side != -1;
 
  unsigned int n_qpoints = 0;
 
  if (!doing_a_side)
  {
    side = 0; // Use 0 for the elem
    n_qpoints = qrule.n_points();
  }
  else
  {
    side = input_side;
    n_qpoints = qrule_face.n_points();
  }
 
  auto parent_props = initProps(tid, &elem, side, n_qpoints);
 
  // Copy from the child stateful properties
  for (const auto qp : index_range(coarsening_map))
  {
    const std::pair<unsigned int, QpMap> & qp_pair = coarsening_map[qp];
    unsigned int child = qp_pair.first;
 
    mooseAssert(child < coarsened_element_children.size(),
                "Coarsened element children vector not initialized");
    const Elem * child_elem = coarsened_element_children[child];
    const QpMap & qp_map = qp_pair.second;
 
    for (const auto state : stateIndexRange())
    {
      const auto & child_props = props(child_elem, side, state);
      for (const auto i : index_range(_stateful_prop_id_to_prop_id))
        (*parent_props[state])[i].qpCopy(qp, child_props[i], qp_map._to);
    }
  }
}

Referenced by ProjectMaterialProperties::onBoundary(), and ProjectMaterialProperties::onElement().

setProps() [1/2]

MaterialProperties & MaterialPropertyStorage::setProps ( const Elem *  elem, unsigned int  side, const unsigned int  state = 0  )

inline

Definition at line 491 of file MaterialPropertyStorage.h.

{
  return const_cast<MaterialProperties &>(std::as_const(*this).props(elem, side, state));
}

Referenced by eraseProperty(), initAndSetProps(), shift(), and swapBack().

setProps() [2/2]

MaterialPropertyStorage::PropsType & MaterialPropertyStorage::setProps ( const unsigned int  state )

inlineprivate

Returns

A writeable reference to the properties at state state.

Definition at line 505 of file MaterialPropertyStorage.h.

{
  return const_cast<MaterialPropertyStorage::PropsType &>(std::as_const(*this).props(state));
}

setRecovering()

void MaterialPropertyStorage::setRecovering ( )

inline

Sets the loading of stateful material properties to recover.

This enforces the requirement of one-to-one stateful material properties, disabling advanced restart of stateful properties

Definition at line 353 of file MaterialPropertyStorage.h.

{ _recovering = true; }

setRestartInPlace()

void MaterialPropertyStorage::setRestartInPlace

(

)

Sets the loading of stateful material properties in place.

On init, this cannot be set because we must first call initProps() to properly initialize the dynamic types within _storage. After the first sweep through with initProps(), we can then load the stateful props directly in place into _storage

Also clears _restartable_map, as it should no longer be needed

Definition at line 83 of file MaterialPropertyStorage.C.

{
  _restart_in_place = true;
  _restartable_map.clear();
}

shallowSwapData()

void MaterialPropertyStorage::shallowSwapData ( const std::vector< unsigned int > &  stateful_prop_ids, MaterialProperties &  data, MaterialProperties &  data_from  )

staticprivate

Shallow copies of material properties.

Definition at line 38 of file MaterialPropertyStorage.C.

{
  for (const auto i : make_range(std::min(stateful_prop_ids.size(), data_from.size())))
    if (stateful_prop_ids[i] < data.size() && data.hasValue(stateful_prop_ids[i]) &&
        data_from.hasValue(i))
    {
      auto & prop = data[stateful_prop_ids[i]];
      auto & prop_from = data_from[i];
      prop.swap(prop_from);
    }
}

Referenced by swap().

shallowSwapDataBack()

void MaterialPropertyStorage::shallowSwapDataBack ( const std::vector< unsigned int > &  stateful_prop_ids, MaterialProperties &  data, MaterialProperties &  data_from  )

staticprivate

Definition at line 53 of file MaterialPropertyStorage.C.

{
  for (const auto i : make_range(std::min(stateful_prop_ids.size(), data.size())))
    if (stateful_prop_ids[i] < data_from.size() && data.hasValue(i) &&
        data_from.hasValue(stateful_prop_ids[i]))
    {
      auto & prop = data[i];
      auto & prop_from = data_from[stateful_prop_ids[i]];
      prop.swap(prop_from);
    }
}

Referenced by swapBack().

shift()

void MaterialPropertyStorage::shift

(

)

Shift the material properties in time.

Old material properties become older, current material properties become old. Older material properties are reused for computing current properties. This is called when solve succeeded.

Shift properties back in time and reuse older data for current (save reallocations etc.) With current, old, and older this can be accomplished by two swaps: older <-> old old <-> current

Definition at line 421 of file MaterialPropertyStorage.C.

{
  mooseAssert(hasStatefulProperties(), "Doesn't have stateful props");
 
  for (unsigned int state = maxState(); state != 0; state--)
    std::swap(setProps(state), setProps(state - 1));
}

Referenced by FEProblemBase::advanceState().

sizeProps()

void MaterialPropertyStorage::sizeProps ( MaterialProperties &  mp, unsigned int  size  )

protected

statefulIndexRange()

libMesh::IntRange< unsigned int > MaterialPropertyStorage::statefulIndexRange ( ) const

inline

Returns

A range over stateful states to be used in range-based for loops

Will be an empty range if there are no stateful states

Definition at line 323 of file MaterialPropertyStorage.h.

  {
    return libMesh::IntRange<unsigned int>(1, numStates());
  }

Referenced by initStatefulProps().

statefulProps()

const std::vector< unsigned int > & MaterialPropertyStorage::statefulProps ( ) const

inline

Definition at line 283 of file MaterialPropertyStorage.h.

{ return _stateful_prop_id_to_prop_id; }

stateIndexRange()

libMesh::IntRange< unsigned int > MaterialPropertyStorage::stateIndexRange ( ) const

inline

Returns

A range over states to be used in range-based for loops

Definition at line 314 of file MaterialPropertyStorage.h.

  {
    return libMesh::IntRange<unsigned int>(0, numStates());
  }

Referenced by copy(), eraseProperty(), initProps(), prolongStatefulProps(), MaterialData::resize(), restrictStatefulProps(), swap(), swapBack(), and updateStatefulPropsForPRefinement().

swap()

void MaterialPropertyStorage::swap	(	const THREAD_ID	tid,
		const Elem &	elem,
		unsigned int	side
	)

Swap (shallow copy) material properties in MaterialData and MaterialPropertyStorage Thread safe.

Parameters

tid	The thread id
elem	Element id
side	Side number (elemental material properties have this equal to zero)

Definition at line 464 of file MaterialPropertyStorage.C.

{
  Threads::spin_mutex::scoped_lock lock(this->_spin_mtx);
 
  for (const auto state : stateIndexRange())
    shallowSwapData(_stateful_prop_id_to_prop_id,
                    _material_data[tid].props(state),
                    // Would be nice to make this setProps()
                    initAndSetProps(&elem, side, state));
}

Referenced by initStatefulProps(), and MaterialData::swap().

swapBack()

void MaterialPropertyStorage::swapBack	(	const THREAD_ID	tid,
		const Elem &	elem,
		unsigned int	side
	)

Swap (shallow copy) material properties in MaterialPropertyStorage and MaterialDat Thread safe.

Parameters

tid	The thread id
elem	Element id
side	Side number (elemental material properties have this equal to zero)

Definition at line 476 of file MaterialPropertyStorage.C.

{
  Threads::spin_mutex::scoped_lock lock(this->_spin_mtx);
 
  for (const auto state : stateIndexRange())
    shallowSwapDataBack(_stateful_prop_id_to_prop_id,
                        setProps(&elem, side, state),
                        _material_data[tid].props(state));
 
  // Workaround for MOOSE difficulties in keeping materialless
  // elements (e.g. Lower D elements in Mortar code) materials
  for (const auto state : stateIndexRange())
    if (props(&elem, side, state).empty())
      setProps(state)[&elem].erase(side);
}

Referenced by initStatefulProps(), and MaterialData::swapBack().

updateStatefulPropsForPRefinement()

void MaterialPropertyStorage::updateStatefulPropsForPRefinement	(	const processor_id_type	pid,
		const std::vector< QpMap > &	p_refinement_map,
		const libMesh::QBase &	qrule,
		const libMesh::QBase &	qrule_face,
		const THREAD_ID	tid,
		const Elem &	elem,
		const int	input_side
	)

Based on the p-refinement flag of elem, either prolong (for refinement) or restrict (for coarsening) the stateful material property data.

Parameters

pid	The rank returned by the mesh. This is used to assert that we are only prolonging/restricting for elements that our process owns
p_refinement_map	A map that describes, for each quadrature point on the current level which quadrature point on the previous level it is closest to
qrule	The volumetric quadrature rule
qrule_face	The face quadrature rule
tid	The thread ID
elem	The element that was just p-refined or coarsened that we are performing material property prolongation/restriction for
input_side	Which element side we are performing material property prolongation/restriction for. Pass in -1 for doing volumetric prolongation/restriction

Definition at line 121 of file MaterialPropertyStorage.C.

{
  unsigned int n_qpoints = 0;
 
  // If we passed in -1 for these then we really need to store properties at 0
  unsigned int side = input_side == -1 ? 0 : input_side;
 
  if (input_side == -1) // Not doing side projection (ie, doing volume projection)
    n_qpoints = qrule.n_points();
  else
    n_qpoints = qrule_face.n_points();
 
  _material_data[tid].resize(n_qpoints);
 
  mooseAssert(elem.active(), "We should be doing p-refinement on active elements only");
  mooseAssert(elem.processor_id() == pid, "Prolongation should be occurring locally");
  mooseAssert(p_refinement_map.size() == n_qpoints, "Refinement map not proper size");
 
  auto current_p_level_props = initProps(tid, &elem, side, n_qpoints);
 
  for (const auto state : stateIndexRange())
    for (const auto i : index_range(_stateful_prop_id_to_prop_id))
    {
      auto & current_p_level_prop = (*current_p_level_props[state])[i];
      // We need to clone this property in order to not overwrite the values we're going to be
      // reading from
      auto previous_p_level_prop = current_p_level_prop.clone(current_p_level_prop.size());
      // Cloning, despite its name, does not copy the data. Luckily since we are about to overwrite
      // all of the current_p_level_prop data, we can just swap its data over to our
      // previous_p_level_prop
      previous_p_level_prop->swap(current_p_level_prop);
      current_p_level_prop.resize(n_qpoints);
      for (const auto qp : index_range(p_refinement_map))
        current_p_level_prop.qpCopy(qp, *previous_p_level_prop, p_refinement_map[qp]._to);
    }
}

Referenced by ProjectMaterialProperties::onBoundary(), and ProjectMaterialProperties::onElement().

Friends And Related Symbol Documentation

dataLoad

void dataLoad ( std::istream &  stream, MaterialPropertyStorage &  storage, void *  context  )

friend

Definition at line 644 of file MaterialPropertyStorage.C.

{
  storage._restartable_map.clear();
 
  const auto & registry = storage.getMaterialPropertyRegistry();
 
  std::vector<std::string> from_prop_ids_to_names;
  dataLoad(stream, from_prop_ids_to_names, nullptr);
 
  decltype(storage._stateful_prop_id_to_prop_id) from_stateful_prop_id_to_prop_id;
  dataLoad(stream, from_stateful_prop_id_to_prop_id, nullptr);
 
  decltype(storage._prop_records) from_prop_records;
  dataLoad(stream, from_prop_records, nullptr);
 
  decltype(storage.numStates()) num_states;
  dataLoad(stream, num_states, nullptr);
 
  {
    // Build maps of material object -> properties and property -> material objects
    const auto build_maps = [](const auto & prop_records, const auto & ids_to_names)
    {
      std::map<std::string, std::set<std::string>> object_to_props, prop_to_objects;
      for (const auto i : index_range(prop_records))
        if (prop_records[i] && prop_records[i]->stateful())
        {
          const auto & prop = ids_to_names[i];
          for (const auto & declarer : (*prop_records[i]).declarers)
          {
            object_to_props[declarer].insert(prop);
            prop_to_objects[prop].insert(declarer);
          }
        }
 
      return std::make_pair(std::move(object_to_props), std::move(prop_to_objects));
    };
    // Maps for the current stateful properties
    const std::vector<std::string> prop_ids_to_names(registry.idsToNamesBegin(),
                                                     registry.idsToNamesEnd());
    const auto [object_to_props, prop_to_objects] =
        build_maps(storage._prop_records, prop_ids_to_names);
    // Maps for the stored stateful properties
    const auto [from_object_to_props, from_prop_to_objects] =
        build_maps(from_prop_records, from_prop_ids_to_names);
 
    // Enforce our stateful requirements
    for (const auto & [object, props] : object_to_props)
    {
      const auto find_from_object = from_object_to_props.find(object);
 
      // We have a material object that was stored with the same name that
      // had stateful material properties. Here, we enforce that the stateful
      // properties stored match exactly the ones that we have declared in
      // the new run
      if (find_from_object != from_object_to_props.end())
      {
        const auto & from_props = find_from_object->second;
        if (props != from_props)
        {
          std::stringstream error;
          error << "The stateful material properties in " << object
                << " that are being restarted do not match the stored properties in the same "
                   "material object from the checkpoint.\n\n";
          error << "Checkpointed stateful properties:\n";
          for (const auto & prop : from_props)
            error << " - " << prop << "\n";
          error << "\nCurrent stateful properties:\n";
          for (const auto & prop : props)
            error << " - " << prop << "\n";
          mooseError(error.str());
        }
      }
      // We're recovering and we haven't found a stateful material object. We require a
      // one-to-one stateful mapping when recovering
      else if (storage._recovering)
      {
        mooseError("The ",
                   object,
                   " was stored in restart but no longer exists. This is not supported when "
                   "recovering stateful material properties.");
      }
    }
 
    // We can easily support this, but have chosen not to due to ambiguity and we
    // don't yet know how to express this ambiguity. Just removing this error
    // _should_ make it work without issue because to_stateful_ids below for this
    // property will be an empty optional, which means simply don't load it. Or,
    // we could load it into the new property.
    for (const auto & [from_prop, from_objects] : from_prop_to_objects)
      if (const auto find_objects = prop_to_objects.find(from_prop);
          find_objects != prop_to_objects.end())
        for (const auto & object : find_objects->second)
          if (!from_objects.count(object))
            mooseError(
                "The stateful material property '",
                from_prop,
                "' was declared in ",
                object,
                " but was not declared in that object on checkpoint.\n\nThis is not currently "
                "supported due to ambiguity.\n\nPlease contact the development team on "
                "GitHub if you desire this capability.");
  }
 
  std::vector<std::optional<unsigned int>> to_stateful_ids(from_stateful_prop_id_to_prop_id.size());
 
  auto & to_prop_records = storage._prop_records;
 
  // Mark everything as not restored in the event that we call this again
  for (auto & record_ptr : to_prop_records)
    if (record_ptr)
      record_ptr->restored = false;
 
  // Fill the mapping from previous ID to current stateful ID
  for (const auto from_stateful_id : index_range(from_stateful_prop_id_to_prop_id))
  {
    const auto from_prop_id = from_stateful_prop_id_to_prop_id[from_stateful_id];
 
    mooseAssert(from_prop_id < from_prop_records.size(), "Invalid record map");
    mooseAssert(from_prop_records[from_prop_id], "Not set");
    const auto & from_record = *from_prop_records[from_prop_id];
    mooseAssert(from_record.stateful(), "Not stateful");
 
    mooseAssert(from_prop_id < from_prop_ids_to_names.size(), "Invalid ID map");
    const auto & name = from_prop_ids_to_names[from_prop_id];
 
    if (const auto query_to_prop_id = registry.queryID(name))
    {
      const auto to_prop_id = *query_to_prop_id;
 
      mooseAssert(to_prop_id < to_prop_records.size(), "Invalid record map");
      mooseAssert(to_prop_records[to_prop_id], "Not set");
      auto & to_record = *to_prop_records[to_prop_id];
 
      if (to_record.stateful())
      {
        if (from_record.type != to_record.type)
          mooseError(
              "The type for the restarted stateful material property '", name, "' does not match");
 
        // I'm not sure if we need to enforce this one, but I don't want to think
        // about it deeply so we'll just make it an error until someone complains
        // we have time to think
        if (from_record.state != to_record.state)
          mooseError("The number of states for the restarted stateful material property '",
                     name,
                     "' do not match.\n\n",
                     "Checkpointed states: ",
                     from_record.state,
                     "\nCurrent states: ",
                     to_record.state);
 
        const auto to_stateful_id = storage.getPropRecord(to_prop_id).stateful_id;
        mooseAssert(to_stateful_id != invalid_uint, "Not stateful");
 
        to_stateful_ids[from_stateful_id] = to_stateful_id;
 
        // Mark that we're going to restore this property
        to_record.restored = true;
        mooseAssert(storage.isRestoredProperty(name), "Restored mismatch");
 
        if (storage._recovering)
          mooseAssert(from_stateful_id == to_stateful_id, "Does not have direct mapping");
      }
    }
  }
 
  // Load the properties
  for (const auto state : make_range(num_states))
  {
    std::size_t num_elems;
    dataLoad(stream, num_elems, nullptr);
 
    for (std::size_t i_elem = 0; i_elem < num_elems; ++i_elem)
    {
      const Elem * elem;
      dataLoad(stream, elem, context);
      mooseAssert(elem, "Null element");
 
      std::size_t num_sides;
      dataLoad(stream, num_sides, nullptr);
 
      for (std::size_t i_side = 0; i_side < num_sides; ++i_side)
      {
        unsigned int side;
        dataLoad(stream, side, nullptr);
 
        std::size_t num_props;
        dataLoad(stream, num_props, nullptr);
        mooseAssert(num_props <= to_stateful_ids.size(), "Missized map");
 
        std::size_t num_q_points;
        dataLoad(stream, num_q_points, nullptr);
 
        // Avoid multiple map lookups for entries pertaining to [elem, side]
        MaterialPropertyStorage::RestartableMapType::mapped_type * restart_entry = nullptr;
        MaterialProperties * in_place_entry = nullptr;
 
        // Load each stateful property
        for (const auto from_stateful_id : make_range(num_props))
        {
          // Load the binary data, which lets us choose in a moment whether
          // or not to load it in place or to cache it to load later
          std::stringstream data;
          dataLoad(stream, data, nullptr);
          data.seekg(0, std::ios::beg);
 
          // We have a property to load into
          if (const auto to_stateful_id_ptr = to_stateful_ids[from_stateful_id])
          {
            const auto to_stateful_id = *to_stateful_id_ptr;
 
            // Load the data directly into _storage
            if (storage._restart_in_place)
            {
              if (!in_place_entry)
                in_place_entry = &storage.setProps(elem, side, state);
 
              dataLoad(data, (*in_place_entry)[to_stateful_id], nullptr);
            }
            // Properties aren't initialized, so load the data into
            // _restartable_map to be loaded later in initStatefulProps()
            else
            {
              if (!restart_entry)
                restart_entry = &storage._restartable_map[std::make_pair(elem, side)];
 
              auto & mat_entry = (*restart_entry)[to_stateful_id];
              if (state >= mat_entry.size())
                mat_entry.resize(state + 1);
 
              mat_entry[state] = std::move(data);
            }
          }
        }
      }
    }
  }
}

Referenced by initStatefulProps().

dataStore

void dataStore ( std::ostream &  stream, MaterialPropertyStorage &  storage, void *  context  )

friend

Definition at line 581 of file MaterialPropertyStorage.C.

{
  // Store the material property ID -> name map for mapping back
  const auto & registry = storage.getMaterialPropertyRegistry();
  std::vector<std::string> ids_to_names(registry.idsToNamesBegin(), registry.idsToNamesEnd());
  dataStore(stream, ids_to_names, nullptr);
 
  // Store the stateful ID -> property ID map for mapping back
  dataStore(stream, storage._stateful_prop_id_to_prop_id, nullptr);
 
  // Store the prop -> record map
  dataStore(stream, storage._prop_records, nullptr);
 
  // Store the number of states
  auto num_states = storage.numStates();
  dataStore(stream, num_states, nullptr);
 
  // Store every property
  for (const auto state : storage.stateIndexRange())
  {
    std::size_t num_elems = storage.setProps(state).size();
    dataStore(stream, num_elems, nullptr);
 
    for (auto & elem_side_map_pair : storage.setProps(state))
    {
      const Elem * elem = elem_side_map_pair.first;
      mooseAssert(elem, "Null element");
      dataStore(stream, elem, context);
 
      auto & side_map = elem_side_map_pair.second;
      std::size_t num_sides = side_map.size();
      dataStore(stream, num_sides, nullptr);
 
      for (auto & [side, props] : side_map)
      {
        dataStore(stream, side, nullptr);
 
        std::size_t num_props = props.size();
        dataStore(stream, num_props, nullptr);
        mooseAssert(num_props > 0, "No properties");
 
        std::size_t n_q_points = 0;
        for (const auto & entry : props)
          if (entry.size() > n_q_points)
            n_q_points = entry.size();
        dataStore(stream, n_q_points, nullptr);
 
        // Here we actually store a stringstream of the data instead of the data directly, because
        // upon load we don't know if we can load it immediately into place or if we need to cache
        // it to load later. We also store it as skippable so that we can support not loading a
        // property if it no longer exists in restart
        for (auto & entry : props)
        {
          std::stringstream out;
          dataStore(out, entry, nullptr);
          dataStore(stream, out, nullptr);
        }
      }
    }
  }
}

ProjectMaterialProperties

friend class ProjectMaterialProperties

friend

Definition at line 463 of file MaterialPropertyStorage.h.

RedistributeProperties

friend class RedistributeProperties

friend

Definition at line 466 of file MaterialPropertyStorage.h.

Member Data Documentation

_consumers

std::map<Moose::MaterialDataType, std::set<const MooseObject *> > MaterialPropertyStorage::_consumers

protected

The consumers of this storage.

Definition at line 391 of file MaterialPropertyStorage.h.

Referenced by addConsumer(), and getConsumers().

_material_data

std::vector<MaterialData> MaterialPropertyStorage::_material_data

private

The threaded material data.

Definition at line 448 of file MaterialPropertyStorage.h.

Referenced by getMaterialData(), getMaterialData(), initProps(), MaterialPropertyStorage(), prolongStatefulProps(), swap(), swapBack(), and updateStatefulPropsForPRefinement().

_max_state

unsigned int MaterialPropertyStorage::_max_state

private

The maximum state (0 = current, 1 = old, 2 = older)

Definition at line 437 of file MaterialPropertyStorage.h.

Referenced by addProperty(), and maxState().

_problem

FEProblemBase& MaterialPropertyStorage::_problem

protected

Reference to the problem.

Definition at line 379 of file MaterialPropertyStorage.h.

_prop_records

std::vector<std::optional<PropRecord> > MaterialPropertyStorage::_prop_records

protected

Property records indexed by property id (may be null)

Definition at line 385 of file MaterialPropertyStorage.h.

Referenced by addProperty(), getPropRecord(), and queryStatefulPropName().

_recovering

bool MaterialPropertyStorage::_recovering

private

Whether or not we're recovering; enforces a one-to-one mapping of stateful properties.

Definition at line 460 of file MaterialPropertyStorage.h.

Referenced by setRecovering().

_registry

MaterialPropertyRegistry& MaterialPropertyStorage::_registry

private

Shared registry (across storage objects) for property names and IDs.

Definition at line 445 of file MaterialPropertyStorage.h.

Referenced by addProperty(), getMaterialPropertyRegistry(), hasProperty(), initStatefulProps(), isRestoredProperty(), and queryStatefulPropName().

_restart_in_place

bool MaterialPropertyStorage::_restart_in_place

private

Whether or not we want to restart stateful properties in place.

Definition at line 458 of file MaterialPropertyStorage.h.

Referenced by setRestartInPlace().

_restartable_map

RestartableMapType MaterialPropertyStorage::_restartable_map

private

The restartable data to be loaded in initStatefulProps() later.

Definition at line 455 of file MaterialPropertyStorage.h.

Referenced by initStatefulProps(), and setRestartInPlace().

_spin_mtx

libMesh::Threads::spin_mutex& MaterialPropertyStorage::_spin_mtx

private

Definition at line 442 of file MaterialPropertyStorage.h.

Referenced by swap(), and swapBack().

_stateful_prop_id_to_prop_id

std::vector<unsigned int> MaterialPropertyStorage::_stateful_prop_id_to_prop_id

protected

the vector of stateful property ids (the vector index is the map to stateful prop_id)

Definition at line 388 of file MaterialPropertyStorage.h.

Referenced by addProperty(), copy(), initProps(), prolongStatefulProps(), restrictStatefulProps(), statefulProps(), swap(), swapBack(), and updateStatefulPropsForPRefinement().

_storage

std::array<PropsType, MaterialData::max_state + 1> MaterialPropertyStorage::_storage

protected

The actual storage.

Definition at line 382 of file MaterialPropertyStorage.h.

Referenced by maxState(), and props().

---

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

• include/materials/MaterialPropertyStorage.h
• src/materials/MaterialPropertyStorage.C