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 MooseMesh;
class MaterialBase;

namespace Moose
{
namespace 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;

struct PropRecord
{
  std::set<const ::MaterialBase *> declarers;
  std::string name;
  std::string type;
  unsigned int id = libMesh::invalid_uint;
  std::vector<unsigned int> dims;
  bool bnd = false;
};

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; }
  std::string name() const { return _record->name; }
  std::string type() const { return _record->type; }
  unsigned int dim() const { return _record->dims.size(); }
  unsigned int dim(unsigned int i) const
  {
    if (i >= dim())
      mooseError("Cannot query the size of ",
                 i,
                 "-th dimension for the ",
                 dim(),
                 "D material property '",
                 name(),
                 "'.");

    return _record->dims.at(i);
  }

  virtual std::type_index propertyType() = 0;

  virtual void init(const PropRecord & record, const StorageKey &);

  virtual void allocate(const MooseMesh & 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;

#ifdef MOOSE_KOKKOS_SCOPE

  KOKKOS_FUNCTION operator bool() const { return _id != libMesh::invalid_uint || _default; }
#endif

protected:
  const PropRecord * _record = nullptr;
  unsigned int _id = libMesh::invalid_uint;
  bool _default = false;
};

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);

  auto & operator=(const MaterialProperty<T, dimension> & property);

#ifdef MOOSE_KOKKOS_SCOPE

  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 MooseMesh & 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 const bool value = true;
};

} // namespace Kokkos
} // namespace Moose