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"
#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::_u;
  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 node = kokkosBoundaryNodeID(tid);
  auto & sys = kokkosSystem(_kokkos_var.sys());
  auto dof = sys.getNodeLocalDofIndex(node, 0, _kokkos_var.var());

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

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

  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)