MaterialBase.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

// MOOOSE includes
#include "MooseObject.h"
#include "BlockRestrictable.h"
#include "BoundaryRestrictable.h"
#include "SetupInterface.h"
#include "MooseVariableDependencyInterface.h"
#include "ScalarCoupleable.h"
#include "FunctionInterface.h"
#include "DistributionInterface.h"
#include "UserObjectInterface.h"
#include "TransientInterface.h"
#include "PostprocessorInterface.h"
#include "VectorPostprocessorInterface.h"
#include "DependencyResolverInterface.h"
#include "Restartable.h"
#include "MeshChangedInterface.h"
#include "OutputInterface.h"
#include "RandomInterface.h"
#include "ElementIDInterface.h"
#include "MaterialProperty.h"
#include "MaterialData.h"
#include "MathUtils.h"
#include "Assembly.h"
#include "GeometricSearchInterface.h"
#include "ADFunctorInterface.h"
#include "SolutionInvalidInterface.h"
#include "MaterialPropertyInterface.h"

#define usingMaterialBaseMembers                                                                   \
  usingMooseObjectMembers;                                                                         \
  usingTransientInterfaceMembers;                                                                  \
  using MaterialBase::_subproblem;                                                                 \
  using MaterialBase::_fe_problem;                                                                 \
  using MaterialBase::_tid;                                                                        \
  using MaterialBase::_assembly;                                                                   \
  using MaterialBase::_qp;                                                                         \
  using MaterialBase::_coord;                                                                      \
  using MaterialBase::_normals;                                                                    \
  using MaterialBase::_mesh

// forward declarations
class MaterialBase;
class MooseMesh;
class SubProblem;
class FaceInfo;
class FEProblemBase;

class MaterialBase : public MooseObject,
                     public BlockRestrictable,
                     public BoundaryRestrictable,
                     public SetupInterface,
                     public MooseVariableDependencyInterface,
                     public ScalarCoupleable,
                     public FunctionInterface,
                     public DistributionInterface,
                     public UserObjectInterface,
                     public TransientInterface,
                     public PostprocessorInterface,
                     public VectorPostprocessorInterface,
                     public DependencyResolverInterface,
                     public Restartable,
                     public MeshChangedInterface,
                     public OutputInterface,
                     public RandomInterface,
                     public ElementIDInterface,
                     protected GeometricSearchInterface,
                     protected ADFunctorInterface
{
public:
  static InputParameters validParams();

  MaterialBase(const InputParameters & parameters);

#ifdef MOOSE_KOKKOS_ENABLED

  MaterialBase(const MaterialBase & object, const Moose::Kokkos::FunctorCopy & key);
#endif

  virtual void initStatefulProperties(const unsigned int n_points);

  virtual bool isInterfaceMaterial() { return false; };

  virtual void computeProperties() = 0;

  virtual void resetProperties();

  virtual void computePropertiesAtQp(unsigned int qp);


  template <typename T>
  MaterialProperty<T> & declarePropertyByName(const std::string & prop_name)
  {
    return declareGenericPropertyByName<T, false>(prop_name);
  }
  template <typename T>
  MaterialProperty<T> & declareProperty(const std::string & name);
  template <typename T>
  ADMaterialProperty<T> & declareADPropertyByName(const std::string & prop_name)
  {
    return declareGenericPropertyByName<T, true>(prop_name);
  }
  template <typename T>
  ADMaterialProperty<T> & declareADProperty(const std::string & name);

  template <typename T, bool is_ad>
  auto & declareGenericProperty(const std::string & prop_name)
  {
    if constexpr (is_ad)
      return declareADProperty<T>(prop_name);
    else
      return declareProperty<T>(prop_name);
  }
  template <typename T, bool is_ad>
  GenericMaterialProperty<T, is_ad> & declareGenericPropertyByName(const std::string & prop_name);

  template <typename T, bool is_ad>
  const GenericMaterialProperty<T, is_ad> &
  getGenericZeroMaterialProperty(const std::string & name);
  template <typename T, bool is_ad>
  const GenericMaterialProperty<T, is_ad> &
  getGenericZeroMaterialPropertyByName(const std::string & prop_name);

  template <typename T, bool is_ad>
  const GenericMaterialProperty<T, is_ad> & getGenericZeroMaterialProperty();

  template <typename T, typename... Ts>
  const MaterialProperty<T> & getZeroMaterialProperty(Ts... args)
  {
    return getGenericZeroMaterialProperty<T, false>(args...);
  }

  template <typename T, typename... Ts>
  const MaterialProperty<T> & getZeroMaterialPropertyByName(Ts... args)
  {
    return getGenericZeroMaterialPropertyByName<T, false>(args...);
  }

  virtual const std::set<std::string> & getRequestedItems() override { return _requested_props; }

  virtual const std::set<std::string> & getSuppliedItems() override { return _supplied_props; }

  const std::set<unsigned int> & getSuppliedPropIDs() { return _supplied_prop_ids; }

  void checkStatefulSanity() const;

  std::set<OutputName> getOutputs();

  virtual bool isBoundaryMaterial() const = 0;

  virtual void subdomainSetup() override;

  virtual const std::unordered_set<unsigned int> & getMatPropDependencies() const = 0;

  bool hasStatefulProperties() const { return _has_stateful_property; }

  bool hasRestoredProperties() const;

  virtual bool ghostable() const { return false; }

  void setFaceInfo(const FaceInfo & fi) { _face_info = &fi; }

  template <typename Consumers>
  static std::deque<MaterialBase *>
  buildRequiredMaterials(const Consumers & mat_consumers,
                         const std::vector<std::shared_ptr<MaterialBase>> & mats,
                         const bool allow_stateful);

  void setActiveProperties(const std::unordered_set<unsigned int> & needed_props);

  bool forceStatefulInit() const { return _force_stateful_init; }

protected:
  virtual void computeQpProperties();

  virtual void resetQpProperties();

  virtual void initQpStatefulProperties();

  virtual const MaterialData & materialData() const = 0;
  virtual MaterialData & materialData() = 0;
  virtual Moose::MaterialDataType materialDataType() = 0;

  virtual const FEProblemBase & miProblem() const { return _fe_problem; }
  virtual FEProblemBase & miProblem() { return _fe_problem; }

  virtual const QBase & qRule() const = 0;

  bool isPropertyActive(const unsigned int prop_id) const
  {
    return _active_prop_ids.count(prop_id) > 0;
  }

  SubProblem & _subproblem;

  FEProblemBase & _fe_problem;
  THREAD_ID _tid;
  Assembly & _assembly;

  unsigned int _qp;

  const MooseArray<Real> & _coord;
  const MooseArray<Point> & _normals;

  MooseMesh & _mesh;

  const Moose::CoordinateSystemType & _coord_sys;

  std::set<std::string> _requested_props;

  std::set<std::string> _supplied_props;

  std::set<unsigned int> _supplied_prop_ids;

  std::unordered_set<unsigned int> _active_prop_ids;

  const bool _compute;

  enum QP_Data_Type
  {
    CURR,
    PREV
  };

  std::unordered_map<unsigned int, unsigned int> _props_to_min_states;

  void registerPropName(const std::string & prop_name, bool is_get, const unsigned int state);

  void checkExecutionStage();

  std::vector<unsigned int> _displacements;

  bool _has_stateful_property;

  bool _overrides_init_stateful_props = true;

  const FaceInfo * _face_info = nullptr;

  const MaterialPropertyName _declare_suffix;

private:
  void markMatPropRequested(const std::string & name);

  void storeSubdomainZeroMatProp(SubdomainID block_id, const MaterialPropertyName & name);

  void storeBoundaryZeroMatProp(BoundaryID boundary_id, const MaterialPropertyName & name);

  unsigned int getMaxQps() const;

  const bool _force_stateful_init;

  friend class FunctorMaterial;
};

template <typename T>
MaterialProperty<T> &
MaterialBase::declareProperty(const std::string & name)
{
  // Check if the supplied parameter is a valid input parameter key
  std::string prop_name = name;
  if (_pars.have_parameter<MaterialPropertyName>(name))
    prop_name = _pars.get<MaterialPropertyName>(name);

  return declarePropertyByName<T>(prop_name);
}

template <typename T, bool is_ad>
GenericMaterialProperty<T, is_ad> &
MaterialBase::declareGenericPropertyByName(const std::string & prop_name)
{
  const auto prop_name_modified =
      _declare_suffix.empty()
          ? prop_name
          : MooseUtils::join(std::vector<std::string>({prop_name, _declare_suffix}), "_");

  // Call this before so that the ID is valid
  auto & prop = materialData().declareProperty<T, is_ad>(prop_name_modified, *this);

  registerPropName(prop_name_modified, false, 0);
  return prop;
}

template <typename T, bool is_ad>
const GenericMaterialProperty<T, is_ad> &
MaterialBase::getGenericZeroMaterialProperty(const std::string & name)
{
  // Check if the supplied parameter is a valid input parameter key
  std::string prop_name = name;
  if (_pars.have_parameter<MaterialPropertyName>(name))
    prop_name = _pars.get<MaterialPropertyName>(name);

  return getGenericZeroMaterialPropertyByName<T, is_ad>(prop_name);
}

template <typename T, bool is_ad>
const GenericMaterialProperty<T, is_ad> &
MaterialBase::getGenericZeroMaterialPropertyByName(const std::string & prop_name)
{
  checkExecutionStage();
  auto & preload_with_zero = materialData().getProperty<T, is_ad>(prop_name, 0, *this);

  _requested_props.insert(prop_name);
  registerPropName(prop_name, true, 0);
  markMatPropRequested(prop_name);

  // Register this material on these blocks and boundaries as a zero property with relaxed
  // consistency checking
  for (std::set<SubdomainID>::const_iterator it = blockIDs().begin(); it != blockIDs().end(); ++it)
    storeSubdomainZeroMatProp(*it, prop_name);
  for (std::set<BoundaryID>::const_iterator it = boundaryIDs().begin(); it != boundaryIDs().end();
       ++it)
    storeBoundaryZeroMatProp(*it, prop_name);

  // set values for all qpoints to zero
  // (in multiapp scenarios getMaxQps can return different values in each app; we need the max)
  unsigned int nqp = getMaxQps();
  if (nqp > preload_with_zero.size())
    preload_with_zero.resize(nqp);
  for (unsigned int qp = 0; qp < nqp; ++qp)
    MathUtils::mooseSetToZero(preload_with_zero[qp]);

  return preload_with_zero;
}

template <typename T, bool is_ad>
const GenericMaterialProperty<T, is_ad> &
MaterialBase::getGenericZeroMaterialProperty()
{
  // static zero property storage
  static GenericMaterialProperty<T, is_ad> zero(MaterialPropertyInterface::zero_property_id);

  // resize to accomodate maximum number of qpoints
  // (in multiapp scenarios getMaxQps can return different values in each app; we need the max)
  unsigned int nqp = getMaxQps();
  if (nqp > zero.size())
    zero.resize(nqp);

  // set values for all qpoints to zero
  for (unsigned int qp = 0; qp < nqp; ++qp)
    MathUtils::mooseSetToZero(zero[qp]);

  return zero;
}

template <typename T>
ADMaterialProperty<T> &
MaterialBase::declareADProperty(const std::string & name)
{
  // Check if the supplied parameter is a valid input parameter key
  std::string prop_name = name;
  if (_pars.have_parameter<MaterialPropertyName>(name))
    prop_name = _pars.get<MaterialPropertyName>(name);

  return declareADPropertyByName<T>(prop_name);
}

template <typename Consumers>
std::deque<MaterialBase *>
MaterialBase::buildRequiredMaterials(const Consumers & mat_consumers,
                                     const std::vector<std::shared_ptr<MaterialBase>> & mats,
                                     const bool allow_stateful)
{
  std::deque<MaterialBase *> required_mats;

  std::unordered_set<unsigned int> needed_mat_props;
  for (const auto & consumer : mat_consumers)
  {
    const auto & mp_deps = consumer->getMatPropDependencies();
    needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
  }

  // A predicate of calling this function is that these materials come in already sorted by
  // dependency with the front of the container having no other material dependencies and following
  // materials potentially depending on the ones in front of them. So we can start at the back and
  // iterate forward checking whether the current material supplies anything that is needed, and if
  // not we discard it
  for (auto it = mats.rbegin(); it != mats.rend(); ++it)
  {
    auto * const mat = it->get();
    bool supplies_needed = false;

    const auto & supplied_props = mat->getSuppliedPropIDs();

    // Do O(N) with the small container
    for (const auto supplied_prop : supplied_props)
    {
      if (needed_mat_props.count(supplied_prop))
      {
        supplies_needed = true;
        break;
      }
    }

    if (!supplies_needed)
      continue;

    if (!allow_stateful && mat->hasStatefulProperties())
      ::mooseError(
          "Someone called buildRequiredMaterials with allow_stateful = false but a material "
          "dependency ",
          mat->name(),
          " computes stateful properties.");

    const auto & mp_deps = mat->getMatPropDependencies();
    needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
    required_mats.push_front(mat);
  }

  return required_mats;
}