Zoltan2_MeshAdapter.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//   Zoltan2: A package of combinatorial algorithms for scientific computing
//
// Copyright 2012 NTESS and the Zoltan2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef _ZOLTAN2_MESHADAPTER_HPP_
#define _ZOLTAN2_MESHADAPTER_HPP_

#include <Zoltan2_Adapter.hpp>
#include "TpetraExt_MatrixMatrix.hpp"

namespace Zoltan2 {

enum MeshEntityType {
  MESH_VERTEX,
  MESH_EDGE,
  MESH_FACE,
  MESH_REGION
};

enum EntityTopologyType {
  POINT,         // a 0D entity (e.g. a vertex)
  LINE_SEGMENT,  // a 1D entity (e.g. an edge)
  POLYGON,       // a general 2D entity
  TRIANGLE,      // a specific 2D entity bounded by 3 edge entities
  QUADRILATERAL, // a specific 2D entity bounded by 4 edge entities
  POLYHEDRON,    // a general 3D entity
  TETRAHEDRON,   // a specific 3D entity bounded by 4 triangle entities
  HEXAHEDRON,    // a specific 3D entity bounded by 6 quadrilateral
                 // entities
  PRISM,         // a specific 3D entity bounded by a combination of 3
                 //quadrilateral entities and 2 triangle entities
  PYRAMID        // a specific 3D entity bounded by a combination of 1
                 // quadrilateral entity and 4 triangle entities
};

template <typename User>
class MeshAdapter : public AdapterWithCoords<User> {
public:

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  typedef typename InputTraits<User>::scalar_t scalar_t;
  typedef typename InputTraits<User>::offset_t offset_t;
  typedef typename InputTraits<User>::lno_t lno_t;
  typedef typename InputTraits<User>::gno_t gno_t;
  typedef typename InputTraits<User>::part_t part_t;
  typedef typename InputTraits<User>::node_t node_t;
  typedef User user_t;
  typedef User userCoord_t;
  typedef MeshAdapter<User> base_adapter_t;
#endif

  enum BaseAdapterType adapterType() const override {return MeshAdapterType;}

  // Default MeshEntityType is MESH_REGION with MESH_FACE-based adjacencies and
  // second adjacencies and coordinates
  MeshAdapter() : primaryEntityType(MESH_REGION),
                  adjacencyEntityType(MESH_FACE),
                  secondAdjacencyEntityType(MESH_FACE) {};

  // Methods to be defined in derived classes.

  virtual bool areEntityIDsUnique(MeshEntityType etype) const
  {
    return etype==this->getPrimaryEntityType();
  }

  //virtual size_t getGlobalNumOf(MeshEntityType etype) const = 0;

  virtual size_t getLocalNumOf(MeshEntityType etype) const = 0;


  virtual void getIDsViewOf(MeshEntityType etype,
                            gno_t const *&Ids) const = 0;


  virtual void getTopologyViewOf(MeshEntityType etype,
                                 enum EntityTopologyType const *&Types) const
  {
    Types = NULL;
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual int getNumWeightsPerOf(MeshEntityType etype) const { return 0; }

  virtual void getWeightsViewOf(MeshEntityType etype,
     const scalar_t *&weights, int &stride, int idx = 0) const
  {
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }


  virtual int getDimension() const { return 0; }

  virtual void getCoordinatesViewOf(MeshEntityType etype,
    const scalar_t *&coords, int &stride, int coordDim) const
  {
    coords = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }


  virtual bool availAdjs(MeshEntityType source, MeshEntityType target) const {
    return false;
  }


  virtual size_t getLocalNumAdjs(MeshEntityType source,
                                 MeshEntityType target) const { return 0;}


  virtual void getAdjsView(MeshEntityType source, MeshEntityType target,
     const offset_t *&offsets, const gno_t *& adjacencyIds) const
  {
    offsets = NULL;
    adjacencyIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED
  }


  virtual bool avail2ndAdjs(MeshEntityType sourcetarget,
                            MeshEntityType through) const
  {
    return false;
  }

  virtual size_t getLocalNum2ndAdjs(MeshEntityType sourcetarget,
                                    MeshEntityType through) const
  {
    return 0;
  }

  virtual void get2ndAdjsView(MeshEntityType sourcetarget,
                              MeshEntityType through,
                              const offset_t *&offsets,
                              const gno_t *&adjacencyIds) const
  {
    offsets = NULL;
    adjacencyIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual int getNumWeightsPer2ndAdj(MeshEntityType sourcetarget,
                                     MeshEntityType through) const { return 0;}


  virtual void get2ndAdjWeightsView(MeshEntityType sourcetarget,
                                    MeshEntityType through,
                                    const scalar_t *&weights,
                                    int &stride,
                                    int idx) const
  {
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }

  // Implementations of base-class methods

  inline enum MeshEntityType getPrimaryEntityType() const {
    return this->primaryEntityType;
  }

  inline enum MeshEntityType getAdjacencyEntityType() const {
    return this->adjacencyEntityType;
  }

  inline enum MeshEntityType getSecondAdjacencyEntityType() const {
    return this->secondAdjacencyEntityType;
  }

  void setEntityTypes(std::string ptypestr, std::string atypestr,
                      std::string satypestr) {

    if (ptypestr != atypestr && ptypestr != satypestr) {
      if (ptypestr == "region")
        this->primaryEntityType = MESH_REGION;
      else if (ptypestr == "face")
        this->primaryEntityType = MESH_FACE;
      else if (ptypestr == "edge")
        this->primaryEntityType = MESH_EDGE;
      else if (ptypestr == "vertex")
        this->primaryEntityType = MESH_VERTEX;
      else {
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  Invalid MeshEntityType " << ptypestr << std::endl;
        emsg << "Valid values: region  face  edge  vertex" << std::endl;
        throw std::runtime_error(emsg.str());
      }

      if (atypestr == "region")
        this->adjacencyEntityType = MESH_REGION;
      else if (atypestr == "face")
        this->adjacencyEntityType = MESH_FACE;
      else if (atypestr == "edge")
        this->adjacencyEntityType = MESH_EDGE;
      else if (atypestr == "vertex")
        this->adjacencyEntityType = MESH_VERTEX;
      else {
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  Invalid MeshEntityType " << atypestr << std::endl;
        emsg << "Valid values: region  face  edge  vertex" << std::endl;
        throw std::runtime_error(emsg.str());
      }

      if (satypestr == "region")
        this->secondAdjacencyEntityType = MESH_REGION;
      else if (satypestr == "face")
        this->secondAdjacencyEntityType = MESH_FACE;
      else if (satypestr == "edge")
        this->secondAdjacencyEntityType = MESH_EDGE;
      else if (satypestr == "vertex")
        this->secondAdjacencyEntityType = MESH_VERTEX;
      else {
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  Invalid MeshEntityType " << satypestr << std::endl;
        emsg << "Valid values: region  face  edge  vertex" << std::endl;
        throw std::runtime_error(emsg.str());
      }
    }
    else {
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  PrimaryEntityType " << ptypestr
           << " matches AdjacencyEntityType " << atypestr
           << " or SecondAdjacencyEntityType " << satypestr << std::endl;
      throw std::runtime_error(emsg.str());
    }
  }

  virtual bool useDegreeAsWeightOf(MeshEntityType etype, int idx) const
  {
    return false;
  }

  // Functions from the BaseAdapter interface
  size_t getLocalNumIDs() const override {
    return getLocalNumOf(getPrimaryEntityType());
  }

  void getIDsView(const gno_t *&Ids) const override {
    getIDsViewOf(getPrimaryEntityType(), Ids);
  }

  void getIDsKokkosView(Kokkos::View<const gno_t *,
    typename node_t::device_type> &ids) const override
  {
    Kokkos::View<gno_t *, typename node_t::device_type>
      kokkos_ids("gids", getLocalNumIDs());
    auto host_kokkos_ids = Kokkos::create_mirror_view(kokkos_ids);

    const gno_t * gnos;
    getIDsView(gnos);
    for(size_t n = 0; n < getLocalNumIDs(); ++n) {
      host_kokkos_ids(n) = gnos[n];
    }
    Kokkos::deep_copy(kokkos_ids, host_kokkos_ids);
    ids = kokkos_ids;
  }

  int getNumWeightsPerID() const override {
    return getNumWeightsPerOf(getPrimaryEntityType());
  }

  void getWeightsView(const scalar_t *&wgt, int &stride, int idx = 0) const override {
    getWeightsViewOf(getPrimaryEntityType(), wgt, stride, idx);
  }

  void getCoordinatesView(const scalar_t *&coords, int &stride,
                          int coordDim) const override
  {
    getCoordinatesViewOf(getPrimaryEntityType(), coords, stride, coordDim);
  }

  void getCoordinatesKokkosView(
    // coordinates in MJ are LayoutLeft since Tpetra Multivector gives LayoutLeft
    Kokkos::View<scalar_t **, Kokkos::LayoutLeft, typename node_t::device_type> & elements) const override
  {
    // coordinates in MJ are LayoutLeft since Tpetra Multivector gives LayoutLeft
    Kokkos::View<scalar_t **, Kokkos::LayoutLeft, typename node_t::device_type>
      kokkos_coordinates("pamgen coords", getLocalNumIDs(), getDimension());
    auto host_temp_values = Kokkos::create_mirror_view(kokkos_coordinates);
    const scalar_t * coords;
    for(int dim = 0; dim < getDimension(); ++dim) {
      int stride = -1;
      getCoordinatesView(coords, stride, dim);
      for(size_t n = 0; n < getLocalNumIDs(); ++n) {
        host_temp_values(n, dim) = coords[n*stride];
      }
    }
    Kokkos::deep_copy(kokkos_coordinates, host_temp_values);
    elements = kokkos_coordinates;
  }

  bool useDegreeAsWeight(int idx) const
  {
    return useDegreeAsWeightOf(getPrimaryEntityType(), idx);
  }

private:
  enum MeshEntityType primaryEntityType; // Entity type
                                         // to be partitioned, ordered,
                                         // colored, matched, etc.
  enum MeshEntityType adjacencyEntityType; // Entity type defining first-order
                                           // adjacencies; adjacencies are of
                                           // this type.
  enum MeshEntityType secondAdjacencyEntityType; // Bridge entity type
                                                 // defining second-order
                                                 // adjacencies.
};

}  //namespace Zoltan2

#endif