NoSplitting.hpp

#ifndef NO_SPLITTING_HPP
#define NO_SPLITTING_HPP

// --- INCLUSION fichiers headers ---

#include <Kokkos_Core.hpp>

#include <rang.hpp>
#include <BlockPerfectGas.hpp>

#include <TinyVector.hpp>
#include <TinyMatrix.hpp>
#include <Mesh.hpp>
#include <MeshData.hpp>
#include <FiniteVolumesEulerUnknowns.hpp>

// ---------------------------------

// Creation classe NoSplitting

template<typename MeshData> 
class NoSplitting 
{
  typedef typename MeshData::MeshType MeshType; 
  typedef FiniteVolumesEulerUnknowns<MeshData> UnknownsType; 

  MeshData& m_mesh_data; 
  MeshType& m_mesh;
  const typename MeshType::Connectivity& m_connectivity;

  constexpr static size_t dimension = MeshType::dimension; 

  typedef TinyVector<dimension> Rd; 
  typedef TinyMatrix<dimension> Rdd;

private:

  struct ReduceMin
  {
  private:
    const Kokkos::View<const double*> x_;

  public:
    typedef Kokkos::View<const double*>::non_const_value_type value_type;

    ReduceMin(const Kokkos::View<const double*>& x) : x_ (x) {}

    typedef Kokkos::View<const double*>::size_type size_type;
    
    KOKKOS_INLINE_FUNCTION void
    operator() (const size_type i, value_type& update) const
    {
      if (x_(i) < update) {
	update = x_(i);
      }
    }

    KOKKOS_INLINE_FUNCTION void
    join (volatile value_type& dst,
	  const volatile value_type& src) const
    {
      if (src < dst) {
	dst = src;
      }
    }

    KOKKOS_INLINE_FUNCTION void
    init (value_type& dst) const
    { // The identity under max is -Inf.
      dst= Kokkos::reduction_identity<value_type>::min();