grid_base_objects.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__LIB_GRID__GEOMETRIC_BASE_OBJECTS__
#define __H__LIB_GRID__GEOMETRIC_BASE_OBJECTS__
 
#include <list>
#include <cassert>
#include <iostream>
#include <utility>
#include "common/types.h"
#include "common/common.h"
#include "common/assert.h"
#include "lib_grid/attachments/attachment_pipe.h"
#include "lib_grid/attachments/attached_list.h"
#include "common/util/hash_function.h"
#include "common/allocators/small_object_allocator.h"
#include "common/math/ugmath_types.h"
#include "common/util/pointer_const_array.h"
 
namespace ug
{
//  CONSTANTS
 
enum GridBaseObjectId
{
  VERTEX = 0,
  EDGE,
  FACE,
  VOLUME,
  NUM_GEOMETRIC_BASE_OBJECTS    //always last!!!
};
enum GridBaseObjectId {…};
 
extern const char* GRID_BASE_OBJECT_SINGULAR_NAMES[];
extern const char* GRID_BASE_OBJECT_PLURAL_NAMES[];
 
//  Reference-Object IDs
enum ReferenceObjectID
{
  ROID_UNKNOWN = -1,
  ROID_VERTEX,
  ROID_EDGE,
  ROID_TRIANGLE,
  ROID_QUADRILATERAL,
  ROID_TETRAHEDRON,
  ROID_HEXAHEDRON,
  ROID_PRISM,
  ROID_PYRAMID,
  ROID_OCTAHEDRON,
  NUM_REFERENCE_OBJECTS
};
enum ReferenceObjectID {…};
 
inline
ReferenceObjectID operator++(ReferenceObjectID& roid, int)
{
  int tmp = roid;
  return roid = static_cast<ReferenceObjectID>(++tmp);
};
ReferenceObjectID operator++(ReferenceObjectID& roid, int) {…}
 
inline
std::ostream& operator<< (std::ostream& outStream, ReferenceObjectID type)
{
  switch(type)
  {
    case ROID_UNKNOWN: outStream << "(invalid)"; break;
    case ROID_VERTEX: outStream << "Vertex"; break;
    case ROID_EDGE: outStream << "Edge"; break;
    case ROID_TRIANGLE: outStream << "Triangle"; break;
    case ROID_QUADRILATERAL: outStream << "Quadrilateral"; break;
    case ROID_TETRAHEDRON: outStream << "Tetrahedron"; break;
    case ROID_OCTAHEDRON: outStream << "Octahedron"; break;
    case ROID_HEXAHEDRON: outStream << "Hexahedron"; break;
    case ROID_PRISM: outStream << "Prism"; break;
    case ROID_PYRAMID: outStream << "Pyramid"; break;
    default: throw(UGError("Unknown ReferenceObjectID in operator<<"));
  }
  return outStream;
};
std::ostream& operator<< (std::ostream& outStream, ReferenceObjectID type) {…}
 
 
//  PREDECLARATIONS
class Grid;
template<class TElem> class ElementStorage;
 
class GridObject; //  geometric base object
class Vertex;   //  base for all 0-dimensional grid objects.
class Edge;     //  base for all 1-dimensional grid objects.
class Face;       //  base for all 2-dimensional grid objects.
class Volume;     //  base for all 3-dimensional grid objects.
 
class EdgeDescriptor; //  describes an edge.
class FaceDescriptor; //  describes a face.
class VolumeDescriptor; //  describes a volume.
 
class EdgeVertices;   //  manages the vertices of an edge. Base for Edge and EdgeDescriptor.
class FaceVertices;   //  manages the vertices of a face. Base for Face and FaceDescriptor.
class VolumeVertices; //  manages the vertices of a volume. Base for Volume and VolumeDescriptor.
 
template<> class attachment_traits<Vertex*, ElementStorage<Vertex> >;
template<> class attachment_traits<Edge*, ElementStorage<Edge> >;
template<> class attachment_traits<Face*, ElementStorage<Face> >;
template<> class attachment_traits<Volume*, ElementStorage<Volume> >;
 
//  GridObject
 
class UG_API GridObject/* : public SmallObject<>*/
{
  friend class Grid;
  friend class attachment_traits<Vertex*, ElementStorage<Vertex> >;
  friend class attachment_traits<Edge*, ElementStorage<Edge> >;
  friend class attachment_traits<Face*, ElementStorage<Face> >;
  friend class attachment_traits<Volume*, ElementStorage<Volume> >;
 
  public:
    virtual ~GridObject() {}
 
 
    virtual GridObject* create_empty_instance() const {return NULL;}
 
    virtual int container_section() const = 0;
    virtual int base_object_id() const = 0;
    virtual ReferenceObjectID reference_object_id() const = 0;
 
 
    virtual bool is_constraining() const          {return false;}
 
 
    virtual bool is_constrained() const           {return false;}
 
 
    virtual void remove_constraint_link(const Vertex* vrt)    {}
    virtual void remove_constraint_link(const Edge* e)      {}
    virtual void remove_constraint_link(const Face* f)      {}
 
    inline uint grid_data_index() const       {return m_gridDataIndex;}
 
  protected:
 
    inline void set_grid_data_index(uint index)   {m_gridDataIndex = index;}
 
  protected:
    uint            m_gridDataIndex;//  index to grid-attached data.
};
class UG_API GridObject/* : public SmallObject<>*/ {…};
 
 
 
//  Vertex
 
class UG_API Vertex : public GridObject
{
  friend class Grid;
  public:
    typedef Vertex grid_base_object;
 
  //  lower dimensional Base Object
    typedef void lower_dim_base_object;
 
  //  higher dimensional Base Object
    typedef Edge higher_dim_base_object;
 
    typedef Vertex side;
    typedef Edge sideof;
 
    static const bool HAS_SIDES = false;
    static const bool CAN_BE_SIDE = true;
 
    static const int dim = 0;
 
    static const int BASE_OBJECT_ID = VERTEX;
 
    static const size_t NUM_VERTICES = 1;
 
  public:
    inline static bool type_match(GridObject* pObj) {return dynamic_cast<Vertex*>(pObj) != NULL;}
 
    virtual ~Vertex() {}
 
    inline uint num_sides() const {return 0;}
 
    virtual int container_section() const {return -1;}
    virtual int base_object_id() const    {return VERTEX;}
    virtual ReferenceObjectID reference_object_id() const {return ROID_UNKNOWN;}
 
 
    inline uint32 get_hash_value() const  {return m_hashValue;}
 
  protected:
    uint32  m_hashValue;//  a unique value for each vertex in a grid.
};
class UG_API Vertex : public GridObject {…};
 
 
 
class UG_API VertexDescriptor {
public:
  typedef Vertex* const* ConstVertexArray;
 
  VertexDescriptor()  {}
  VertexDescriptor(Vertex* v) : m_v(v)  {}
  VertexDescriptor(const VertexDescriptor& d) : m_v (d.m_v) {}
 
  VertexDescriptor& operator = (const VertexDescriptor& d)
  {m_v = d.m_v; return *this;}
  VertexDescriptor& operator = (const VertexDescriptor& d) {…}
 
  inline void set_vertex(Vertex* v)   {m_v = v;}
  inline void set_vertex(uint, Vertex* v) {m_v = v;}
 
  inline Vertex* vertex () const        {return m_v;}
  virtual Vertex* vertex(size_t) const    {return m_v;}
  Vertex* operator[](size_t) const      {return m_v;}
 
  virtual ConstVertexArray vertices() const {return &m_v;}
  virtual size_t num_vertices() const     {return 1;}
 
//  compatibility with std::vector for some template routines
  inline size_t size() const          {return 1;}
 
private:
  Vertex* m_v;
};
class UG_API VertexDescriptor {…};
 
 
class UG_API IVertexGroup
{
  public:
    typedef Vertex* const* ConstVertexArray;
 
    virtual ~IVertexGroup() {};
    virtual Vertex* vertex(size_t index) const = 0;
    virtual ConstVertexArray vertices() const = 0;
    virtual size_t num_vertices() const = 0;
 
  //  compatibility with std::vector for some template routines
    inline size_t size() const  {return num_vertices();}
    inline Vertex* operator[](size_t index) const {return vertex(index);}
};
class UG_API IVertexGroup {…};
 
 
class UG_API CustomVertexGroup : public IVertexGroup
{
  public:
    CustomVertexGroup()             {}
    CustomVertexGroup(size_t numVrts)     {m_vrts.resize(numVrts);}
    virtual ~CustomVertexGroup()        {}
 
    virtual Vertex* vertex(size_t index) const  {return m_vrts[index];}
    virtual ConstVertexArray vertices() const {return &m_vrts.front();}
    virtual size_t num_vertices() const     {return m_vrts.size();}
 
    void set_num_vertices(size_t newSize)   {m_vrts.resize(newSize);}
    void resize(size_t newSize)         {m_vrts.resize(newSize);}
    void clear()                {m_vrts.clear();}
    void push_back(Vertex* vrt)         {m_vrts.push_back(vrt);}
    void set_vertex(size_t index, Vertex* vrt)  {m_vrts[index] = vrt;}
 
  private:
    std::vector<Vertex*>  m_vrts;
};
class UG_API CustomVertexGroup : public IVertexGroup {…};
 
 
 
//  EdgeVertices
class UG_API EdgeVertices : public IVertexGroup
{
  friend class Grid;
  public:
    virtual ~EdgeVertices()           {}
    virtual Vertex* vertex(size_t index) const  {return m_vertices[index];}
    virtual ConstVertexArray vertices() const {return m_vertices;}
    virtual size_t num_vertices() const     {return 2;}
 
  //  compatibility with std::vector for some template routines
    inline size_t size() const          {return 2;}
    Vertex* operator[](size_t index) const    {return m_vertices[index];}
 
  protected:
    inline void assign_edge_vertices(const EdgeVertices& ev)
    {
      m_vertices[0] = ev.m_vertices[0];
      m_vertices[1] = ev.m_vertices[1];
    }
    inline void assign_edge_vertices(const EdgeVertices& ev) {…}
 
  protected:
    Vertex* m_vertices[2];
};
class UG_API EdgeVertices : public IVertexGroup {…};
 
//  Edge
 
class UG_API Edge : public GridObject, public EdgeVertices
{
  friend class Grid;
  public:
    typedef Edge grid_base_object;
 
  //  lower dimensional Base Object
    typedef Vertex lower_dim_base_object;
  //  higher dimensional Base Object
    typedef Face higher_dim_base_object;
 
    typedef Vertex side;
    typedef Face sideof;
 
    static const bool HAS_SIDES = true;
    static const bool CAN_BE_SIDE = true;
 
    static const int dim = 1;
 
    static const int BASE_OBJECT_ID = EDGE;
 
    static const size_t NUM_VERTICES = 2;
 
  public:
    inline static bool type_match(GridObject* pObj) {return dynamic_cast<Edge*>(pObj) != NULL;}
 
    virtual ~Edge() {}
 
    virtual int container_section() const {return -1;}
    virtual int base_object_id() const    {return EDGE;}
    virtual ReferenceObjectID reference_object_id() const {return ROID_UNKNOWN;}
 
    inline uint num_sides() const {return 2;}
 
 
    bool get_opposing_side(Vertex* v, Vertex** vrtOut);
 
    bool get_opposing_side(Vertex* v, VertexDescriptor& vrtOut);
 
    virtual bool refine(std::vector<Edge*>& vNewEdgesOut,
                      Vertex* newVertex,
                      Vertex** pSubstituteVrts = NULL)  {return false;}
    virtual bool refine(std::vector<Edge*>& vNewEdgesOut, {…}
 
  protected:
    inline void set_vertex(uint index, Vertex* pVrt)  {m_vertices[index] = pVrt;}
};
class UG_API Edge : public GridObject, public EdgeVertices {…};
 
 
//  EdgeDescriptor
class UG_API EdgeDescriptor : public EdgeVertices
{
  public:
    EdgeDescriptor();
    EdgeDescriptor(const EdgeDescriptor& ed);
    EdgeDescriptor(Vertex* vrt1, Vertex* vrt2);
 
    EdgeDescriptor& operator = (const EdgeDescriptor& ed);
 
    inline void set_vertex(uint index, Vertex* vrt) {m_vertices[index] = vrt;}
    inline void set_vertices(Vertex* vrt1, Vertex* vrt2)
      {
        m_vertices[0] = vrt1;
        m_vertices[1] = vrt2;
      }
    inline void set_vertices(Vertex* vrt1, Vertex* vrt2) {…}
};
class UG_API EdgeDescriptor : public EdgeVertices {…};
 
 
 
class UG_API FaceVertices : public IVertexGroup
{
  public:
    virtual ~FaceVertices()             {}
    virtual Vertex* vertex(size_t index) const    {UG_ASSERT(0, "SHOULDN'T BE CALLED"); return NULL;}
    virtual ConstVertexArray vertices() const   {UG_ASSERT(0, "SHOULDN'T BE CALLED"); return NULL;}
    virtual size_t num_vertices() const       {UG_ASSERT(0, "SHOULDN'T BE CALLED"); return 0;}
 
  //  compatibility with std::vector for some template routines
    inline size_t size() const  {return num_vertices();}
    inline Vertex* operator[](size_t index) const {return vertex(index);}
};
class UG_API FaceVertices : public IVertexGroup {…};
 
//  Face
 
class UG_API Face : public GridObject, public FaceVertices
{
  friend class Grid;
  public:
    typedef Face grid_base_object;
 
  //  lower dimensional Base Object
    typedef Edge lower_dim_base_object;
  //  higher dimensional Base Object
    typedef Volume higher_dim_base_object;
 
    typedef Edge side;
    typedef Volume sideof;
 
    static const bool HAS_SIDES = true;
    static const bool CAN_BE_SIDE = true;
 
    static const int dim = 2;
    static const int BASE_OBJECT_ID = FACE;
 
  public:
    inline static bool type_match(GridObject* pObj) {return dynamic_cast<Face*>(pObj) != NULL;}
 
    virtual ~Face() {}
 
 
    virtual EdgeDescriptor edge_desc(int index) const
      {return EdgeDescriptor(vertex(index), vertex((index+1) % size()));}
    virtual EdgeDescriptor edge_desc(int index) const {…}
 
 
    virtual void edge_desc(int index, EdgeDescriptor& edOut) const
      {edOut.set_vertices(vertex(index), vertex((index+1) % size()));}
    virtual void edge_desc(int index, EdgeDescriptor& edOut) const {…}
 
    inline uint num_edges() const {return (uint)num_vertices();}
    inline uint num_sides() const {return num_edges();}
 
    virtual int container_section() const {return -1;}
    virtual int base_object_id() const    {return FACE;}
    virtual ReferenceObjectID reference_object_id() const {return ROID_UNKNOWN;}
 
    virtual Edge* create_edge(int index)  {return NULL;}  
 
 
 
    virtual bool get_opposing_side(EdgeVertices* e, EdgeDescriptor& edOut) const  {return false;}
 
 
    virtual std::pair<GridBaseObjectId, int>
    get_opposing_object(Vertex* vrt) const  {UG_THROW("Base method not implemented.");}
 
 
    int get_local_side_index(EdgeVertices* e) const;
 
    virtual bool refine(std::vector<Face*>& vNewFacesOut,
              Vertex** newFaceVertexOut,
              Vertex** newEdgeVertices,
              Vertex* newFaceVertex = NULL,
              Vertex** pSubstituteVertices = NULL,
              int snapPointIndex = -1)  {return false;}
    virtual bool refine(std::vector<Face*>& vNewFacesOut, {…}
 
 
 
    virtual bool is_regular_ref_rule(int edgeMarks) const {return false;}
 
    virtual bool collapse_edge(std::vector<Face*>& vNewFacesOut,
                int edgeIndex, Vertex* newVertex,
                Vertex** pSubstituteVertices = NULL)  {return false;}
    virtual bool collapse_edge(std::vector<Face*>& vNewFacesOut, {…}
 
    virtual bool collapse_edges(std::vector<Face*>& vNewFacesOut,
                std::vector<Vertex*>& vNewEdgeVertices,
                Vertex** pSubstituteVertices = NULL)  {return false;}
    virtual bool collapse_edges(std::vector<Face*>& vNewFacesOut, {…}
 
// BEGIN Depreciated
    virtual void create_faces_by_edge_split(int splitEdgeIndex,
              Vertex* newVertex,
              std::vector<Face*>& vNewFacesOut,
              Vertex** pSubstituteVertices = NULL)  {};
    virtual void create_faces_by_edge_split(int splitEdgeIndex, {…}
// END Depreciated
 
    //virtual void create_faces_by_edge_collapse(int collapseEdgeIndex,
    //            Vertex* newVertex,
    //            std::vector<Face*>& vNewFacesOut) = 0;
 
  protected:
    virtual void set_vertex(uint index, Vertex* pVrt) {UG_ASSERT(0, "SHOULDN'T BE CALLED");}
};
class UG_API Face : public GridObject, public FaceVertices {…};
 
 
 
const int MAX_FACE_VERTICES = 4;
 
//  FaceDescriptor
class UG_API FaceDescriptor : public FaceVertices
{
  public:
    FaceDescriptor();
    FaceDescriptor(uint numVertices);
    FaceDescriptor(const FaceDescriptor& fd);
    FaceDescriptor(Vertex* v0, Vertex* v1, Vertex* v2) :
      m_numVertices(3)
      {m_vertices[0] = v0; m_vertices[1] = v1; m_vertices[2] = v2;}
    FaceDescriptor(Vertex* v0, Vertex* v1, Vertex* v2) : {…}
 
    FaceDescriptor(Vertex* v0, Vertex* v1, Vertex* v2, Vertex* v3) :
      m_numVertices(4)
      {m_vertices[0] = v0; m_vertices[1] = v1; m_vertices[2] = v2; m_vertices[3] = v3;}
    FaceDescriptor(Vertex* v0, Vertex* v1, Vertex* v2, Vertex* v3) : {…}
 
    virtual ~FaceDescriptor()         {}
 
    FaceDescriptor& operator = (const FaceDescriptor& fd);
 
    virtual Vertex* vertex(size_t index) const  {return m_vertices[index];}
    virtual ConstVertexArray vertices() const   {return m_vertices;}
    virtual size_t num_vertices() const       {return m_numVertices;}
 
    inline void set_num_vertices(uint numVertices)  {m_numVertices = numVertices;}
    inline void set_vertex(uint index, Vertex* vrt)
      {m_vertices[index] = vrt;}
    inline void set_vertex(uint index, Vertex* vrt) {…}
 
  protected:
    Vertex* m_vertices[MAX_FACE_VERTICES];
    uint    m_numVertices;
};
class UG_API FaceDescriptor : public FaceVertices {…};
 
 
//  VOLUMES
 
//  VolumeVertices
class UG_API VolumeVertices : public IVertexGroup
{
  public:
    virtual ~VolumeVertices()           {}
 
    virtual Vertex* vertex(size_t index) const  {UG_ASSERT(0, "SHOULDN'T BE CALLED"); return NULL;}
    virtual ConstVertexArray vertices() const   {UG_ASSERT(0, "SHOULDN'T BE CALLED"); return NULL;}
    virtual size_t num_vertices() const       {UG_ASSERT(0, "SHOULDN'T BE CALLED"); return 0;}
 
  //  compatibility with std::vector for some template routines
    inline size_t size() const  {return num_vertices();}
    inline Vertex* operator[](size_t index) const {return vertex(index);}
};
class UG_API VolumeVertices : public IVertexGroup {…};
 
//  Volume
 
class UG_API Volume : public GridObject, public VolumeVertices
{
  friend class Grid;
  public:
    typedef Volume grid_base_object;
 
  //  lower dimensional Base Object
    typedef Face lower_dim_base_object;
  //  higher dimensional Base Object
    typedef void higher_dim_base_object;
 
    typedef Face side;
  //  this is just by convention. Use can_be_side() to stop recursions.
    typedef Volume sideof;
 
    static const bool HAS_SIDES = true;
    static const bool CAN_BE_SIDE = false;
 
    static const int dim = 3;
    static const int BASE_OBJECT_ID = VOLUME;
 
  public:
    inline static bool type_match(GridObject* pObj) {return dynamic_cast<Volume*>(pObj) != NULL;}
 
    virtual ~Volume() {}
 
    virtual EdgeDescriptor edge_desc(int index) const       {return EdgeDescriptor(NULL, NULL);}
    virtual void edge_desc(int index, EdgeDescriptor& edOut) const  {edOut = EdgeDescriptor(NULL, NULL);}
    virtual uint num_edges() const                  {return 0;}
 
    virtual FaceDescriptor face_desc(int index) const       {return FaceDescriptor(0);}
    virtual void face_desc(int index, FaceDescriptor& fdOut) const  {fdOut = FaceDescriptor(0);}
    virtual uint num_faces() const                  {return 0;}
    inline uint num_sides() const                 {return num_faces();}
 
    virtual Edge* create_edge(int index)  {return NULL;}  
    virtual Face* create_face(int index)    {return NULL;}  
    
 
    virtual void get_vertex_indices_of_edge(size_t& ind1Out,
                        size_t& ind2Out,
                        size_t edgeInd) const
    {UG_THROW("Base method not implemented.");};
    virtual void get_vertex_indices_of_edge(size_t& ind1Out, {…}
    
 
    virtual void get_vertex_indices_of_face(std::vector<size_t>& indsOut,
                        size_t side) const
    {UG_THROW("Base method not implemented.");}
    virtual void get_vertex_indices_of_face(std::vector<size_t>& indsOut, {…}
 
 
    virtual int get_edge_index_from_vertices( const size_t vi0,
                          const size_t vi1) const
    {UG_THROW("Base method not implemented.");};
    virtual int get_edge_index_from_vertices( const size_t vi0, {…}
 
 
    virtual int get_face_edge_index ( const size_t faceInd,
                      const size_t faceEdgeInd) const
    {UG_THROW("Base method not implemented.");};
    virtual int get_face_edge_index ( const size_t faceInd, {…}
 
 
    virtual bool get_opposing_side(FaceVertices* f, FaceDescriptor& fdOut) const  {return false;}
 
 
    virtual std::pair<GridBaseObjectId, int>
    get_opposing_object(Vertex* vrt) const
    {UG_THROW("Base method not implemented.");}
    get_opposing_object(Vertex* vrt) const {…}
 
    int get_local_side_index(FaceVertices* f) const;
 
    virtual bool refine(std::vector<Volume*>& vNewVolumesOut,
              Vertex** ppNewVertexOut,
              Vertex** newEdgeVertices,
              Vertex** newFaceVertices,
              Vertex* newVolumeVertex,
              const Vertex& prototypeVertex,
              Vertex** pSubstituteVertices = NULL,
              vector3* corners = NULL,
              bool* isSnapPoint = NULL) {return false;}
    virtual bool refine(std::vector<Volume*>& vNewVolumesOut, {…}
 
    
 
    virtual bool is_regular_ref_rule(int edgeMarks) const {return false;}
 
    virtual bool collapse_edge(std::vector<Volume*>& vNewVolumesOut,
                int edgeIndex, Vertex* newVertex,
                std::vector<Vertex*>* pvSubstituteVertices = NULL)  {return false;}
    virtual bool collapse_edge(std::vector<Volume*>& vNewVolumesOut, {…}
 
    virtual void get_flipped_orientation(VolumeDescriptor& vdOut) const;
    
    virtual int container_section() const {return -1;}
    virtual int base_object_id() const    {return VOLUME;}
    virtual ReferenceObjectID reference_object_id() const {return ROID_UNKNOWN;}
 
    //virtual void create_volumes_by_edge_split(int splitEdgeIndex,
    //            Vertex* newVertex,
    //            std::vector<Volume*>& vNewFacesOut) = 0;
 
    //virtual void create_Volumes_by_edge_collapse(int collapseEdgeIndex,
    //            Vertex* newVertex,
    //            std::vector<Volume*>& vNewFacesOut) = 0;
  protected:
    virtual void set_vertex(uint index, Vertex* pVrt) {UG_ASSERT(0, "SHOULDN'T BE CALLED");}
};
 
 
 
const int MAX_VOLUME_VERTICES = 8;
 
//  VolumeDescriptor
class UG_API VolumeDescriptor : public VolumeVertices
{
  public:
    VolumeDescriptor();
    VolumeDescriptor(uint numVertices);
    VolumeDescriptor(const VolumeDescriptor& vd);
 
    virtual ~VolumeDescriptor()                   {}
 
    VolumeDescriptor& operator = (const VolumeDescriptor& vv);
    VolumeDescriptor& operator = (const VolumeVertices& vv);
 
    virtual Vertex* vertex(size_t index) const  {return m_vertices[index];}
    virtual ConstVertexArray vertices() const   {return m_vertices;}
    virtual size_t num_vertices() const       {return m_numVertices;}
 
    inline void set_num_vertices(uint numVertices)    {m_numVertices = numVertices;}
    inline void set_vertex(uint index, Vertex* vrt) {m_vertices[index] = vrt;}
 
  protected:
    Vertex* m_vertices[MAX_VOLUME_VERTICES];
    uint    m_numVertices;
};
class UG_API VolumeDescriptor : public VolumeVertices {…};
 
 
 
 
template <int dim> struct GeomObjBaseTypeByDim;
 
template <> struct GeomObjBaseTypeByDim<0>{
  typedef Vertex base_obj_type;
};
template <> struct GeomObjBaseTypeByDim<0> {…};
 
template <> struct GeomObjBaseTypeByDim<1>{
  typedef Edge base_obj_type;
};
template <> struct GeomObjBaseTypeByDim<1> {…};
 
template <> struct GeomObjBaseTypeByDim<2>{
  typedef Face base_obj_type;
};
template <> struct GeomObjBaseTypeByDim<2> {…};
 
template <> struct GeomObjBaseTypeByDim<3>{
  typedef Volume base_obj_type;
};
template <> struct GeomObjBaseTypeByDim<3> {…};
 
 
template <class TGeomObjPtrType>
struct PtrToValueType
{typedef void base_type;};
struct PtrToValueType {…};
 
template <>
struct PtrToValueType<Vertex*>
{typedef Vertex base_type;};
struct PtrToValueType<Vertex*> {…};
 
template <>
struct PtrToValueType<Edge*>
{typedef Edge base_type;};
struct PtrToValueType<Edge*> {…};
 
template <>
struct PtrToValueType<Face*>
{typedef Face base_type;};
struct PtrToValueType<Face*> {…};
 
template <>
struct PtrToValueType<Volume*>
{typedef Volume base_type;};
struct PtrToValueType<Volume*> {…};
//  hash-funtions for vertices
size_t hash_key(Vertex* key);
 
//  hash-funtions for edges
 
size_t hash_key(EdgeVertices* key);
size_t hash_key(const EdgeVertices* key);
 
 
size_t hash_key(Edge* key);
 
 
size_t hash_key(EdgeDescriptor* key);
 
//  hash-funtions for faces
 
size_t hash_key(FaceVertices* key);
size_t hash_key(const FaceVertices* key);
 
 
size_t hash_key(Face* key);
 
 
size_t hash_key(FaceDescriptor* key);
 
//  hash-funtions for volumes
 
size_t hash_key(VolumeVertices* key);
size_t hash_key(const VolumeVertices* key);
 
 
size_t hash_key(Volume* key);
 
 
size_t hash_key(VolumeDescriptor* key);
 
}// end of namespace
 
#endif
    virtual Face* create_face(int index)    {return NULL;}   {…}
class UG_API Volume : public GridObject, public VolumeVertices {…};