MaterialPropertyStorage.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 "Moose.h"
#include "MooseHashing.h"
#include "HashMap.h"
#include "MaterialProperty.h"
#include "MaterialPropertyRegistry.h"
#include "MaterialData.h"
 
#include <variant>
 
// Forward declarations
class FEProblemBase;
class MaterialBase;
class QpMap;
 
// libMesh forward declarations
namespace libMesh
{
class QBase;
class Elem;
}
 
class MaterialPropertyStorage;
 
void dataStore(std::ostream & stream, MaterialPropertyStorage & storage, void * context);
void dataLoad(std::istream & stream, MaterialPropertyStorage & storage, void * context);
 
class MaterialPropertyStorage
{
public:
  MaterialPropertyStorage(MaterialPropertyRegistry & registry, FEProblemBase & problem);
 
  struct PropRecord
  {
    bool stateful() const { return state > 0; }
    std::set<std::string> declarers;
    std::string type;
    unsigned int stateful_id = invalid_uint;
    unsigned int state = 0;
    bool restored = false;
  };
 
  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);
 
  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);
 
  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);
 
  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);
 
  void shift();
 
  void copy(const THREAD_ID tid,
            const Elem & elem_to,
            const Elem & elem_from,
            unsigned int side,
            unsigned int n_qpoints);
 
  void copy(const THREAD_ID tid,
            const Elem * elem_to,
            const Elem * elem_from,
            unsigned int side,
            unsigned int n_qpoints);
 
  void swap(const THREAD_ID tid, const Elem & elem, unsigned int side);
 
  void swapBack(const THREAD_ID tid, const Elem & elem, unsigned int side);
 
  bool hasStatefulProperties() const { return maxState() > 0; }
 
  bool hasOlderProperties() const { return maxState() > 1; }
 
  typedef HashMap<const Elem *, HashMap<unsigned int, MaterialProperties>> PropsType;
 
 
  const PropsType & props(const unsigned int state = 0) const;
  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);
 
  bool hasProperty(const std::string & prop_name) const { return _registry.hasProperty(prop_name); }
 
  unsigned int addProperty(const std::string & prop_name,
                           const std::type_info & type,
                           const unsigned int state,
                           const MaterialBase * const declarer);
 
  const std::vector<unsigned int> & statefulProps() const { return _stateful_prop_id_to_prop_id; }
 
  const MaterialPropertyRegistry & getMaterialPropertyRegistry() const { return _registry; }
 
  std::optional<std::string> queryStatefulPropName(const unsigned int id) const;
 
  void eraseProperty(const Elem * elem);
 
  unsigned int maxState() const
  {
    mooseAssert(_max_state < _storage.size(), "Too big");
    return _max_state;
  }
  unsigned int numStates() const { return maxState() + 1; }
  libMesh::IntRange<unsigned int> stateIndexRange() const
  {
    return libMesh::IntRange<unsigned int>(0, numStates());
  }
  libMesh::IntRange<unsigned int> statefulIndexRange() const
  {
    return libMesh::IntRange<unsigned int>(1, numStates());
  }
 
  const MaterialData & getMaterialData(const THREAD_ID tid) const { return _material_data[tid]; }
  MaterialData & getMaterialData(const THREAD_ID tid) { return _material_data[tid]; }
 
  const std::set<const MooseObject *> & getConsumers(Moose::MaterialDataType type) const;
 
  void addConsumer(Moose::MaterialDataType type, const MooseObject * object)
  {
    _consumers[type].insert(object);
  }
 
  void setRecovering() { _recovering = true; }
 
  void setRestartInPlace();
 
  const PropRecord & getPropRecord(const unsigned int id) const;
 
  bool isRestoredProperty(const std::string & name) const;
 
protected:
  FEProblemBase & _problem;
 
  std::array<PropsType, MaterialData::max_state + 1> _storage;
 
  std::vector<std::optional<PropRecord>> _prop_records;
 
  std::vector<unsigned int> _stateful_prop_id_to_prop_id;
 
  std::map<Moose::MaterialDataType, std::set<const MooseObject *>> _consumers;
 
  void sizeProps(MaterialProperties & mp, unsigned int size);
 
private:
  std::vector<MaterialProperties *>
  initProps(const THREAD_ID tid, const Elem * elem, unsigned int side, unsigned int n_qpoints);
 
  MaterialProperties & initProps(const THREAD_ID tid,
                                 const unsigned int state,
                                 const Elem * elem,
                                 unsigned int side,
                                 unsigned int n_qpoints);
 
 
  static void shallowSwapData(const std::vector<unsigned int> & stateful_prop_ids,
                              MaterialProperties & data,
                              MaterialProperties & data_from);
  static void shallowSwapDataBack(const std::vector<unsigned int> & stateful_prop_ids,
                                  MaterialProperties & data,
                                  MaterialProperties & data_from);
 
  PropsType & setProps(const unsigned int state);
 
  MaterialProperties &
  initAndSetProps(const Elem * elem, const unsigned int side, const unsigned int state);
 
  unsigned int _max_state;
 
  // You'd think a private mutex would work here, so I'll leave this
  // in the namespace for when that happens, but CI thinks that can
  // make us crash, so I'll just initialize this to Threads::spin_mtx
  libMesh::Threads::spin_mutex & _spin_mtx;
 
  MaterialPropertyRegistry & _registry;
 
  std::vector<MaterialData> _material_data;
 
  typedef std::unordered_map<std::pair<const Elem *, unsigned int>,
                             std::map<unsigned int, std::vector<std::stringstream>>>
      RestartableMapType;
 
  RestartableMapType _restartable_map;
 
  bool _restart_in_place;
  bool _recovering;
 
  // Need to be able to eraseProperty from here
  friend class ProjectMaterialProperties;
 
  // Need to be able to initProps from here
  friend class RedistributeProperties;
 
  // Need non-const props from here
  friend void dataLoad(std::istream &, MaterialPropertyStorage &, void *);
  friend void dataStore(std::ostream &, MaterialPropertyStorage &, void *);
};
 
inline const MaterialPropertyStorage::PropsType &
MaterialPropertyStorage::props(const unsigned int state) const
{
  mooseAssert(state < _storage.size(), "Invalid material property state " + std::to_string(state));
  return _storage[state];
}
 
inline const MaterialProperties &
MaterialPropertyStorage::props(const Elem * elem, unsigned int side, const unsigned int state) const
{
  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;
}
 
inline MaterialProperties &
MaterialPropertyStorage::setProps(const Elem * elem, unsigned int side, const unsigned int state)
{
  return const_cast<MaterialProperties &>(std::as_const(*this).props(elem, side, state));
}
 
inline MaterialProperties &
MaterialPropertyStorage::initAndSetProps(const Elem * elem,
                                         unsigned int side,
                                         const unsigned int state)
{
  return setProps(state)[elem][side];
}
 
inline MaterialPropertyStorage::PropsType &
MaterialPropertyStorage::setProps(const unsigned int state)
{
  return const_cast<MaterialPropertyStorage::PropsType &>(std::as_const(*this).props(state));
}
 
void dataStore(std::ostream & stream, MaterialPropertyStorage::PropRecord & record, void * context);
void dataLoad(std::istream & stream, MaterialPropertyStorage::PropRecord & record, void * context);