KokkosMaterialPropertyDecl.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 "KokkosArray.h"
 
#include "MoosePassKey.h"
 
#include <typeindex>
 
class MaterialBase;
 
namespace Moose::Kokkos
{
 
class MaterialPropertyStorage;
 
using StorageKey = Moose::PassKey<MaterialPropertyStorage>;
 
template <typename T, unsigned int dimension>
class MaterialPropertyValueBase;
 
template <typename T, unsigned int dimension>
class MaterialPropertyValue;
 
class Datum;
class Assembly;
class Mesh;
 
enum class PropertyConstantOption
{
  NONE,
  ELEMENT,
  SUBDOMAIN
};
 
struct PropRecord
{
  std::set<const ::MaterialBase *> declarers;
  std::string name;
  std::string type;
  unsigned int id = libMesh::invalid_uint;
  std::unordered_map<SubdomainID, std::vector<unsigned int>> dims;
  bool bnd = false;
  bool on_demand = false;
  std::unordered_map<SubdomainID, PropertyConstantOption> constant_option;
};
 
using PropertyStore = std::function<void(std::ostream &, void *)>;
using PropertyLoad = std::function<void(std::istream &, void *)>;
 
class MaterialPropertyBase
{
public:
  MaterialPropertyBase() = default;
  virtual ~MaterialPropertyBase() {}
 
  unsigned int id() const { return _id; }
  const std::string & name() const;
  const std::string & type() const;
  unsigned int dim() const;
  unsigned int dimSize(SubdomainID subdomain, unsigned int i) const;
 
  virtual std::type_index propertyType() = 0;
 
  virtual void init(const PropRecord & record, const StorageKey &);
 
  virtual void allocate(const Mesh & mesh,
                        const Assembly & assembly,
                        const std::set<SubdomainID> & subdomains,
                        const bool bnd,
                        StorageKey) = 0;
  virtual void copy(const MaterialPropertyBase & prop, StorageKey) = 0;
  virtual void swap(MaterialPropertyBase & prop, StorageKey) = 0;
 
protected:
  const PropRecord * _record = nullptr;
  unsigned int _id = libMesh::invalid_uint;
  bool _default = false;
  Array<PropertyConstantOption> _constant_option;
};
 
inline const std::string &
MaterialPropertyBase::name() const
{
  if (!_record)
    mooseError("Cannot get the name of an uninitialized or default material property.");
  else
    return _record->name;
}
 
inline const std::string &
MaterialPropertyBase::type() const
{
  if (!_record)
    mooseError("Cannot get the type of an uninitialized or default material property.");
  else
    return _record->type;
}
 
inline unsigned int
MaterialPropertyBase::dim() const
{
  if (!_record || !_record->dims.size())
    mooseError("Cannot get the dimension of an uninitialized or default material property.");
  else
    return _record->dims.begin()->second.size();
}
 
inline unsigned int
MaterialPropertyBase::dimSize(SubdomainID subdomain, unsigned int i) const
{
  const unsigned int D = dim();
 
  if (i >= D)
    mooseError("Cannot get the size of ",
               i,
               "-th dimension for the ",
               D,
               "D material property '",
               name(),
               "'.");
 
  return libmesh_map_find(_record->dims, subdomain)[i];
}
 
template <typename T, unsigned int dimension>
void propertyStore(std::ostream & stream, void * prop);
template <typename T, unsigned int dimension>
void propertyLoad(std::istream & stream, void * prop);
 
template <typename T, unsigned int dimension = 0>
class MaterialProperty final : public MaterialPropertyBase
{
public:
  MaterialProperty() = default;
  MaterialProperty(const T & value);
  MaterialProperty(const MaterialProperty<T, dimension> & property);
  template <unsigned int D>
  MaterialProperty(const MaterialProperty<T, D> & other) = delete;
 
  auto & operator=(const MaterialProperty<T, dimension> & property);
 
#ifdef MOOSE_KOKKOS_SCOPE
  KOKKOS_FUNCTION operator bool() const { return _data.isAlloc() || _default; }
 
  KOKKOS_FUNCTION MaterialPropertyValue<T, dimension> operator()(const Datum & datum,
                                                                 const unsigned int qp) const;
#endif
 
  virtual std::type_index propertyType() override
  {
    return std::type_index(typeid(MaterialProperty<T, dimension>));
  }
 
  virtual void init(const PropRecord & record, const StorageKey & key) override;
 
#ifdef MOOSE_KOKKOS_SCOPE
  virtual void allocate(const Mesh & mesh,
                        const Assembly & assembly,
                        const std::set<SubdomainID> & subdomains,
                        const bool bnd,
                        StorageKey) override;
  virtual void copy(const MaterialPropertyBase & prop, StorageKey) override;
  virtual void swap(MaterialPropertyBase & prop, StorageKey) override;
#endif
 
private:
  void shallowCopy(const MaterialProperty<T, dimension> & property);
 
  const MaterialProperty<T, dimension> * _reference = nullptr;
  Array<Array<T, dimension + 1>> _data;
  T _value;
 
  friend class MaterialPropertyValueBase<T, dimension>;
 
  friend void propertyStore<T, dimension>(std::ostream &, void *);
  friend void propertyLoad<T, dimension>(std::istream &, void *);
};
 
// The Kokkos array containing Kokkos material properties requires a deep copy because the copy
// constructor of each Kokkos material property should be invoked
template <typename T, unsigned int dimension>
struct ArrayDeepCopy<MaterialProperty<T, dimension>>
{
  static constexpr bool value = true;
};
 
} // namespace Moose::Kokkos