MaterialData.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
 
#ifdef MOOSE_KOKKOS_ENABLED
#include "KokkosMaterialProperty.h"
#endif
 
#include "MaterialProperty.h"
#include "Moose.h"
#include "MooseUtils.h"
 
// libMesh
#include "libmesh/elem.h"
 
#include <vector>
#include <memory>
#include <typeinfo>
 
class MaterialPropertyStorage;
class MooseObject;
class Material;
class XFEM;
class MaterialBase;
 
class MaterialData
{
public:
  MaterialData(MaterialPropertyStorage & storage, const THREAD_ID tid);
 
  static constexpr unsigned int max_state = 2;
 
  void resize(unsigned int n_qpoints);
 
  unsigned int nQPoints() const { return _n_qpoints; }
 
  void copy(const Elem & elem_to, const Elem & elem_from, unsigned int side);
 
  void swap(const Elem & elem, unsigned int side = 0);
 
  template <typename MatContainer>
  void reinit(const MatContainer & mats);
 
  void reset(const std::vector<std::shared_ptr<MaterialBase>> & mats);
 
  void swapBack(const Elem & elem, unsigned int side = 0);
 
  const MaterialProperties & props(const unsigned int state = 0) const;
  MaterialProperties & props(const unsigned int state = 0);
 
  template <typename T, bool is_ad>
  bool haveGenericProperty(const std::string & prop_name) const;
 
  template <typename T>
  bool haveProperty(const std::string & prop_name) const
  {
    return haveGenericProperty<T, false>(prop_name);
  }
 
  template <typename T>
  bool haveADProperty(const std::string & prop_name) const
  {
    return haveGenericProperty<T, true>(prop_name);
  }
 
#ifdef MOOSE_KOKKOS_SCOPE
  template <typename T, unsigned int dimension>
  bool haveKokkosProperty(const std::string & prop_name) const;
#endif
 
  template <typename T, bool is_ad = false>
  GenericMaterialProperty<T, is_ad> & getProperty(const std::string & prop_name,
                                                  const unsigned int state,
                                                  const MooseObject & requestor)
  {
    return getPropertyHelper<T, is_ad, false>(prop_name, state, requestor);
  }
  template <typename T, bool is_ad>
  GenericMaterialProperty<T, is_ad> & declareProperty(const std::string & prop_name,
                                                      const MooseObject & requestor)
  {
    return getPropertyHelper<T, is_ad, true>(prop_name, 0, requestor);
  }
 
#ifdef MOOSE_KOKKOS_SCOPE
  template <typename T, unsigned int dimension, unsigned int state>
  Moose::Kokkos::MaterialProperty<T, dimension> getKokkosProperty(const std::string & prop_name);
 
  template <typename T, unsigned int dimension>
  Moose::Kokkos::MaterialProperty<T, dimension>
  declareKokkosProperty(const std::string & prop_name,
                        const std::vector<unsigned int> & dims,
                        const MaterialBase * declarer,
                        const bool bnd,
                        const bool on_demand,
                        const Moose::Kokkos::PropertyConstantOption constant_option);
#endif
 
  bool isSwapped() const { return _swapped; }
 
  const MaterialPropertyStorage & getMaterialPropertyStorage() const { return _storage; }
 
  class XFEMKey
  {
    friend class XFEM;
    XFEMKey() {}
    XFEMKey(const XFEM &) {}
  };
 
  MaterialPropertyStorage & getMaterialPropertyStorageForXFEM(const XFEMKey) { return _storage; }
 
  bool hasProperty(const std::string & prop_name) const;
 
  unsigned int getPropertyId(const std::string & prop_name) const;
 
  void onlyResizeIfSmaller(bool flag) { _resize_only_if_smaller = flag; };
 
  bool isOnlyResizeIfSmaller() const { return _resize_only_if_smaller; };
 
  void eraseProperty(const Elem * elem);
 
private:
  MaterialPropertyStorage & _storage;
 
  const THREAD_ID _tid;
 
  unsigned int _n_qpoints;
 
  std::array<MaterialProperties, max_state + 1> _props;
 
  unsigned int addPropertyHelper(const std::string & prop_name,
                                 const std::type_info & type,
                                 const unsigned int state,
                                 const MaterialBase * const declarer);
 
  template <typename T, bool is_ad, bool declare>
  GenericMaterialProperty<T, is_ad> & getPropertyHelper(const std::string & prop_name,
                                                        const unsigned int state,
                                                        const MooseObject & requestor);
 
#ifdef MOOSE_KOKKOS_ENABLED
  Moose::Kokkos::MaterialPropertyBase &
  addKokkosPropertyHelper(const std::string & prop_name,
                          const std::type_info & type,
                          const unsigned int state,
                          std::shared_ptr<Moose::Kokkos::MaterialPropertyBase> shell);
 
  Moose::Kokkos::MaterialPropertyBase &
  declareKokkosPropertyHelper(const std::string & prop_name,
                              const std::type_info & type,
                              const MaterialBase * declarer,
                              const std::vector<unsigned int> & dims,
                              const bool bnd,
                              const bool on_demand,
                              const Moose::Kokkos::PropertyConstantOption constant_option,
                              std::shared_ptr<Moose::Kokkos::MaterialPropertyBase> shell);
 
  Moose::Kokkos::MaterialPropertyBase & getKokkosPropertyHelper(
      const std::string & prop_name,
      const unsigned int state = 0,
      std::shared_ptr<Moose::Kokkos::MaterialPropertyBase> shell = nullptr) const;
 
  bool haveKokkosPropertyHelper(const std::string & prop_name) const;
  void kokkosRegisterLoadStoreHelper(std::type_index type,
                                     Moose::Kokkos::PropertyStore store,
                                     Moose::Kokkos::PropertyLoad load);
#endif
 
  static void mooseErrorHelper(const MooseObject & object, const std::string_view & error);
 
  const MaterialBase & castRequestorToDeclarer(const MooseObject & requestor) const;
 
  bool _swapped;
 
  bool _resize_only_if_smaller;
 
  unsigned int getMaxStateRequested(const unsigned int prop_id) const;
};
 
inline const MaterialProperties &
MaterialData::props(const unsigned int state) const
{
  mooseAssert(_props.size() > state, "Invalid state");
  return _props[state];
}
 
inline MaterialProperties &
MaterialData::props(const unsigned int state)
{
  mooseAssert(_props.size() > state, "Invalid state");
  return _props[state];
}
 
template <typename T, bool is_ad>
inline bool
MaterialData::haveGenericProperty(const std::string & prop_name) const
{
  if (!hasProperty(prop_name))
    return false;
 
  const auto prop_id = getPropertyId(prop_name);
  // the property id exists, but the property was not created in this instance of the material type
  if (prop_id >= props(0).size())
    return false;
 
  const PropertyValue * const base_prop = props(0).queryValue(prop_id);
  return dynamic_cast<const GenericMaterialProperty<T, is_ad> *>(base_prop) != nullptr;
}
 
template <typename T, bool is_ad, bool declare>
GenericMaterialProperty<T, is_ad> &
MaterialData::getPropertyHelper(const std::string & prop_name,
                                const unsigned int state,
                                const MooseObject & requestor)
{
  if constexpr (is_ad)
    mooseAssert(state == 0, "Cannot request/declare AD properties for states other than zero");
  if constexpr (declare)
    mooseAssert(state == 0, "Cannot declare properties for states other than zero");
 
  // Register/get the ID of the property
  const auto prop_id = addPropertyHelper(
      prop_name, typeid(T), state, declare ? &castRequestorToDeclarer(requestor) : nullptr);
  const auto size = prop_id + 1;
 
  // Initialize the states that we need
  for (const auto state_i : make_range(getMaxStateRequested(prop_id) + 1))
  {
    auto & entry = props(state_i);
    if (entry.size() < size)
      entry.resize(size, {});
    // if we are not declaring the property we initialize only what we need (the requested state)
    if (!entry.hasValue(prop_id) && (declare || state_i == state))
    {
      if (state_i == 0)
        entry.setPointer(
            prop_id, std::move(std::make_unique<GenericMaterialProperty<T, is_ad>>(prop_id)), {});
      else
        entry.setPointer(prop_id, std::move(std::make_unique<MaterialProperty<T>>(prop_id)), {});
    }
  }
 
  // Should be available now
  auto & base_prop = props(state)[prop_id];
 
  // In the event that this property was already declared/requested, make sure
  // that the types are consistent
  auto prop = dynamic_cast<GenericMaterialProperty<T, is_ad> *>(&base_prop);
  if (!prop)
  {
    constexpr std::string_view action = declare ? "declared" : "requested";
    constexpr auto is_ad_to_str = [](const bool is_ad_bool)
    { return std::string_view(is_ad_bool ? "AD" : "non-AD"); };
    constexpr std::string_view ad_type = is_ad_to_str(is_ad);
 
    std::stringstream error;
    error << "The " << action << " " << ad_type << " "
          << "material property '" + prop_name + "' of type '" << MooseUtils::prettyCppType<T>()
          << "'\nis already retrieved or declared as a " << is_ad_to_str(base_prop.isAD())
          << " property of type '" << base_prop.type() << "'.";
    mooseErrorHelper(requestor, error.str());
  }
 
  return *prop;
}
 
template <typename MatContainer>
void
MaterialData::reinit(const MatContainer & mats)
{
  for (const auto & mat : mats)
    mat->computeProperties();
}
 
#ifdef MOOSE_KOKKOS_SCOPE
template <typename T, unsigned int dimension>
bool
MaterialData::haveKokkosProperty(const std::string & prop_name) const
{
  if (!haveKokkosPropertyHelper(prop_name))
    return false;
 
  auto & prop = getKokkosPropertyHelper(prop_name);
  return dynamic_cast<Moose::Kokkos::MaterialProperty<T, dimension> *>(&prop) != nullptr;
}
 
template <typename T, unsigned int dimension, unsigned int state>
Moose::Kokkos::MaterialProperty<T, dimension>
MaterialData::getKokkosProperty(const std::string & prop_name)
{
  // Reserve the storages for the property up to the requested state
  // If the storages were already reserved, it will do nothing
  for (unsigned int s = 0; s <= state; ++s)
  {
    auto shell = std::make_shared<Moose::Kokkos::MaterialProperty<T, dimension>>();
 
    addKokkosPropertyHelper(prop_name, typeid(T), state, shell);
 
    // Only instantiate load and store functions for stateful properties to avoid requiring users
    // to provide custom dataLoad and dataStore for non-trivially-copyable types that are never
    // used as stateful properties
    if constexpr (state > 0)
      kokkosRegisterLoadStoreHelper(shell->propertyType(),
                                    Moose::Kokkos::propertyStore<T, dimension>,
                                    Moose::Kokkos::propertyLoad<T, dimension>);
  }
 
  auto & prop_base = getKokkosPropertyHelper(prop_name, state, nullptr);
  auto prop_cast = dynamic_cast<Moose::Kokkos::MaterialProperty<T, dimension> *>(&prop_base);
 
  if (!prop_cast)
    mooseError("The requested ",
               dimension,
               "D Kokkos material property '",
               prop_name,
               "' of type '",
               MooseUtils::prettyCppType<T>(),
               "' was already declared or requested as a ",
               prop_base.dim(),
               "D property of type '",
               prop_base.type(),
               "'.");
 
  return *prop_cast;
}
 
template <typename T, unsigned int dimension>
Moose::Kokkos::MaterialProperty<T, dimension>
MaterialData::declareKokkosProperty(const std::string & prop_name,
                                    const std::vector<unsigned int> & dims,
                                    const MaterialBase * declarer,
                                    const bool bnd,
                                    const bool on_demand,
                                    const Moose::Kokkos::PropertyConstantOption constant_option)
{
  auto shell = std::make_shared<Moose::Kokkos::MaterialProperty<T, dimension>>();
 
  auto & prop_base = declareKokkosPropertyHelper(
      prop_name, typeid(T), declarer, dims, bnd, on_demand, constant_option, shell);
  auto prop_cast = dynamic_cast<Moose::Kokkos::MaterialProperty<T, dimension> *>(&prop_base);
 
  if (!prop_cast)
    mooseError("The declared ",
               dimension,
               "D Kokkos material property '",
               prop_name,
               "' of type '",
               MooseUtils::prettyCppType<T>(),
               "' was already declared or requested as a ",
               prop_base.dim(),
               "D property of type '",
               prop_base.type(),
               "'.");
 
  return *prop_cast;
}
#endif