simple_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 WONTON_SIMPLE_MESH_WRAPPER_H_
#define WONTON_SIMPLE_MESH_WRAPPER_H_

#include "wonton/mesh/simple/simple_mesh.h"

#include <vector>
#include <algorithm>

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

namespace Wonton {
class Simple_Mesh_Wrapper : public AuxMeshTopology<Simple_Mesh_Wrapper> {
 public:
  explicit Simple_Mesh_Wrapper(Simple_Mesh const & mesh,
                               bool request_sides = true,
                               bool request_wedges = true,
                               bool request_corners = true) :
      AuxMeshTopology<Simple_Mesh_Wrapper>(
        request_sides, request_wedges, request_corners),
      mesh_(mesh) {
    AuxMeshTopology<Simple_Mesh_Wrapper>::build_aux_entities();
  }  // explicit constructor

  Simple_Mesh_Wrapper(Simple_Mesh_Wrapper const & inmesh) = delete;

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

  ~Simple_Mesh_Wrapper() = default;

  // The following methods are needed somewhere within AuxMeshTopology

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

  // The number of OWNED entities

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

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

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

  // number of ghost data entities

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

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

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

  // cell type: Simple_Mesh only has OWNED
  Entity_type cell_get_type(int const cellid) const {
    return Entity_type::PARALLEL_OWNED;
  }

  // node type: Simple_Mesh only has OWNED
  Entity_type node_get_type(int const nodeid) const {
    return Entity_type::PARALLEL_OWNED;
  }

  // cell element type: Simple_Mesh only deals with HEX
  Element_type cell_get_element_type(int const cellid) const {
    return Element_type::HEX;
  }

  // Connectivity information

  void cell_get_faces_and_dirs(int const cellid, std::vector<int> *cfaces,
                               std::vector<int> *cfdirs) const {
    mesh_.cell_get_faces_and_dirs(cellid, cfaces, cfdirs);
  }

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

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

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

  GID_t get_global_id(int const id, Entity_kind const kind) const {
    return id;
  }


  template<int D>
  void node_get_coordinates(int const nodeid, Point<D>* pp) const 
  {
    mesh_.node_get_coordinates(nodeid, pp);
  }

 private:
  Simple_Mesh const & mesh_;
};  // class Simple_Mesh_Wrapper

}  // namespace Wonton

#endif  // WONTON_SIMPLE_MESH_WRAPPER_H_