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>
#include "Tpetra_DefaultPlatform.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 BaseAdapter<User> {
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>::part_t                part_t;
  typedef typename InputTraits<User>::node_t                node_t;
  typedef User                                              user_t;
  typedef User                                              userCoord_t;
  typedef int nonzero_t;  // adjacency matrix doesn't need scalar_t
  typedef Tpetra::CrsMatrix<nonzero_t,lno_t,gno_t,node_t>   sparse_matrix_type;
  typedef Tpetra::Map<lno_t, gno_t, node_t>                 map_type;
#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 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_IN_ADAPTER
  }

  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 gno_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;
  }

  virtual void get2ndAdjsView(MeshEntityType sourcetarget,
                              MeshEntityType through,
                              const lno_t *&offsets,
                              const gno_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
  }

  // 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 gno_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);
  }

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