BatchMaterial.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "ElementUserObject.h"

#include "libmesh/int_range.h"

#include <tuple>
#include <string>
#include <vector>
#include <utility>

namespace BatchMaterialUtils
{

// type wrappers
template <typename T, unsigned int state>
struct GatherMatPropTempl
{
  typedef T type;
  typedef const MaterialProperty<T> gather_type;

  template <typename M>
  static gather_type * getPointer(M & mpi, const MaterialPropertyName & name)
  {
    return &mpi.template getGenericMaterialProperty<T, false>(name, state);
  }
};

template <typename T>
using GatherMatProp = GatherMatPropTempl<T, 0>;
template <typename T>
using GatherMatPropOld = GatherMatPropTempl<T, 1>;

struct GatherVariable
{
  typedef Real type;
  typedef const VariableValue gather_type;

  template <typename C>
  static gather_type * getPointer(const C & coupleable, const VariableName & name)
  {
    return &coupleable.coupledValue(name);
  }
};

struct GatherVariableOld
{
  typedef Real type;
  typedef const VariableValue gather_type;

  template <typename C>
  static gather_type * getPointer(const C & coupleable, const VariableName & name)
  {
    return &coupleable.coupledValueOld(name);
  }
};

// tuple wrappers
struct TupleStd
{
  // the tuple type
  template <typename... Args>
  using type = std::tuple<Args...>;

  // the element access function
  template <int N, typename T>
  static auto & get(T && t)
  {
    return std::get<N>(t);
  }

  // tuple size (number of elements)
  template <typename T>
  using size = std::tuple_size<T>;

  // element type access
  template <int I, typename T>
  using element = typename std::tuple_element<I, T>::type;
};
}

template <typename Tuple, typename Output, typename... Input>
class BatchMaterial : public ElementUserObject
{
  typedef BatchMaterial<Tuple, Output, Input...> BatchMaterialType;

  template <int I, typename T, typename... Names>
  void construct(T && name, Names &&... names);

  template <int I>
  void copy(const unsigned int nqp);

public:
  static InputParameters validParams() { return ElementUserObject::validParams(); }

  template <typename... Names>
  BatchMaterial(const InputParameters & params, Names &&... names)
    : ElementUserObject(params), _output_ready(false)
  {
    construct<0, Names...>(std::forward<Names>(names)...);
  }

  virtual void batchCompute() = 0;

  typedef Output OutputType;
  typedef std::vector<OutputType> OutputVector;

  typedef typename Tuple::template type<typename Input::type...> InputType;
  typedef std::vector<InputType> InputVector;

  const OutputVector & getOutputData() const { return _output_data; }

  OutputVector & setOutputData() { return _output_data; }

  const InputVector & getInputData() const { return _input_data; }

  bool outputReady() const { return _output_ready; }

  std::size_t getIndex(dof_id_type elem_id) const;

  void initialize() override final;

  void execute() override final;

  void threadJoin(const UserObject & uo) override final;

  void finalize() override final;

  InputVector _input_data;

  OutputVector _output_data;

  // use regular tuple for the Moose pointers
  std::tuple<typename Input::gather_type *...> _input_ptr;

  std::size_t _index;

  std::map<dof_id_type, std::size_t> _index_map;

  friend struct BatchMaterialUtils::GatherVariable;

  friend struct BatchMaterialUtils::GatherVariableOld;

protected:
  virtual bool shouldCompute() { return true; }

private:
  bool _output_ready;
};

template <typename Tuple, typename Output, typename... Input>
template <int I, typename T, typename... Names>
void
BatchMaterial<Tuple, Output, Input...>::construct(T && name, Names &&... names)
{
  // couple the variable or material property
  typedef typename std::tuple_element<I, std::tuple<Input...>>::type CurrentElement;
  std::get<I>(_input_ptr) = CurrentElement::getPointer(*this, name);

  // recursively couple the next variable or material property
  if constexpr (sizeof...(Names) > 0)
    construct<I + 1, Names...>(std::forward<Names>(names)...);
}

template <typename Tuple, typename Output, typename... Input>
template <int I>
void
BatchMaterial<Tuple, Output, Input...>::copy(const unsigned int nqp)
{
  // copy all qp values for the current item
  for (const auto qp : make_range(nqp))
    Tuple::template get<I>(_input_data[_index + qp]) = (*std::get<I>(_input_ptr))[qp];

  // proceed to next item
  if constexpr (I + 1 < sizeof...(Input))
    copy<I + 1>(nqp);
}

template <typename Tuple, typename Output, typename... Input>
std::size_t
BatchMaterial<Tuple, Output, Input...>::getIndex(dof_id_type elem_id) const
{
  const auto it = _index_map.find(elem_id);
  if (it == _index_map.end())
    mooseError("Element ", elem_id, " was not found in the index map for ", name(), ".");
  return it->second;
}

template <typename Tuple, typename Output, typename... Input>
void
BatchMaterial<Tuple, Output, Input...>::initialize()
{
  _index = 0;

  if (shouldCompute())
    _output_ready = false;
}

template <typename Tuple, typename Output, typename... Input>
void
BatchMaterial<Tuple, Output, Input...>::execute()
{
  if (!shouldCompute())
    return;

  // update index map
  _index_map[_current_elem->id()] = _index;

  // make sure the input data is sized sufficiently big
  const auto nqp = _qrule->n_points();
  if (_input_data.size() < _index + nqp)
    _input_data.resize(_index + nqp);

  // copy data
  copy<0>(nqp);
  _index += nqp;
}

template <typename Tuple, typename Output, typename... Input>
void
BatchMaterial<Tuple, Output, Input...>::threadJoin(const UserObject & uo)
{
  if (!shouldCompute())
    return;

  // join maps (with index shift)
  const auto & bm = static_cast<const BatchMaterialType &>(uo);
  for (const auto & [id, index] : bm._index_map)
    _index_map[id] = index + _index;

  // make sure we have enough space
  const auto capacity = _input_data.capacity();
  if (capacity < _index + bm._index)
    _input_data.reserve(_index + bm._index);

  // concatenate input data
  _input_data.insert(std::begin(_input_data) + _index,
                     std::begin(bm._input_data),
                     std::begin(bm._input_data) + bm._index);
  _index += bm._index;
}

template <typename Tuple, typename Output, typename... Input>
void
BatchMaterial<Tuple, Output, Input...>::finalize()
{
  if (!shouldCompute())
    return;

  // resize the input and output data blocks to contain just the gathered items
  // (should be a no-op mostly)
  _input_data.resize(_index);
  _output_data.resize(_index);
  batchCompute();

  _output_ready = true;
}