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::Kokkos
{
 
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;
 
 
  template <typename Derived>
  KOKKOS_FUNCTION void initQpStatefulProperties(const unsigned int /* qp */,
                                                Datum & /* datum */) const
  {
    ::Kokkos::abort(
        "Default initQpStatefulProperties() should never be called. Make sure you properly "
        "redefined this method in your class without typos.");
  }
 
  template <typename Derived>
  static auto defaultInitStateful()
  {
    return &Material::initQpStatefulProperties<Derived>;
  }
 
  template <typename Derived>
  KOKKOS_FUNCTION void operator()(ElementInit, const ThreadID tid, const Derived & material) const;
  template <typename Derived>
  KOKKOS_FUNCTION void operator()(SideInit, const ThreadID tid, const Derived & material) const;
  template <typename Derived>
  KOKKOS_FUNCTION void operator()(NeighborInit, const ThreadID tid, const Derived & material) const;
  template <typename Derived>
  KOKKOS_FUNCTION void
  operator()(ElementCompute, const ThreadID tid, const Derived & material) const;
  template <typename Derived>
  KOKKOS_FUNCTION void operator()(SideCompute, const ThreadID tid, const Derived & material) const;
  template <typename Derived>
  KOKKOS_FUNCTION void
  operator()(NeighborCompute, const ThreadID tid, const Derived & material) const;
 
protected:
  void getKokkosMaterialPropertyHook(const std::string & prop_name_in,
                                     const unsigned int state) override final;
 
  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 QBase * const & _qrule;
  virtual const QBase & qRule() const override { return *_qrule; }
};
 
template <typename Derived>
KOKKOS_FUNCTION void
Material::operator()(ElementInit, const ThreadID tid, const Derived & material) const
{
  // When constant option is subdomain, elem is an arbitrary element in each subdomain, and thus
  // datum is invalid
  auto elem = kokkosElementID(tid);
 
  Datum datum(elem, libMesh::invalid_uint, kokkosAssembly(), kokkosSystems());
 
  const unsigned int num_qps = _constant_option == PropertyConstantOption::NONE ? datum.n_qps() : 1;
 
  for (unsigned int qp = 0; qp < num_qps; ++qp)
    material.template initQpStatefulProperties<Derived>(qp, datum);
}
 
template <typename Derived>
KOKKOS_FUNCTION void
Material::operator()(SideInit, const ThreadID tid, const Derived & material) const
{
  auto [elem, side] = kokkosElementSideID(tid);
 
  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());
 
  const unsigned int num_qps = _constant_option == PropertyConstantOption::NONE ? datum.n_qps() : 1;
 
  for (unsigned int qp = 0; qp < num_qps; ++qp)
    material.template initQpStatefulProperties<Derived>(qp, datum);
}
 
template <typename Derived>
KOKKOS_FUNCTION void
Material::operator()(NeighborInit, const ThreadID tid, const Derived & material) const
{
  auto [elem, side] = kokkosElementSideID(tid);
 
  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());
 
  const unsigned int num_qps = _constant_option == PropertyConstantOption::NONE ? datum.n_qps() : 1;
 
  for (unsigned int qp = 0; qp < num_qps; ++qp)
    material.template initQpStatefulProperties<Derived>(qp, datum);
}
 
template <typename Derived>
KOKKOS_FUNCTION void
Material::operator()(ElementCompute, const ThreadID tid, const Derived & material) const
{
  // When constant option is subdomain, elem is an arbitrary element in each subdomain, and thus
  // datum is invalid
  auto elem = kokkosElementID(tid);
 
  Datum datum(elem, libMesh::invalid_uint, kokkosAssembly(), kokkosSystems());
 
  const unsigned int num_qps = _constant_option == PropertyConstantOption::NONE ? datum.n_qps() : 1;
 
  for (unsigned int qp = 0; qp < num_qps; ++qp)
    material.template computeQpProperties<Derived>(qp, datum);
}
 
template <typename Derived>
KOKKOS_FUNCTION void
Material::operator()(SideCompute, const ThreadID tid, const Derived & material) const
{
  auto [elem, side] = kokkosElementSideID(tid);
 
  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());
 
  const unsigned int num_qps = _constant_option == PropertyConstantOption::NONE ? datum.n_qps() : 1;
 
  for (unsigned int qp = 0; qp < num_qps; ++qp)
    material.template computeQpProperties<Derived>(qp, datum);
}
 
template <typename Derived>
KOKKOS_FUNCTION void
Material::operator()(NeighborCompute, const ThreadID tid, const Derived & material) const
{
  auto [elem, side] = kokkosElementSideID(tid);
 
  Datum datum(elem, side, kokkosAssembly(), kokkosSystems());
 
  const unsigned int num_qps = _constant_option == PropertyConstantOption::NONE ? datum.n_qps() : 1;
 
  for (unsigned int qp = 0; qp < num_qps; ++qp)
    material.template computeQpProperties<Derived>(qp, datum);
}
 
} // namespace Moose::Kokkos