jali_mesh_wrapper.h

Go to the documentation of this file.

/*
This file is part of the Ristra Wonton project.
Please see the license file at the root of this repository, or at:
    https://github.com/laristra/wonton/blob/master/LICENSE
*/

#ifndef JALI_MESH_WRAPPER_H_
#define JALI_MESH_WRAPPER_H_

#include <cassert>
#include <algorithm>
#include <vector>
#include <array>
#include <utility>

#include "Mesh.hh"                      // Jali mesh header

#include "wonton/mesh/AuxMeshTopology.h"
#include "wonton/support/wonton.h"
#include "wonton/support/Point.h"

namespace Wonton {

template <int D>
Point<D> toWontonPoint(const JaliGeometry::Point& jp) {
  Point<D> pp;
  assert(jp.dim() == D);
  for (int d = 0; d < D; ++d)
    pp[d] = jp[d];
  return pp;
}

class Jali_Mesh_Wrapper : public AuxMeshTopology<Jali_Mesh_Wrapper> {
 public:


  explicit Jali_Mesh_Wrapper(Jali::Mesh const & mesh,
                             bool request_sides = true,
                             bool request_wedges = true,
                             bool request_corners = true) :
      AuxMeshTopology<Jali_Mesh_Wrapper>
        (request_sides, request_wedges, request_corners),
      jali_mesh_(mesh) {

    // base class (AuxMeshTopology) method that has to be called here
    // and not in the constructor of the base class because it needs
    // access to methods in this class which in turn need access to
    // its member variables. But these member vars don't get
    // initialized until the base class is constructed

    AuxMeshTopology<Jali_Mesh_Wrapper>::build_aux_entities(); 
  }

  Jali_Mesh_Wrapper(Jali_Mesh_Wrapper const & inmesh) = delete;

  Jali_Mesh_Wrapper & operator=(Jali_Mesh_Wrapper const & inmesh) = delete;

  ~Jali_Mesh_Wrapper() {}

  int space_dimension() const {
    return jali_mesh_.space_dimension();
  }

  int num_owned_cells() const {
    return jali_mesh_.num_entities(Jali::Entity_kind::CELL,
                                   Jali::Entity_type::PARALLEL_OWNED);
  }

  int num_owned_faces() const {
    return jali_mesh_.num_entities(Jali::Entity_kind::FACE,
                                   Jali::Entity_type::PARALLEL_OWNED);
  }

  int num_owned_nodes() const {
    return jali_mesh_.num_entities(Jali::Entity_kind::NODE,
                                   Jali::Entity_type::PARALLEL_OWNED);
  }

  int num_ghost_cells() const {
    return jali_mesh_.num_entities(Jali::Entity_kind::CELL,
                                   Jali::Entity_type::PARALLEL_GHOST);
  }

  int num_ghost_faces() const {
    return jali_mesh_.num_entities(Jali::Entity_kind::FACE,
                                   Jali::Entity_type::PARALLEL_GHOST);
  }

  int num_ghost_nodes() const {
    return jali_mesh_.num_entities(Jali::Entity_kind::NODE,
                                   Jali::Entity_type::PARALLEL_GHOST);
  }


  Wonton::Entity_type cell_get_type(int const cellid) const {
    Jali::Entity_type etype =
        jali_mesh_.entity_get_type(Jali::Entity_kind::CELL, cellid);
    return jali2wonton_type(etype);
  }


  Wonton::Entity_type node_get_type(int const nodeid) const {
    Jali::Entity_type etype =
        jali_mesh_.entity_get_type(Jali::Entity_kind::NODE, nodeid);
    return jali2wonton_type(etype);
  }


  Wonton::Element_type cell_get_element_type(int const cellid) const {
    Jali::Cell_type ctype = jali_mesh_.cell_get_type(cellid);
    return jali2wonton_elemtype(ctype);
  }

  void cell_get_faces_and_dirs(int const cellid, std::vector<int> *cfaces,
                               std::vector<int> *cfdirs) const {
    std::vector<Jali::dir_t> fdirs;

    jali_mesh_.cell_get_faces_and_dirs(cellid, cfaces, &fdirs);

    cfdirs->resize(fdirs.size());
    int const nb_dirs = fdirs.size();
    for (int i = 0; i < nb_dirs; ++i)
      (*cfdirs)[i] = static_cast<int>(fdirs[i]);
  }

  void cell_get_nodes(int cellid, std::vector<int> *nodes) const {
    jali_mesh_.cell_get_nodes(cellid, nodes);
  }

  void cell_get_node_adj_cells(int const cellid,
                               Entity_type const ptype,
                               std::vector<int> *adjcells) const {
    jali_mesh_.cell_get_node_adj_cells(cellid, (Jali::Entity_type) ptype,
                                       adjcells);
  }

  void face_get_nodes(int const faceid, std::vector<int> *fnodes) const {
    jali_mesh_.face_get_nodes(faceid, fnodes);
  }


  void node_get_cells(int const nodeid,
                      Entity_type const ptype,
                      std::vector<int> *nodecells) const {
    jali_mesh_.node_get_cells(nodeid, (Jali::Entity_type) ptype,
                              nodecells);
  }

  GID_t get_global_id(int const id, Entity_kind const kind) const {
    return jali_mesh_.GID(id, (Jali::Entity_kind)kind);
  }

  template <int D>
  void node_get_coordinates(int const nodeid, Point<D>* pp) const {
    JaliGeometry::Point jp;
    jali_mesh_.node_get_coordinates(nodeid, &jp);
    assert(jp.dim() == D);
    *pp = toWontonPoint<D>(jp);
  }

 private:

  Wonton::Entity_type jali2wonton_type(Jali::Entity_type etype) const {
    static Wonton::Entity_type jali2wonton_type_[5] =
        {DELETED, PARALLEL_OWNED, PARALLEL_GHOST, BOUNDARY_GHOST, ALL};
    return jali2wonton_type_[static_cast<int>(etype)];
  }
  
  Wonton::Element_type jali2wonton_elemtype(Jali::Cell_type elemtype) const {
    static Wonton::Element_type jali2wonton_elemtype_[9] =
        {UNKNOWN_TOPOLOGY, TRI, QUAD, POLYGON, TET, PRISM, PYRAMID, HEX,
         POLYHEDRON};
    return jali2wonton_elemtype_[static_cast<int>(elemtype)];
  }
    
  Jali::Mesh const & jali_mesh_;
};  // class Jali_Mesh_Wrapper


}  // end namespace Wonton

#endif // JALI_MESH_WRAPPER_H_