Zoltan2_MeshAdapter.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_MESHADAPTER_HPP_
#define _ZOLTAN2_MESHADAPTER_HPP_

#include <Zoltan2_Adapter.hpp>

namespace Zoltan2 {
  
enum MeshEntityType {
  MESH_REGION,
  MESH_FACE,
  MESH_EDGE,
  MESH_VERTEX
};
  template <typename User>
  class MeshAdapter : public BaseAdapter<User> {
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.

public:

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  typedef typename InputTraits<User>::scalar_t    scalar_t;
  typedef typename InputTraits<User>::lno_t    lno_t;
  typedef typename InputTraits<User>::gno_t    gno_t;
  typedef typename InputTraits<User>::zgid_t    zgid_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;
#endif
  
  enum BaseAdapterType adapterType() const {return MeshAdapterType;}
  
  virtual ~MeshAdapter() {};
  
  // 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 size_t getLocalNumOf(MeshEntityType etype) const = 0;
  
  
  virtual void getIDsViewOf(MeshEntityType etype,
                            zgid_t const *&Ids) const = 0;


  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_IN_ADAPTER
  }


  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_IN_ADAPTER
  }


  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 lno_t *&offsets, const zgid_t *& adjacencyIds) const 
  {
    offsets = NULL;
    adjacencyIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED_IN_ADAPTER
  }


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


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

// TODO:  Later may allow user to not implement second adjacencies and, if we want them,
// TODO:  we compute A^T A, where A is matrix of first adjacencies.
  virtual void get2ndAdjsView(MeshEntityType sourcetarget,
                              MeshEntityType through,
                              const lno_t *&offsets,
                              const zgid_t *&adjacencyIds) const
  {
    offsets = NULL;
    adjacencyIds = NULL;
    Z2_THROW_NOT_IMPLEMENTED_IN_ADAPTER
  }


  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_IN_ADAPTER
  }

//KDD What if we wanted to provide weights with respect to first adjacencies?
//KDD Should we add functions for that?
//VJL Yes.

  // 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 {
    return getLocalNumOf(getPrimaryEntityType());
  }
  
  void getIDsView(const zgid_t *&Ids) const {
    getIDsViewOf(getPrimaryEntityType(), Ids);
  }
  
  int getNumWeightsPerID() const {
    return getNumWeightsPerOf(getPrimaryEntityType());
  }
  
  void getWeightsView(const scalar_t *&wgt, int &stride, int idx = 0) const {
    getWeightsViewOf(getPrimaryEntityType(), wgt, stride, idx);
  }

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

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

#endif