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

// initQpStatefulProperties() and computeQpProperties() are intentionally hidden
// but some compilers generate ugly warnings

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Woverloaded-virtual"
#elif defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
#endif

#include "KokkosMaterialBase.h"
#include "KokkosDatum.h"

#include "Coupleable.h"
#include "MaterialPropertyInterface.h"

namespace Moose
{
namespace Kokkos
{

template <typename Derived>
class Material : public MaterialBase, public Coupleable, public MaterialPropertyInterface
{
public:
  static InputParameters validParams();

  Material(const InputParameters & parameters);

  Material(const Material & object);

  virtual void initStatefulProperties(unsigned int) override;
  virtual void computeProperties() override;


  KOKKOS_FUNCTION void initQpStatefulProperties(const unsigned int /* qp */,
                                                Datum & /* datum */) const
  {
  }

  KOKKOS_FUNCTION void operator()(ElementInit, const ThreadID tid) const;
  KOKKOS_FUNCTION void operator()(SideInit, const ThreadID tid) const;
  KOKKOS_FUNCTION void operator()(NeighborInit, const ThreadID tid) const;
  KOKKOS_FUNCTION void operator()(ElementCompute, const ThreadID tid) const;
  KOKKOS_FUNCTION void operator()(SideCompute, const ThreadID tid) const;
  KOKKOS_FUNCTION void operator()(NeighborCompute, const ThreadID tid) const;

protected:
  template <typename T, unsigned int dimension = 0, unsigned int state = 0>
  MaterialProperty<T, dimension> getKokkosMaterialPropertyByName(const std::string & prop_name_in);
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension> getKokkosMaterialPropertyOldByName(const std::string & prop_name)
  {
    return getKokkosMaterialPropertyByName<T, dimension, 1>(prop_name);
  }
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension> getKokkosMaterialPropertyOlderByName(const std::string & prop_name)
  {
    return getKokkosMaterialPropertyByName<T, dimension, 2>(prop_name);
  }
  template <typename T, unsigned int dimension = 0, unsigned int state = 0>
  MaterialProperty<T, dimension> getKokkosMaterialProperty(const std::string & name)
  {
    return getKokkosMaterialPropertyByName<T, dimension, state>(getMaterialPropertyName(name));
  }
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension> getKokkosMaterialPropertyOld(const std::string & name)
  {
    return getKokkosMaterialPropertyByName<T, dimension, 1>(getMaterialPropertyName(name));
  }
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension> getKokkosMaterialPropertyOlder(const std::string & name)
  {
    return getKokkosMaterialPropertyByName<T, dimension, 2>(getMaterialPropertyName(name));
  }

  virtual void checkMaterialProperty(const std::string & name, const unsigned int state) override
  {
    // Avoid performing duplicate checks for triple block/face/neighbor materials
    if (boundaryRestricted() || !_bnd)
      MaterialPropertyInterface::checkMaterialProperty(name, state);
  }

  virtual bool isBoundaryMaterial() const override { return _bnd; }

  virtual const std::unordered_set<unsigned int> & getMatPropDependencies() const override
  {
    return MaterialPropertyInterface::getMatPropDependencies();
  }

  virtual const MaterialData & materialData() const override { return _material_data; }
  virtual MaterialData & materialData() override { return _material_data; }
  virtual MaterialDataType materialDataType() override { return _material_data_type; }

  const bool _bnd;
  const bool _neighbor;

private:
  const bool _default_init;

  const QBase * const & _qrule;
  virtual const QBase & qRule() const override { return *_qrule; }
};

template <typename Derived>
InputParameters
Material<Derived>::validParams()
{
  InputParameters params = MaterialBase::validParams();
  params += MaterialPropertyInterface::validParams();
  params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
  return params;
}

template <typename Derived>
Material<Derived>::Material(const InputParameters & parameters)
  : MaterialBase(parameters),
    Coupleable(this, false),
    MaterialPropertyInterface(this, blockIDs(), boundaryIDs()),
    _bnd(_material_data_type != Moose::BLOCK_MATERIAL_DATA),
    _neighbor(_material_data_type == Moose::NEIGHBOR_MATERIAL_DATA),
    _default_init(&Derived::initQpStatefulProperties == &Material::initQpStatefulProperties),
    _qrule(_bnd ? (_neighbor ? _subproblem.assembly(_tid, 0).qRuleNeighbor()
                             : _subproblem.assembly(_tid, 0).qRuleFace())
                : _subproblem.assembly(_tid, 0).qRule())
{
  for (auto coupled_var : getCoupledMooseVars())
    addMooseVariableDependency(coupled_var);
}

template <typename Derived>
Material<Derived>::Material(const Material & object)
  : MaterialBase(object),
    Coupleable(object, {}),
    MaterialPropertyInterface(object, {}),
    _bnd(object._bnd),
    _neighbor(object._neighbor),
    _default_init(object._default_init),
    _qrule(object._qrule)
{
}

template <typename Derived>
void
Material<Derived>::initStatefulProperties(unsigned int)
{
  if (_default_init)
    return;

  if (!_bnd && !_neighbor)
    ::Kokkos::parallel_for(
        ::Kokkos::RangePolicy<ElementInit, ExecSpace, ::Kokkos::IndexType<ThreadID>>(
            0, numKokkosElements()),
        *static_cast<Derived *>(this));
  else if (_bnd && !_neighbor)
    ::Kokkos::parallel_for(
        ::Kokkos::RangePolicy<SideInit, ExecSpace, ::Kokkos::IndexType<ThreadID>>(
            0, numKokkosElementSides()),
        *static_cast<Derived *>(this));
  else
    ::Kokkos::parallel_for(
        ::Kokkos::RangePolicy<NeighborInit, ExecSpace, ::Kokkos::IndexType<ThreadID>>(
            0, numKokkosElementSides()),
        *static_cast<Derived *>(this));

  ::Kokkos::fence();
}

template <typename Derived>
void
Material<Derived>::computeProperties()
{
  if (!_bnd && !_neighbor)
    ::Kokkos::parallel_for(
        ::Kokkos::RangePolicy<ElementCompute, ExecSpace, ::Kokkos::IndexType<ThreadID>>(
            0, numKokkosElements()),
        *static_cast<Derived *>(this));
  else if (_bnd && !_neighbor)
    ::Kokkos::parallel_for(
        ::Kokkos::RangePolicy<SideCompute, ExecSpace, ::Kokkos::IndexType<ThreadID>>(
            0, numKokkosElementSides()),
        *static_cast<Derived *>(this));
  else
    ::Kokkos::parallel_for(
        ::Kokkos::RangePolicy<NeighborCompute, ExecSpace, ::Kokkos::IndexType<ThreadID>>(
            0, numKokkosElementSides()),
        *static_cast<Derived *>(this));

  ::Kokkos::fence();
}

template <typename Derived>
KOKKOS_FUNCTION void
Material<Derived>::operator()(ElementInit, const ThreadID tid) const
{
  auto material = static_cast<const Derived *>(this);
  auto elem = kokkosElementID(tid);

  Datum datum(elem, kokkosAssembly(), kokkosSystems());

  for (unsigned int qp = 0; qp < datum.n_qps(); qp++)
  {
    datum.reinit();
    material->initQpStatefulProperties(qp, datum);
  }
}

template <typename Derived>
KOKKOS_FUNCTION void
Material<Derived>::operator()(SideInit, const ThreadID tid) const
{
  auto material = static_cast<const Derived *>(this);
  auto [elem, side] = kokkosElementSideID(tid);

  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());

  for (unsigned int qp = 0; qp < datum.n_qps(); qp++)
  {
    datum.reinit();
    material->initQpStatefulProperties(qp, datum);
  }
}

template <typename Derived>
KOKKOS_FUNCTION void
Material<Derived>::operator()(NeighborInit, const ThreadID tid) const
{
  auto material = static_cast<const Derived *>(this);
  auto [elem, side] = kokkosElementSideID(tid);

  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());

  for (unsigned int qp = 0; qp < datum.n_qps(); qp++)
  {
    datum.reinit();
    material->initQpStatefulProperties(qp, datum);
  }
}

template <typename Derived>
KOKKOS_FUNCTION void
Material<Derived>::operator()(ElementCompute, const ThreadID tid) const
{
  auto material = static_cast<const Derived *>(this);
  auto elem = kokkosElementID(tid);

  Datum datum(elem, kokkosAssembly(), kokkosSystems());

  for (unsigned int qp = 0; qp < datum.n_qps(); qp++)
  {
    datum.reinit();
    material->computeQpProperties(qp, datum);
  }
}

template <typename Derived>
KOKKOS_FUNCTION void
Material<Derived>::operator()(SideCompute, const ThreadID tid) const
{
  auto material = static_cast<const Derived *>(this);
  auto [elem, side] = kokkosElementSideID(tid);

  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());

  for (unsigned int qp = 0; qp < datum.n_qps(); qp++)
  {
    datum.reinit();
    material->computeQpProperties(qp, datum);
  }
}

template <typename Derived>
KOKKOS_FUNCTION void
Material<Derived>::operator()(NeighborCompute, const ThreadID tid) const
{
  auto material = static_cast<const Derived *>(this);
  auto [elem, side] = kokkosElementSideID(tid);

  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());

  for (unsigned int qp = 0; qp < datum.n_qps(); qp++)
  {
    datum.reinit();
    material->computeQpProperties(qp, datum);
  }
}

template <typename Derived>
template <typename T, unsigned int dimension, unsigned int state>
MaterialProperty<T, dimension>
Material<Derived>::getKokkosMaterialPropertyByName(const std::string & prop_name_in)
{
  MaterialBase::checkExecutionStage();

  const auto prop_name =
      _get_suffix.empty()
          ? prop_name_in
          : MooseUtils::join(std::vector<std::string>({prop_name_in, _get_suffix}), "_");

  if constexpr (state == 0)
    _requested_props.insert(prop_name);

  auto prop =
      MaterialPropertyInterface::getKokkosMaterialPropertyByName<T, dimension, state>(prop_name);

  registerPropName(prop_name, true, state);

  return prop;
}

} // namespace Kokkos
} // namespace Moose