KokkosDirichletBCBase.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 "KokkosNodalBC.h"
#include "KokkosADNodalBC.h"
 
namespace Moose::Kokkos
{
 
template <bool is_ad>
class DirichletBCBaseTempl : public std::conditional_t<is_ad, ADNodalBC, NodalBC>
{
  using real_type = std::conditional_t<is_ad, ADReal, Real>;
 
public:
  static InputParameters validParams();
 
  DirichletBCBaseTempl(const InputParameters & parameters);
 
  virtual bool preset() const override { return _preset; }
 
  virtual void presetSolution(TagID tag) override;
 
  struct PresetLoop
  {
  };
 
  template <typename Derived>
  KOKKOS_FUNCTION void operator()(PresetLoop, const ThreadID tid, const Derived & bc) const;
 
  template <typename Derived>
  KOKKOS_FUNCTION auto computeQpResidual(const unsigned int qp, AssemblyDatum & datum) const;
 
  using Base = std::conditional_t<is_ad, ADNodalBC, NodalBC>;
  using Base::operator();
 
protected:
  using Base::_kokkos_var;
  using Base::_thread;
  using Base::_u;
  using Base::_vars;
  using Base::kokkosAssembly;
  using Base::kokkosBoundaryNodeID;
  using Base::kokkosSystem;
  using Base::kokkosSystems;
  using Base::numKokkosBoundaryNodes;
 
private:
  const bool _preset;
  TagID _solution_tag;
};
 
template <bool is_ad>
template <typename Derived>
KOKKOS_FUNCTION void
DirichletBCBaseTempl<is_ad>::operator()(PresetLoop, const ThreadID tid, const Derived & bc) const
{
  auto comp = _thread(tid, 0);
  auto node = kokkosBoundaryNodeID(_thread(tid, 1));
  auto & sys = kokkosSystem(_kokkos_var.sys(comp));
  auto dof = sys.getNodeLocalDofIndex(node, 0, _kokkos_var.var(comp));
 
  if (dof == libMesh::DofObject::invalid_id)
    return;
 
  AssemblyDatum datum(
      node, kokkosAssembly(), kokkosSystems(), _kokkos_var, _kokkos_var.var(comp), comp);
 
  sys.getVectorDofValue(dof, _solution_tag) = bc.computeValue(0, datum);
}
 
template <bool is_ad>
template <typename Derived>
KOKKOS_FUNCTION auto
DirichletBCBaseTempl<is_ad>::computeQpResidual(const unsigned int qp, AssemblyDatum & datum) const
{
  auto bc = static_cast<const Derived *>(this);
 
  return _u(datum, qp) - real_type(bc->computeValue(qp, datum));
}
 
typedef DirichletBCBaseTempl<false> DirichletBCBase;
typedef DirichletBCBaseTempl<true> ADDirichletBCBase;
 
} // namespace Moose::Kokkos
 
#define registerKokkosDirichletBC(app, classname)                                                  \
  registerKokkosResidualObject(app, classname);                                                    \
  registerKokkosAdditionalOperation(classname, PresetLoop)
 
#define registerKokkosADDirichletBC(app, classname)                                                \
  registerKokkosADResidualObject(app, classname);                                                  \
  registerKokkosAdditionalOperation(classname, PresetLoop)