Zoltan2_GraphAdapter.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_GRAPHADAPTER_HPP_
#define _ZOLTAN2_GRAPHADAPTER_HPP_
 
#include <Zoltan2_Adapter.hpp>
#include <Zoltan2_VectorAdapter.hpp>
 
namespace Zoltan2 {
 
enum GraphEntityType { GRAPH_VERTEX, GRAPH_EDGE };
 
template <typename User, typename UserCoord = User>
class GraphAdapter : public AdapterWithCoordsWrapper<User, UserCoord> {
private:
  enum GraphEntityType primaryEntityType_ = GRAPH_VERTEX;
 
  enum GraphEntityType adjacencyEntityType_ = GRAPH_EDGE;
 
  VectorAdapter<UserCoord> *coordinateInput_ = nullptr;
 
  bool haveCoordinateInput_ = false;
 
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  using scalar_t = typename InputTraits<User>::scalar_t;
  using lno_t = typename InputTraits<User>::lno_t;
  using gno_t = typename InputTraits<User>::gno_t;
  using node_t = typename InputTraits<User>::node_t;
  using offset_t = typename InputTraits<User>::offset_t;
  using user_t = User;
  using userCoord_t = UserCoord;
  using base_adapter_t = GraphAdapter<User, UserCoord>;
  using Base = AdapterWithCoordsWrapper<User, UserCoord>;
  using VtxDegreeHostView = Kokkos::View<bool *, Kokkos::HostSpace>;
  using device_t = typename node_t::device_type;
#endif
 
  enum BaseAdapterType adapterType() const override { return GraphAdapterType; }
 
  // Methods to be defined in derived classes.
 
  virtual size_t getLocalNumVertices() const = 0;
 
  virtual size_t getLocalNumEdges() const = 0;
 
  virtual void getVertexIDsView(const gno_t *&vertexIds) const = 0;
 
  virtual void
  getVertexIDsDeviceView(typename Base::ConstIdsDeviceView &vertexIds) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getVertexIDsHostView(typename Base::ConstIdsHostView &vertexIds) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getEdgesView(const offset_t *&offsets,
                            const gno_t *&adjIds) const = 0;
 
  virtual void
  getEdgesDeviceView(typename Base::ConstOffsetsDeviceView &offsets,
                     typename Base::ConstIdsDeviceView &adjIds) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void getEdgesHostView(typename Base::ConstOffsetsHostView &offsets,
                                typename Base::ConstIdsHostView &adjIds) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual int getNumWeightsPerVertex() const { return 0; }
 
  virtual void getVertexWeightsView(const scalar_t *&weights, int &stride,
                                    int /* idx */ = 0) const {
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getVertexWeightsDeviceView(typename Base::WeightsDeviceView1D &weights,
                             int /* idx */ = 0) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getVertexWeightsDeviceView(typename Base::WeightsDeviceView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getVertexWeightsHostView(typename Base::WeightsHostView1D &weights,
                           int /* idx */ = 0) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getVertexWeightsHostView(typename Base::WeightsHostView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual bool useDegreeAsVertexWeight(int /* idx */) const { return false; }
 
  virtual int getNumWeightsPerEdge() const { return 0; }
 
  virtual void getEdgeWeightsView(const scalar_t *&weights, int &stride,
                                  int /* idx */ = 0) const {
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getEdgeWeightsDeviceView(typename Base::WeightsDeviceView1D &weights,
                           int /* idx */ = 0) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getEdgeWeightsDeviceView(typename Base::WeightsDeviceView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getEdgeWeightsHostView(typename Base::WeightsHostView1D &weights,
                         int /* idx */ = 0) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  virtual void
  getEdgeWeightsHostView(typename Base::WeightsHostView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }
 
  void setCoordinateInput(VectorAdapter<UserCoord> *coordData) override {
    coordinateInput_ = coordData;
    haveCoordinateInput_ = true;
  }
 
  bool coordinatesAvailable() const { return haveCoordinateInput_; }
 
  VectorAdapter<UserCoord> *getCoordinateInput() const override {
    return coordinateInput_;
  }
 
  // Implementations of base-class methods
 
  inline enum GraphEntityType getPrimaryEntityType() const {
    return this->primaryEntityType_;
  }
 
  void setPrimaryEntityType(const std::string &typestr) {
    if (typestr == "vertex") {
      this->primaryEntityType_ = GRAPH_VERTEX;
      this->adjacencyEntityType_ = GRAPH_EDGE;
    } else if (typestr == "edge") {
      this->primaryEntityType_ = GRAPH_EDGE;
      this->adjacencyEntityType_ = GRAPH_VERTEX;
    } else {
      AssertCondition(true, "Invalid GraphEntityType (" + typestr +
                                "). Valid values are 'vertex' and 'edge'");
    }
  }
 
  inline enum GraphEntityType getAdjacencyEntityType() const {
    return this->adjacencyEntityType_;
  }
 
  void setAdjacencyEntityType(const std::string &typestr) {
    if (typestr == "vertex") {
      this->adjacencyEntityType_ = GRAPH_VERTEX;
      this->primaryEntityType_ = GRAPH_EDGE;
    } else if (typestr == "edge") {
      this->adjacencyEntityType_ = GRAPH_EDGE;
      this->primaryEntityType_ = GRAPH_VERTEX;
    } else {
      AssertCondition(true, "Invalid GraphEntityType (" + typestr +
                                "). Valid values are 'vertex' and 'edge'");
    }
  }
 
  // Functions from the BaseAdapter interface
  size_t getLocalNumIDs() const override {
    if (getPrimaryEntityType() == GRAPH_VERTEX)
      return getLocalNumVertices();
    else
      return getLocalNumEdges();
  }
 
  void getIDsView(const gno_t *&Ids) const override {
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getIDsView not yet supported for graph edges.");
 
    getVertexIDsView(Ids);
  }
 
  void getIDsDeviceView(typename Base::ConstIdsDeviceView &Ids) const override {
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getIDsDeviceView not yet supported for graph edges.");
 
    getVertexIDsDeviceView(Ids);
  }
 
  void getIDsHostView(typename Base::ConstIdsHostView &Ids) const override {
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getIDsHostView not yet supported for graph edges.");
 
    getVertexIDsHostView(Ids);
  }
 
  int getNumWeightsPerID() const override {
    if (getPrimaryEntityType() == GRAPH_VERTEX)
      return getNumWeightsPerVertex();
    else
      return getNumWeightsPerEdge();
  }
 
  void getWeightsView(const scalar_t *&wgt, int &stride,
                      int idx = 0) const override {
 
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getWeightsView not yet supported for graph edges.");
 
    getVertexWeightsView(wgt, stride, idx);
  }
 
  void getWeightsHostView(typename Base::WeightsHostView1D &hostWgts,
                          int idx = 0) const override {
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getWeightsHostView not yet supported for graph edges.");
 
    getVertexWeightsHostView(hostWgts, idx);
  }
 
  void getWeightsHostView(typename Base::WeightsHostView &hostWgts) const override {
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getWeightsHostView not yet supported for graph edges.");
 
    getVertexWeightsHostView(hostWgts);
  }
 
  void getWeightsDeviceView(typename Base::WeightsDeviceView1D &deviceWgts,
                            int idx = 0) const override {
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getWeightsDeviceView not yet supported for graph edges.");
 
    getVertexWeightsDeviceView(deviceWgts, idx);
  }
 
  void getWeightsDeviceView(typename Base::WeightsDeviceView &deviceWgts) const override {
    AssertCondition(getPrimaryEntityType() == GRAPH_VERTEX,
                    "getWeightsDeviceView not yet supported for graph edges.");
 
    getVertexWeightsDeviceView(deviceWgts);
  }
 
  bool useDegreeAsWeight(int idx) const {
    AssertCondition(this->getPrimaryEntityType() == GRAPH_VERTEX,
                    "useDegreeAsWeight not yet supported for graph edges.");
 
    return useDegreeAsVertexWeight(idx);
  }
};
 
} // namespace Zoltan2
 
#endif