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);