Zoltan2_XpetraCrsGraphAdapter.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_XPETRACRSGRAPHADAPTER_HPP_
#define _ZOLTAN2_XPETRACRSGRAPHADAPTER_HPP_
 
#include <Zoltan2_GraphAdapter.hpp>
#include <Zoltan2_StridedData.hpp>
#include <Zoltan2_XpetraTraits.hpp>
#include <Zoltan2_PartitioningHelpers.hpp>
 
#include <Xpetra_CrsGraph.hpp>
 
namespace Zoltan2 {
 
template <typename User, typename UserCoord=User>
  class XpetraCrsGraphAdapter : public GraphAdapter<User,UserCoord> {
 
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 Xpetra::CrsGraph<lno_t, gno_t, node_t> xgraph_t;
  typedef User user_t;
  typedef UserCoord userCoord_t;
 
  using Base = GraphAdapter<User,UserCoord>;
#endif
 
  XpetraCrsGraphAdapter(const RCP<const User> &ingraph,
                        int nVtxWeights=0, int nEdgeWeights=0);
 
  void setWeights(const scalar_t *val, int stride, int idx);
  void setWeightsDevice(typename Base::ConstWeightsDeviceView& val, int idx) {}
  void setWeightsHost(typename Base::ConstWeightsHostView& val, int idx) {}
 
  void setVertexWeights(const scalar_t *val, int stride, int idx);
  void setVertexWeightsDevice(typename Base::ConstWeightsDeviceView& val, int idx);
  void setVertexWeightsHost(typename Base::ConstWeightsHostView& val, int idx);
 
  void setWeightIsDegree(int idx);
 
  void setVertexWeightIsDegree(int idx);
 
  void setEdgeWeights(const scalar_t *val, int stride, int idx);
  void setEdgeWeightsDevice(typename Base::ConstWeightsDeviceView& val, int idx);
  void setEdgeWeightsHost(typename Base::ConstWeightsHostView& val, int idx);
 
  RCP<const xgraph_t> getXpetraGraph() const { return graph_; }
 
  RCP<const User> getUserGraph() const { return ingraph_; }
 
  // The GraphAdapter interface.
 
  // TODO:  Assuming rows == objects;
  // TODO:  Need to add option for columns or nonzeros?
  size_t getLocalNumVertices() const override { return graph_->getLocalNumRows(); }
 
  void getVertexIDsView(const gno_t *&ids) const override
  {
    ids = NULL;
    if (getLocalNumVertices())
      ids = graph_->getRowMap()->getLocalElementList().getRawPtr();
  }
 
  size_t getLocalNumEdges() const override { return graph_->getLocalNumEntries(); }
 
  void getEdgesView(const offset_t *&offsets, const gno_t *&adjIds) const override
  {
    offsets = offs_.getRawPtr();
    adjIds = (getLocalNumEdges() ? adjids_.getRawPtr() : NULL);
  }
 
  int getNumWeightsPerVertex() const override { return nWeightsPerVertex_;}
 
  void getVertexWeightsView(const scalar_t *&weights, int &stride,
                            int idx) const override
  {
    if(idx<0 || idx >= nWeightsPerVertex_)
    {
      std::ostringstream emsg;
      emsg << __FILE__ << ":" << __LINE__
           << "  Invalid vertex weight index " << idx << std::endl;
      throw std::runtime_error(emsg.str());
    }
 
 
    size_t length;
    vertexWeights_[idx].getStridedList(length, weights, stride);
  }
 
  bool useDegreeAsVertexWeight(int idx) const override {return vertexDegreeWeight_[idx];}
 
  int getNumWeightsPerEdge() const override { return nWeightsPerEdge_;}
 
  void getEdgeWeightsView(const scalar_t *&weights, int &stride, int idx) const override
  {
    if(idx<0 || idx >= nWeightsPerEdge_)
    {
      std::ostringstream emsg;
      emsg << __FILE__ << ":" << __LINE__
           << "  Invalid edge weight index " << idx << std::endl;
      throw std::runtime_error(emsg.str());
    }
 
 
    size_t length;
    edgeWeights_[idx].getStridedList(length, weights, stride);
  }
 
  template <typename Adapter>
    void applyPartitioningSolution(const User &in, User *&out,
      const PartitioningSolution<Adapter> &solution) const;
 
  template <typename Adapter>
    void applyPartitioningSolution(const User &in, RCP<User> &out,
      const PartitioningSolution<Adapter> &solution) const;
 
private:
 
  RCP<const User > ingraph_;
  RCP<const xgraph_t > graph_;
  RCP<const Comm<int> > comm_;
 
  ArrayRCP<const offset_t> offs_;
  ArrayRCP<const gno_t> adjids_;
 
  int nWeightsPerVertex_;
  ArrayRCP<StridedData<lno_t, scalar_t> > vertexWeights_;
  ArrayRCP<bool> vertexDegreeWeight_;
 
  int nWeightsPerEdge_;
  ArrayRCP<StridedData<lno_t, scalar_t> > edgeWeights_;
 
  int coordinateDim_;
  ArrayRCP<StridedData<lno_t, scalar_t> > coords_;
 
};
 
// Definitions
 
template <typename User, typename UserCoord>
  XpetraCrsGraphAdapter<User,UserCoord>::XpetraCrsGraphAdapter(
    const RCP<const User> &ingraph, int nVtxWgts, int nEdgeWgts):
      ingraph_(ingraph), graph_(), comm_() , offs_(), adjids_(),
      nWeightsPerVertex_(nVtxWgts), vertexWeights_(), vertexDegreeWeight_(),
      nWeightsPerEdge_(nEdgeWgts), edgeWeights_(),
      coordinateDim_(0), coords_()
{
  typedef StridedData<lno_t,scalar_t> input_t;
 
  try {
    graph_ = rcp_const_cast<const xgraph_t>(
           XpetraTraits<User>::convertToXpetra(rcp_const_cast<User>(ingraph)));
  }
  Z2_FORWARD_EXCEPTIONS
 
  comm_ = graph_->getComm();
  size_t nvtx = graph_->getLocalNumRows();
  size_t nedges = graph_->getLocalNumEntries();
 
  // Unfortunately we have to copy the offsets and edge Ids
  // because edge Ids are not usually stored in vertex id order.
 
  size_t n = nvtx + 1;
  offset_t *offs = new offset_t [n];
 
  if (!offs)
  {
    std::cerr << "Error: " << __FILE__ << ", " << __LINE__<< std::endl;
    std::cerr << n << " objects" << std::endl;
    throw std::bad_alloc();
  }
 
  gno_t *adjids = NULL;
  if (nedges)
  {
    adjids = new gno_t [nedges];
 
    if (!adjids)
    {
      std::cerr << "Error: " << __FILE__ << ", " << __LINE__<< std::endl;
      std::cerr << nedges << " objects" << std::endl;
      throw std::bad_alloc();
    }
  }
 
  offs[0] = 0;
  for (size_t v=0; v < nvtx; v++){
    ArrayView<const lno_t> nbors;
    graph_->getLocalRowView(v, nbors);
    offs[v+1] = offs[v] + nbors.size();
    for (offset_t e=offs[v], i=0; e < offs[v+1]; e++)
      adjids[e] = graph_->getColMap()->getGlobalElement(nbors[i++]);
  }
 
  offs_ = arcp(offs, 0, n, true);
  adjids_ = arcp(adjids, 0, nedges, true);
 
  if (nWeightsPerVertex_ > 0) {
    vertexWeights_ =
          arcp(new input_t[nWeightsPerVertex_], 0, nWeightsPerVertex_, true);
    vertexDegreeWeight_ =
          arcp(new bool[nWeightsPerVertex_], 0, nWeightsPerVertex_, true);
    for (int i=0; i < nWeightsPerVertex_; i++)
      vertexDegreeWeight_[i] = false;
  }
 
  if (nWeightsPerEdge_ > 0)
    edgeWeights_ = arcp(new input_t[nWeightsPerEdge_], 0, nWeightsPerEdge_, true);
}
 
template <typename User, typename UserCoord>
  void XpetraCrsGraphAdapter<User,UserCoord>::setWeights(
    const scalar_t *weightVal, int stride, int idx)
{
  if (this->getPrimaryEntityType() == GRAPH_VERTEX)
    setVertexWeights(weightVal, stride, idx);
  else
    setEdgeWeights(weightVal, stride, idx);
}
 
template <typename User, typename UserCoord>
  void XpetraCrsGraphAdapter<User,UserCoord>::setVertexWeights(
    const scalar_t *weightVal, int stride, int idx)
{
  typedef StridedData<lno_t,scalar_t> input_t;
 
  if(idx<0 || idx >= nWeightsPerVertex_)
  {
      std::ostringstream emsg;
      emsg << __FILE__ << ":" << __LINE__
           << "  Invalid vertex weight index " << idx << std::endl;
      throw std::runtime_error(emsg.str());
  }
 
  size_t nvtx = getLocalNumVertices();
  ArrayRCP<const scalar_t> weightV(weightVal, 0, nvtx*stride, false);
  vertexWeights_[idx] = input_t(weightV, stride);
}
 
template <typename User, typename UserCoord>
  void XpetraCrsGraphAdapter<User,UserCoord>::setWeightIsDegree(
    int idx)
{
  if (this->getPrimaryEntityType() == GRAPH_VERTEX)
    setVertexWeightIsDegree(idx);
  else {
    std::ostringstream emsg;
    emsg << __FILE__ << "," << __LINE__
         << " error:  setWeightIsNumberOfNonZeros is supported only for"
         << " vertices" << std::endl;
    throw std::runtime_error(emsg.str());
  }
}
 
template <typename User, typename UserCoord>
  void XpetraCrsGraphAdapter<User,UserCoord>::setVertexWeightIsDegree(
    int idx)
{
  if(idx<0 || idx >= nWeightsPerVertex_)
  {
      std::ostringstream emsg;
      emsg << __FILE__ << ":" << __LINE__
           << "  Invalid vertex weight index " << idx << std::endl;
      throw std::runtime_error(emsg.str());
  }
 
  vertexDegreeWeight_[idx] = true;
}
 
template <typename User, typename UserCoord>
  void XpetraCrsGraphAdapter<User,UserCoord>::setEdgeWeights(
    const scalar_t *weightVal, int stride, int idx)
{
  typedef StridedData<lno_t,scalar_t> input_t;
 
  if(idx<0 || idx >= nWeightsPerEdge_)
  {
      std::ostringstream emsg;
      emsg << __FILE__ << ":" << __LINE__
           << "  Invalid edge weight index " << idx << std::endl;
      throw std::runtime_error(emsg.str());
  }
 
  size_t nedges = getLocalNumEdges();
  ArrayRCP<const scalar_t> weightV(weightVal, 0, nedges*stride, false);
  edgeWeights_[idx] = input_t(weightV, stride);
}
 
template <typename User, typename UserCoord>
  template<typename Adapter>
    void XpetraCrsGraphAdapter<User,UserCoord>::applyPartitioningSolution(
      const User &in, User *&out,
      const PartitioningSolution<Adapter> &solution) const
{
  // Get an import list (rows to be received)
  size_t numNewVtx;
  ArrayRCP<gno_t> importList;
  try{
    numNewVtx = Zoltan2::getImportList<Adapter,
                                       XpetraCrsGraphAdapter<User,UserCoord> >
                                      (solution, this, importList);
  }
  Z2_FORWARD_EXCEPTIONS;
 
  // Move the rows, creating a new graph.
  RCP<User> outPtr = XpetraTraits<User>::doMigration(in, numNewVtx,
                                                     importList.getRawPtr());
  out = outPtr.get();
  outPtr.release();
}
 
template <typename User, typename UserCoord>
  template<typename Adapter>
    void XpetraCrsGraphAdapter<User,UserCoord>::applyPartitioningSolution(
      const User &in, RCP<User> &out,
      const PartitioningSolution<Adapter> &solution) const
{
  // Get an import list (rows to be received)
  size_t numNewVtx;
  ArrayRCP<gno_t> importList;
  try{
    numNewVtx = Zoltan2::getImportList<Adapter,
                                       XpetraCrsGraphAdapter<User,UserCoord> >
                                      (solution, this, importList);
  }
  Z2_FORWARD_EXCEPTIONS;
 
  // Move the rows, creating a new graph.
  out = XpetraTraits<User>::doMigration(in, numNewVtx,
                                        importList.getRawPtr());
}
 
}  //namespace Zoltan2
 
#endif