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

namespace Moose
{
namespace Kokkos
{

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

  NodalBC(const InputParameters & parameters);

  virtual void computeResidual() override;
  virtual void computeJacobian() override;


  KOKKOS_FUNCTION Real computeQpJacobian(const ContiguousNodeID /* node */) const { return 1; }
  KOKKOS_FUNCTION Real computeQpOffDiagJacobian(const unsigned int /* jvar */,
                                                const ContiguousNodeID /* node */) const
  {
    return 0;
  }

  KOKKOS_FUNCTION void operator()(ResidualLoop, const ThreadID tid) const;
  KOKKOS_FUNCTION void operator()(JacobianLoop, const ThreadID tid) const;
  KOKKOS_FUNCTION void operator()(OffDiagJacobianLoop, const ThreadID tid) const;

protected:
  const VariableNodalValue _u;

private:
  const bool _default_offdiag;
};

template <typename Derived>
InputParameters
NodalBC<Derived>::validParams()
{
  InputParameters params = NodalBCBase::validParams();
  return params;
}

template <typename Derived>
NodalBC<Derived>::NodalBC(const InputParameters & parameters)
  : NodalBCBase(parameters, Moose::VarFieldType::VAR_FIELD_STANDARD),
    _u(kokkosSystems(), _var),
    _default_offdiag(&Derived::computeQpOffDiagJacobian == &NodalBC::computeQpOffDiagJacobian)
{
  addMooseVariableDependency(&_var);
}

template <typename Derived>
void
NodalBC<Derived>::computeResidual()
{
  ::Kokkos::RangePolicy<ResidualLoop, ExecSpace, ::Kokkos::IndexType<ThreadID>> policy(
      0, numKokkosBoundaryNodes());
  ::Kokkos::parallel_for(policy, *static_cast<Derived *>(this));
  ::Kokkos::fence();
}

template <typename Derived>
void
NodalBC<Derived>::computeJacobian()
{
  ::Kokkos::RangePolicy<JacobianLoop, ExecSpace, ::Kokkos::IndexType<ThreadID>> policy(
      0, numKokkosBoundaryNodes());
  ::Kokkos::parallel_for(policy, *static_cast<Derived *>(this));
  ::Kokkos::fence();

  if (!_default_offdiag)
  {
    auto & sys = kokkosSystem(_kokkos_var.sys());

    _thread.resize({sys.getCoupling(_kokkos_var.var()).size(), numKokkosBoundaryNodes()});

    ::Kokkos::RangePolicy<OffDiagJacobianLoop, ExecSpace, ::Kokkos::IndexType<ThreadID>> policy(
        0, _thread.size());
    ::Kokkos::parallel_for(policy, *static_cast<Derived *>(this));
    ::Kokkos::fence();
  }
}

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

  if (!sys.isNodalDefined(node, _kokkos_var.var()))
    return;

  Real local_re = bc->computeQpResidual(node);

  accumulateTaggedNodalResidual(false, local_re, node);
}

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

  if (!sys.isNodalDefined(node, _kokkos_var.var()))
    return;

  Real local_ke = bc->computeQpJacobian(node);

  // This initializes the row to zero except the diagonal
  accumulateTaggedNodalMatrix(false, local_ke, node, _kokkos_var.var());
}

template <typename Derived>
KOKKOS_FUNCTION void
NodalBC<Derived>::operator()(OffDiagJacobianLoop, const ThreadID tid) const
{
  auto bc = static_cast<const Derived *>(this);
  auto node = kokkosBoundaryNodeID(_thread(tid, 1));
  auto & sys = kokkosSystem(_kokkos_var.sys());
  auto jvar = sys.getCoupling(_kokkos_var.var())[_thread(tid, 0)];

  if (!sys.isNodalDefined(node, _kokkos_var.var()))
    return;

  Real local_ke = bc->computeQpOffDiagJacobian(jvar, node);

  accumulateTaggedNodalMatrix(true, local_ke, node, jvar);
}

} // namespace Kokkos
} // namespace Moose

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