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