Zoltan2_MatrixAdapter.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//   Zoltan2: A package of combinatorial algorithms for scientific computing
//                  Copyright 2012 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Karen Devine      (kddevin@sandia.gov)
//                    Erik Boman        (egboman@sandia.gov)
//                    Siva Rajamanickam (srajama@sandia.gov)
//
// ***********************************************************************
//
// @HEADER

#ifndef _ZOLTAN2_MATRIXADAPTER_HPP_
#define _ZOLTAN2_MATRIXADAPTER_HPP_

#include <Zoltan2_Adapter.hpp>
#include <Zoltan2_VectorAdapter.hpp>

namespace Zoltan2 {

enum MatrixEntityType {
  MATRIX_ROW,
  MATRIX_COLUMN,
  MATRIX_NONZERO
};

template <typename User, typename UserCoord=User>
  class MatrixAdapter : public AdapterWithCoordsWrapper<User, UserCoord> {
private:
  enum MatrixEntityType primaryEntityType_;
  VectorAdapter<UserCoord> *coordinateInput_;
  bool haveCoordinateInput_;

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 part_t = typename InputTraits<User>::part_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 = MatrixAdapter<User,UserCoord>;
  using device_t = typename node_t::device_type;
#endif

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

  // Constructor; sets default primaryEntityType to MATRIX_ROW.
  MatrixAdapter() : primaryEntityType_(MATRIX_ROW),
                    coordinateInput_(),
                    haveCoordinateInput_(false) {}

  virtual size_t getLocalNumRows() const = 0;

  virtual size_t getLocalNumColumns() const = 0;

  virtual size_t getLocalNumEntries() const = 0;



  virtual bool CRSViewAvailable() const { return false; }

  virtual void getRowIDsView(const gno_t *&rowIds) const
  {
    rowIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getRowIDsHostView(typename BaseAdapter<User>::ConstIdsHostView& rowIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getRowIDsDeviceView(typename BaseAdapter<User>::ConstIdsDeviceView& rowIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getCRSView(ArrayRCP<const offset_t> &offsets, ArrayRCP<const gno_t> &colIds) const
  {
    // Default implementation; no CRS view provided.
    offsets = ArrayRCP<const offset_t>();
    colIds = ArrayRCP<const gno_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getCRSHostView(typename BaseAdapter<User>::ConstOffsetsHostView& offsets,
                              typename BaseAdapter<User>::ConstIdsHostView& colIds) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getCRSDeviceView(typename BaseAdapter<User>::ConstOffsetsDeviceView& offsets,
                                typename BaseAdapter<User>::ConstIdsDeviceView& colIds) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }


  virtual void getCRSView(ArrayRCP<const offset_t> &offsets,
                          ArrayRCP<const gno_t> &colIds,
                          ArrayRCP<const scalar_t> &values) const
  {
    // Default implementation; no CRS view provided.
    offsets = ArrayRCP<const offset_t>();
    colIds = ArrayRCP<const gno_t>();
    values = ArrayRCP<const scalar_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getCRSHostView(typename BaseAdapter<User>::ConstOffsetsHostView& offsets,
                              typename BaseAdapter<User>::ConstIdsHostView& colIds,
                              typename BaseAdapter<User>::ConstScalarsHostView& values) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getCRSDeviceView(typename BaseAdapter<User>::ConstOffsetsDeviceView& offsets,
                                typename BaseAdapter<User>::ConstIdsDeviceView& colIds,
                                typename BaseAdapter<User>::ConstScalarsDeviceView& values) const
  {
      Z2_THROW_NOT_IMPLEMENTED
  }


  virtual int getNumWeightsPerRow() const { return 0;}

  virtual void getRowWeightsView(const scalar_t *&weights, int &stride,
                                 int idx = 0) const
  {
    // Default implementation
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getRowWeightsHostView(typename BaseAdapter<User>::WeightsHostView1D& weights,
                                     int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getRowWeightsHostView(typename BaseAdapter<User>::WeightsHostView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getRowWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView1D& weights,
                                       int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getRowWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual bool useNumNonzerosAsRowWeight(int idx) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual bool CCSViewAvailable() const { return false; }

  virtual void getColumnIDsView(const gno_t *&colIds) const
  {
    colIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getColumnIDsHostView(typename BaseAdapter<User>::ConstIdsHostView& colIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getColumnIDsDeviceView(typename BaseAdapter<User>::ConstIdsDeviceView& colIds) const
  {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getCCSView(ArrayRCP<const offset_t> &offsets,
                          ArrayRCP<const gno_t> &rowIds) const
  {
    // Default implementation; no CCS view provided.
    offsets = ArrayRCP<const offset_t>();
    rowIds = ArrayRCP<const gno_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getCCSView(ArrayRCP<const offset_t> &offsets,
                          ArrayRCP<const gno_t> &rowIds,
                          ArrayRCP<const scalar_t> &values) const
  {
    // Default implementation; no CCS view provided.
    offsets = ArrayRCP<const offset_t>();
    rowIds = ArrayRCP<const gno_t>();
    values = ArrayRCP<const scalar_t>();
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual int getNumWeightsPerColumn() const { return 0; }

  virtual void getColumnWeightsView(const scalar_t *&weights, int &stride,
                                    int idx = 0) const
  {
    // Default implementation
    weights = NULL;
    stride = 0;
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getColumnWeightsHostView(typename BaseAdapter<User>::WeightsHostView1D& weights,
                                     int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getColumnWeightsHostView(typename BaseAdapter<User>::WeightsHostView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getColumnWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView1D& weights,
                                       int /* idx */ = 0) const {
      Z2_THROW_NOT_IMPLEMENTED
  }

  virtual void getColumnWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView &weights) const {
    Z2_THROW_NOT_IMPLEMENTED
  }

  virtual bool useNumNonzerosAsColumnWeight(int idx) const { return 0; }

#ifdef FUTURE_FEATURE

  virtual bool symmetricStorage() const {return false;}
#endif

  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 and other methods shared by all

  inline enum MatrixEntityType getPrimaryEntityType() const
  {
    return this->primaryEntityType_;
  }

  void setPrimaryEntityType(std::string typestr)
  {
    if (typestr == "row") {
      this->primaryEntityType = MATRIX_ROW;
    }
    else if (typestr == "column") {
      this->primaryEntityType = MATRIX_COLUMN;
    }
    else if (typestr == "nonzero") {
      this->primaryEntityType = MATRIX_NONZERO;
    }
    else {
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  Invalid MatrixEntityType " << typestr << std::endl;
      emsg << "Valid values are 'row', 'column' and 'nonzero'." << std::endl;
      throw std::runtime_error(emsg.str());
    }
  }

  // Functions from the BaseAdapter interface
  size_t getLocalNumIDs() const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      return getLocalNumRows();
    case MATRIX_COLUMN:
      return getLocalNumColumns();
    case MATRIX_NONZERO:
      return getLocalNumEntries();
    default:   // Shouldn't reach default; just making compiler happy
      return 0;
    }
  }

  void getIDsView(const gno_t *&Ids) const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowIDsView(Ids);
      break;
    case MATRIX_COLUMN:
      getColumnIDsView(Ids);
      break;
    case MATRIX_NONZERO: {
      // TODO:  Need getNonzeroIDsView?  What is a Nonzero ID?
      // TODO:  std::pair<gno_t, gno_t>?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getIDsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }

  void getIDsHostView(typename BaseAdapter<User>::ConstIdsHostView& ids) const override {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowIDsHostView(ids);
      break;
    case MATRIX_COLUMN:
      getColumnIDsHostView(ids);
      break;
    case MATRIX_NONZERO: {
      // TODO:  Need getNonzeroIDsHostView?  What is a Nonzero ID?
      // TODO:  std::pair<gno_t, gno_t>?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getIDsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }

  void getIDsDeviceView(typename BaseAdapter<User>::ConstIdsDeviceView& ids) const override {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowIDsDeviceView(ids);
      break;
    case MATRIX_COLUMN:
      getColumnIDsDeviceView(ids);
      break;
    case MATRIX_NONZERO: {
      // TODO:  Need getNonzeroIDsDeviceView?  What is a Nonzero ID?
      // TODO:  std::pair<gno_t, gno_t>?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getIDsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }

  int getNumWeightsPerID() const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      return getNumWeightsPerRow();
    case MATRIX_COLUMN:
      return getNumWeightsPerColumn();
    case MATRIX_NONZERO:
      return 0;  //TODO: weights not yet supported for nonzeros
    default:   // Shouldn't reach default; just making compiler happy
      return 0;
    }
  }

  void getWeightsView(const scalar_t *&wgt, int &stride,
                      int idx = 0) const override
  {
    switch (getPrimaryEntityType()) {
    case MATRIX_ROW:
      getRowWeightsView(wgt, stride, idx);
      break;
    case MATRIX_COLUMN:
      getColumnWeightsView(wgt, stride, idx);
      break;
    case MATRIX_NONZERO:
      {
      // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
      // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  getWeightsView not yet supported for matrix nonzeros."
           << std::endl;
      throw std::runtime_error(emsg.str());
      }
    default:   // Shouldn't reach default; just making compiler happy
      break;
    }
  }

  void getWeightsHostView(typename BaseAdapter<User>::WeightsHostView &hostWgts) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsHostView(hostWgts);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsHostView(hostWgts);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }

  void getWeightsHostView(typename BaseAdapter<User>::WeightsHostView1D &hostWgts,
                                  int idx = 0) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsHostView(hostWgts, idx);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsHostView(hostWgts, idx);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }

  void getWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView& deviceWgts) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsDeviceView(deviceWgts);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsDeviceView(deviceWgts);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }

  void getWeightsDeviceView(typename BaseAdapter<User>::WeightsDeviceView1D& deviceWgts,
                                    int idx = 0) const override {
      switch (getPrimaryEntityType()) {
      case MATRIX_ROW:
        getRowWeightsDeviceView(deviceWgts, idx);
        break;
      case MATRIX_COLUMN:
        getColumnWeightsDeviceView(deviceWgts, idx);
        break;
      case MATRIX_NONZERO:
        {
        // TODO:  Need getNonzeroWeightsView with Nonzeros as primary object?
        // TODO:  That is, get Nonzeros' weights based on some nonzero ID?
        std::ostringstream emsg;
        emsg << __FILE__ << "," << __LINE__
             << " error:  getWeightsView not yet supported for matrix nonzeros."
             << std::endl;
        throw std::runtime_error(emsg.str());
        }
      default:   // Shouldn't reach default; just making compiler happy
        break;
      }  }

  bool useDegreeAsWeight(int idx) const
  {
    if (this->getPrimaryEntityType() == MATRIX_ROW)
      return useNumNonzerosAsRowWeight(idx);
    else {
      std::ostringstream emsg;
      emsg << __FILE__ << "," << __LINE__
           << " error:  useDegreeAsWeight is currently supported only for rows"
           << std::endl;
      throw std::runtime_error(emsg.str());
    }
  }
};

}  //namespace Zoltan2

#endif