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
  {
    static const std::type_index type = typeid(*this);

    return type;
  }

  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