Mesh.hpp

#ifndef MESH_HPP
#define MESH_HPP

#include <Kokkos_Core.hpp>
#include <TinyVector.hpp>

class Connectivity1D
{
public:
  static constexpr size_t dimension = 1;

private:
  const size_t m_number_of_cells;
  const size_t m_number_of_nodes;

  Kokkos::View<size_t*[2]> m_cell_nodes;
  Kokkos::View<size_t*> m_node_nb_cells;
  Kokkos::View<size_t*[2]> m_node_cells;
  Kokkos::View<size_t*[2]> m_node_cell_local_node;

public:
  const size_t& numberOfNodes() const
  {
    return m_number_of_nodes;
  }

  const size_t& numberOfCells() const
  {
    return m_number_of_cells;
  }

  const Kokkos::View<const size_t*[2]> cellNodes() const
  {
    return m_cell_nodes;
  }

  const Kokkos::View<const size_t*> nodeNbCells() const
  {
    return m_node_nb_cells;
  }

  const Kokkos::View<const size_t*[2]> nodeCells() const
  {
    return m_node_cells;
  }

  const Kokkos::View<const size_t*[2]> nodeCellLocalNode() const
  {
    return m_node_cell_local_node;
  }

  Connectivity1D(const Connectivity1D&) = delete;
  
  Connectivity1D(const size_t& number_of_cells)
    : m_number_of_cells (number_of_cells),
      m_number_of_nodes (number_of_cells+1),
      m_cell_nodes ("cell_nodes", m_number_of_cells),
      m_node_nb_cells ("node_nb_cells",m_number_of_nodes),
      m_node_cells ("node_cells", m_number_of_nodes),
      m_node_cell_local_node ("node_cell_local_node", m_number_of_nodes)
  {
    assert(number_of_cells>0);

    Kokkos::parallel_for(m_number_of_cells, KOKKOS_LAMBDA(const size_t& j) {
	m_cell_nodes(j,0)=j;
	m_cell_nodes(j,1)=j+1;
      });

    Kokkos::parallel_for(m_number_of_nodes, KOKKOS_LAMBDA(const size_t& r) {
	m_node_nb_cells(r) = 2;
      });
    m_node_nb_cells(0) = 1;
    m_node_nb_cells(m_number_of_nodes-1) = 1;


    m_node_cells(0,0) = 0;
    Kokkos::parallel_for(m_number_of_nodes-2, KOKKOS_LAMBDA(const int& r) {
	m_node_cells(r+1,0) = r;
	m_node_cells(r+1,1) = r+1;
      });
    m_node_cells(m_number_of_nodes-1,0) = m_number_of_cells-1;

    Kokkos::parallel_for(m_number_of_nodes, KOKKOS_LAMBDA(const int& r) {
	for (int J=0; J<m_node_nb_cells(r); ++J) {
	  int j = m_node_cells(r,J);
	  for (int R=0; R<2; ++R) {
	    if (m_cell_nodes(j,R) == r) {
	      m_node_cell_local_node(r,J) = R;
	    }
	  }
	}
      });
  }

  ~Connectivity1D()
  {
    ;
  }
};

template <typename ConnectivityType>
class Mesh
{
public:
  static constexpr size_t dimension = ConnectivityType::dimension;
  typedef TinyVector<dimension> Rd;

private:
  const ConnectivityType& m_connectivity;
  Kokkos::View<Rd*> m_xr;

public:

  const Kokkos::View<const Rd*> xr() const
  {
    return m_xr;
  }

  Mesh(const ConnectivityType& connectivity)
    : m_connectivity(connectivity),
      m_xr("xr", 100)
  {
    ;
  }

  ~Mesh()
  {
    ;
  }
};

#endif // MESH_HPP