FiniteVolumesDiffusion.hpp

#ifndef FINITE_VOLUMES_DIFFUSION_HPP
#define FINITE_VOLUMES_DIFFUSION_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 FiniteVolumesDiffusion 

template<typename MeshData> // MeshData est le type generique des donnees (geometriques) attachees a un maillage
class FiniteVolumesDiffusion 
{
  typedef typename MeshData::MeshType MeshType; // type du maillage
  typedef FiniteVolumesEulerUnknowns<MeshData> UnknownsType; // type des inconnues

  MeshData& m_mesh_data; // reference vers les donnees attachees du maillage
  const MeshType& m_mesh; // reference vers le maillage
  const typename MeshType::Connectivity& m_connectivity; // references vers la connectivite

  constexpr static size_t dimension = MeshType::dimension; // dimension du maillage (connue a la compilation)

  typedef TinyVector<dimension> Rd; // type de petits vecteurs (de dimension MeshType::dimension)
  typedef TinyMatrix<dimension> Rdd; // type de petites matrices

private:

 // Sert a calculer les reductions (en gros calculer le min sur des
 // vecteurs en parallele)
  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