KokkosVectorTimeDerivative.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 "KokkosVectorTimeKernelValue.h"
 
class KokkosVectorTimeDerivative : public Moose::Kokkos::VectorTimeKernelValue
{
public:
  static InputParameters validParams();
 
  KokkosVectorTimeDerivative(const InputParameters & parameters);
 
  template <typename Derived>
  KOKKOS_FUNCTION void computeJacobianInternal(const Derived & kernel, AssemblyDatum & datum) const;
 
  template <typename Derived>
  KOKKOS_FUNCTION Moose::Kokkos::Real3 precomputeQpResidual(const unsigned int qp,
                                                            AssemblyDatum & datum) const;
  template <typename Derived>
  KOKKOS_FUNCTION Moose::Kokkos::Real3
  precomputeQpJacobian(const unsigned int j, const unsigned int qp, AssemblyDatum & datum) const;
 
protected:
  const bool _lumping;
};
 
template <typename Derived>
KOKKOS_FUNCTION void
KokkosVectorTimeDerivative::computeJacobianInternal(const Derived & kernel,
                                                    AssemblyDatum & datum) const
{
  using Moose::Kokkos::MAX_CACHED_DOF;
 
  Real local_ke[MAX_CACHED_DOF];
 
  const auto scaling_factor =
      kokkosSystem(_kokkos_var.sys()).getVariableScalingFactor(_kokkos_var.var());
 
  for (unsigned int j = datum.local_thread_id(); j < datum.n_jdofs();
       j += datum.num_local_threads())
  {
    unsigned int num_batches = datum.n_idofs() / MAX_CACHED_DOF;
 
    if (datum.n_idofs() % MAX_CACHED_DOF)
      ++num_batches;
 
    for (unsigned int batch = 0; batch < num_batches; ++batch)
    {
      unsigned int ib = batch * MAX_CACHED_DOF;
      unsigned int ie = ::Kokkos::min(ib + MAX_CACHED_DOF, datum.n_idofs());
 
      for (unsigned int i = ib; i < ie; ++i)
        local_ke[i - ib] = 0;
 
      for (unsigned int qp = 0; qp < datum.n_qps(); ++qp)
      {
        Moose::Kokkos::Real3 value =
            datum.JxW(qp) * kernel.template precomputeQpJacobian<Derived>(j, qp, datum);
 
        for (unsigned int i = ib; i < ie; ++i)
          local_ke[i - ib] += value * _test(datum, i, qp);
      }
 
      for (unsigned int i = ib; i < ie; ++i)
        accumulateTaggedElementalMatrix(local_ke[i - ib] * scaling_factor,
                                        datum.elem().id,
                                        i,
                                        _lumping ? i : j,
                                        datum.jvar(),
                                        datum.comp());
    }
  }
}
 
template <typename Derived>
KOKKOS_FUNCTION Moose::Kokkos::Real3
KokkosVectorTimeDerivative::precomputeQpResidual(const unsigned int qp, AssemblyDatum & datum) const
{
  return _u_dot(datum, qp);
}
 
template <typename Derived>
KOKKOS_FUNCTION Moose::Kokkos::Real3
KokkosVectorTimeDerivative::precomputeQpJacobian(const unsigned int j,
                                                 const unsigned int qp,
                                                 AssemblyDatum & datum) const
{
  return _phi(datum, j, qp) * _du_dot_du;
}