KokkosMaterialBase.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 "KokkosTypes.h"
#include "KokkosMaterialPropertyValue.h"
#include "KokkosDispatcher.h"
#include "KokkosFESystem.h"

#include "MaterialBase.h"

namespace Moose::Kokkos
{

class MaterialBase : public ::MaterialBase,
                     public MeshHolder,
                     public AssemblyHolder,
                     public FESystemHolder
{
public:
  static InputParameters validParams();

  MaterialBase(const InputParameters & parameters);
  MaterialBase(const MaterialBase & object);

  // Unused for Kokkos materials because all subdomains are computed in parallel
  virtual void subdomainSetup() override final {}

  struct ElementInit
  {
  };
  struct SideInit
  {
  };
  struct NeighborInit
  {
  };
  struct ElementCompute
  {
  };
  struct SideCompute
  {
  };
  struct NeighborCompute
  {
  };

protected:
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension> declareKokkosProperty(const std::string & name,
                                                       const std::vector<unsigned int> & dims = {});
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension>
  declareKokkosOnDemandProperty(const std::string & name,
                                const std::vector<unsigned int> & dims = {});
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension>
  declareKokkosPropertyByName(const std::string & prop_name,
                              const std::vector<unsigned int> & dims = {})
  {
    return declareKokkosPropertyInternal<T, dimension>(prop_name, dims, false);
  }
  template <typename T, unsigned int dimension = 0>
  MaterialProperty<T, dimension>
  declareKokkosOnDemandPropertyByName(const std::string & prop_name,
                                      const std::vector<unsigned int> & dims = {})
  {
    return declareKokkosPropertyInternal<T, dimension>(prop_name, dims, true);
  }

  KOKKOS_FUNCTION dof_id_type numKokkosElements() const { return _element_ids.size(); }
  KOKKOS_FUNCTION dof_id_type numKokkosElementSides() const { return _element_side_ids.size(); }
  KOKKOS_FUNCTION ContiguousElementID kokkosElementID(ThreadID tid) const
  {
    return _element_ids[tid];
  }
  KOKKOS_FUNCTION auto kokkosElementSideID(ThreadID tid) const { return _element_side_ids[tid]; }

  std::unique_ptr<DispatcherBase> _init_dispatcher;
  std::unique_ptr<DispatcherBase> _compute_dispatcher;

  const PropertyConstantOption _constant_option;


  Scalar<Real> _t;
  Scalar<const Real> _t_old;
  Scalar<int> _t_step;
  Scalar<Real> _dt;
  Scalar<Real> _dt_old;

private:
  // Unused for Kokkos materials because they are hidden by Kokkos functions
  virtual void initQpStatefulProperties() override final {}
  virtual void computeQpProperties() override final {}

  void initializeMaterialRestrictable();

  template <typename T, unsigned int dimension>
  MaterialProperty<T, dimension> declareKokkosPropertyInternal(
      const std::string & prop_name, const std::vector<unsigned int> & dims, const bool on_demand);

  Array<ContiguousElementID> _element_ids;
  Array<Pair<ContiguousElementID, unsigned int>> _element_side_ids;
};

template <typename T, unsigned int dimension>
MaterialProperty<T, dimension>
MaterialBase::declareKokkosProperty(const std::string & name,
                                    const std::vector<unsigned int> & dims)
{
  std::string prop_name = name;
  if (_pars.have_parameter<MaterialPropertyName>(name))
    prop_name = _pars.get<MaterialPropertyName>(name);

  return declareKokkosPropertyByName<T, dimension>(prop_name, dims);
}

template <typename T, unsigned int dimension>
MaterialProperty<T, dimension>
MaterialBase::declareKokkosOnDemandProperty(const std::string & name,
                                            const std::vector<unsigned int> & dims)
{
  std::string prop_name = name;
  if (_pars.have_parameter<MaterialPropertyName>(name))
    prop_name = _pars.get<MaterialPropertyName>(name);

  return declareKokkosOnDemandPropertyByName<T, dimension>(prop_name, dims);
}

template <typename T, unsigned int dimension>
MaterialProperty<T, dimension>
MaterialBase::declareKokkosPropertyInternal(const std::string & prop_name,
                                            const std::vector<unsigned int> & dims,
                                            const bool on_demand)
{
  if (dims.size() != dimension)
    mooseError("The declared Kokkos material property '",
               prop_name,
               "'\nhas a different dimension (",
               dimension,
               ") with the provided dimension (",
               dims.size(),
               ").");

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

  auto prop = materialData().declareKokkosProperty<T, dimension>(
      prop_name_modified, dims, this, isBoundaryMaterial(), on_demand, _constant_option);

  registerPropName(prop_name_modified, false, 0);

  return prop;
}

} // namespace Moose::Kokkos