KokkosDirichletBCBase.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 "KokkosNodalBC.h"

namespace Moose
{
namespace Kokkos
{

template <typename Derived>
class DirichletBCBase : public NodalBC
{
public:
  static InputParameters validParams();

  DirichletBCBase(const InputParameters & parameters);

  virtual bool preset() const override { return _preset; }

  virtual void presetSolution(TagID tag) override;

  KOKKOS_FUNCTION void operator()(const ThreadID tid) const;

  KOKKOS_FUNCTION Real computeQpResidual(const unsigned int qp, ResidualDatum & datum) const;

private:
  const bool _preset;
  TagID _solution_tag;
};

template <typename Derived>
InputParameters
DirichletBCBase<Derived>::validParams()
{
  InputParameters params = NodalBC::validParams();
  params.addParam<bool>(
      "preset", true, "Whether or not to preset the BC (apply the value before the solve begins).");
  return params;
}

template <typename Derived>
DirichletBCBase<Derived>::DirichletBCBase(const InputParameters & parameters)
  : NodalBC(parameters), _preset(getParam<bool>("preset"))
{
}

template <typename Derived>
void
DirichletBCBase<Derived>::presetSolution(TagID tag)
{
  _solution_tag = tag;

  ::Kokkos::parallel_for(
      ::Kokkos::RangePolicy<ExecSpace, ::Kokkos::IndexType<ThreadID>>(0, numKokkosBoundaryNodes()),
      *static_cast<Derived *>(this));
}

template <typename Derived>
KOKKOS_FUNCTION void
DirichletBCBase<Derived>::operator()(const ThreadID tid) const
{
  auto bc = static_cast<const Derived *>(this);
  auto node = kokkosBoundaryNodeID(tid);
  auto & sys = kokkosSystem(_kokkos_var.sys());
  auto dof = sys.getNodeLocalDofIndex(node, _kokkos_var.var());

  if (dof == libMesh::DofObject::invalid_id)
    return;

  ResidualDatum datum(node, kokkosAssembly(), kokkosSystems(), _kokkos_var, _kokkos_var.var());

  sys.getVectorDofValue(dof, _solution_tag) = bc->computeValue(0, datum);
}

template <typename Derived>
KOKKOS_FUNCTION Real
DirichletBCBase<Derived>::computeQpResidual(const unsigned int qp, ResidualDatum & datum) const
{
  auto bc = static_cast<const Derived *>(this);

  return _u(datum, qp) - bc->computeValue(qp, datum);
}

} // namespace Kokkos
} // namespace Moose

#define usingKokkosDirichletBCBaseMembers(T)                                                       \
public:                                                                                            \
  using Moose::Kokkos::DirichletBCBase<T>::operator();                                             \
  using Moose::Kokkos::NodalBC::operator();                                                        \
                                                                                                   \
protected:                                                                                         \
  using Moose::Kokkos::NodalBC::_u