MaterialData.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "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);
  }

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

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

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