Simple_manifold_2.h

Go to the documentation of this file.

/* *******************************************************************
 * Rocstar Simulation Suite                                          *
 * Copyright@2015, Illinois Rocstar LLC. All rights reserved.        *
 *                                                                   *
 * Illinois Rocstar LLC                                              *
 * Champaign, IL                                                     *
 * www.illinoisrocstar.com                                           *
 * sales@illinoisrocstar.com                                         *
 *                                                                   *
 * License: See LICENSE file in top level of distribution package or *
 * http://opensource.org/licenses/NCSA                               *
 *********************************************************************/
/* *******************************************************************
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,   *
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   *
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          *
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR           *
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   *
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE    *
 * USE OR OTHER DEALINGS WITH THE SOFTWARE.                          *
 *********************************************************************/
// $Id: Simple_manifold_2.h,v 1.9 2008/12/06 08:43:20 mtcampbe Exp $

//=======================================================================
//  This file defines a data structures for accessing a pane of a surface
//  mesh. It mimics the halfedge data structure.
//
//  Author: Xiangmin Jiao
//  Last modified: July 18, 2003
//=======================================================================

#ifndef __SIMPLE_MANIFOLD_2_H_
#define __SIMPLE_MANIFOLD_2_H_

#include "mapbasic.h"
#include "roccom_devel.h"
#include <cassert>

MAP_BEGIN_NAMESPACE

class Facet_ID {
public:
  enum { nDigits=4, BndID=15 };

  Facet_ID( ) : _code(0) {}
  Facet_ID( int eid, char lid) : _code( (eid<<nDigits)+(BndID&lid)) {}

  int  eid() const { return _code>>nDigits; }
  char lid() const { return _code&BndID; }

  bool is_border() const { return lid()==BndID; }

  bool operator==( const Facet_ID e) const 
  { return _code==e._code; }
  bool operator!=( const Facet_ID e) const 
  { return _code!=e._code; }
  bool operator<( const Facet_ID e) const 
  { return lid()<e.lid() || lid()==e.lid() && _code<e._code; }
private:
  int         _code;
};

class Simple_manifold_2 {
public:
  typedef Facet_ID Edge_ID;

  Simple_manifold_2() 
    : _pane(NULL), _is_str(0), _with_ghost(0), _nspe(0),
      _maxsize_real_nodes(-1), _maxsize_real_elmts(-1), 
      _size_real_borders(0), _size_ghost_borders(0), _size_rg_borders(0) {}

  explicit Simple_manifold_2( const COM::Pane *p, 
                              const Simple_manifold_2 *parent=NULL,
                              bool with_ghost=true)
  { init(p, parent, with_ghost); }

  const COM::Pane *pane() const { return _pane; }

  int size_of_nodes()    const { return _pane->size_of_nodes(); }

  int maxsize_of_nodes() const { return _pane->maxsize_of_nodes(); }

  int size_of_real_nodes()    const { return _pane->size_of_real_nodes(); }

  int maxsize_of_real_nodes() const { return _maxsize_real_nodes; }

  int size_of_ghost_nodes()    const { return _pane->size_of_ghost_nodes(); }

  int maxsize_of_ghost_nodes() const { return _pane->maxsize_of_ghost_nodes();}
  //\}

  int size_of_elements() const { return _pane->size_of_elements(); }

  int maxsize_of_elements()    const { return _pane->maxsize_of_elements(); }

  int size_of_real_elements()    const { return _pane->size_of_real_elements(); }

  int maxsize_of_real_elements()    const { return _maxsize_real_elmts; }

  int size_of_ghost_elements()    const { return _pane->size_of_ghost_elements(); }

  int maxsize_of_ghost_elements()    const { return _pane->maxsize_of_ghost_elements(); }

  int size_of_faces() const { return _pane->size_of_elements(); }

  int maxsize_of_faces() const { return _pane->maxsize_of_elements(); }

  int size_of_real_faces() const { return _pane->size_of_real_elements(); }

  int maxsize_of_real_faces() const { return _pane->maxsize_of_real_elements(); }

  int size_of_ghost_faces() const { return _pane->size_of_ghost_elements(); }

  int maxsize_of_ghost_faces() const { return _pane->maxsize_of_ghost_elements(); }

  int size_of_triangles() const;

  int maxsize_of_triangles() const;

  int size_of_real_triangles() const;

  int maxsize_of_real_triangles() const;

  int size_of_ghost_triangles() const;

  int maxsize_of_ghost_triangles() const;

  int size_of_quadrilaterals() const;

  int maxsize_of_quadrilaterals() const;

  int size_of_real_quadrilaterals() const;

  int maxsize_of_real_quadrilaterals() const;

  int size_of_ghost_quadrilaterals() const;

  int maxsize_of_ghost_quadrilaterals() const;
  //\}
  
  int size_of_halfedges() const;
  
  int size_of_real_halfedges() const;
  
  int size_of_ghost_halfedges() const;
  
  int size_of_edges() const;

  int size_of_real_edges() const;

  int size_of_ghost_edges() const;
  //\}

  int size_of_border_edges() const 
  { return _size_real_borders + _size_ghost_borders; }

  int size_of_real_border_edges() const
  { return _size_real_borders + _size_rg_borders; }

  int size_of_ghost_border_edges() const
  { return _size_ghost_borders + _size_rg_borders; }

  int size_of_isolated_nodes() const
  { return _isovIDs.size(); }
  //\}

  Edge_ID get_opposite_real_edge( const Edge_ID &eID) const {
    COM_assertion( eID.is_border() || is_real_element( eID.eid()));

    if ( eID.is_border())
      return get_opposite_real_edge_border(eID);
    else 
      return get_opposite_real_edge_interior(eID);
  }

  Edge_ID get_opposite_ghost_edge( const Edge_ID &eID) const { 
    COM_assertion( eID.is_border() || is_ghost_element( eID.eid()));

    if ( eID.is_border()) 
      return get_opposite_ghost_edge_border(eID);
    else 
      return get_opposite_ghost_edge_interior(eID);
  }

  Edge_ID get_opposite_edge( const Edge_ID &eID) const {

    if ( eID.is_border()) 
      return get_opposite_edge_border(eID);
    else 
      return get_opposite_edge_interior(eID);
  }
  //\}

  Edge_ID get_prev_edge( const Edge_ID &eID) const {
    if ( !eID.is_border()) 
      return get_prev_edge_interior( eID);
    else {
      Edge_ID oeID = get_opposite_edge( eID);
      while ( !oeID.is_border()) 
        oeID = get_opposite_edge_interior( get_next_edge_interior( oeID));
      return oeID;
    }
  }

  Edge_ID get_prev_real_edge( const Edge_ID &eID) const {
    if ( !eID.is_border()) 
      return get_prev_real_edge_interior( eID);
    else {
      Edge_ID oeID = get_opposite_real_edge( eID);
      while ( !oeID.is_border()) 
        oeID = get_opposite_real_edge_interior
          ( get_next_real_edge_interior( oeID));
      return oeID;
    }
  }

  Edge_ID get_prev_ghost_edge( const Edge_ID &eID) const {
    if ( !eID.is_border()) 
      return get_prev_ghost_edge_interior(eID);
    else {
      Edge_ID oeID = get_opposite_ghost_edge( eID);
      while ( !oeID.is_border()) 
        oeID = get_opposite_ghost_edge_interior
          ( get_next_ghost_edge_interior( oeID));
      return oeID;
    }
  }

  Edge_ID get_next_edge( const Edge_ID &eID) const {
    if ( !eID.is_border()) 
      return get_next_edge_interior( eID);
    else {
      Edge_ID oeID = get_opposite_edge_border( eID);
      while ( !oeID.is_border()) 
        oeID = get_opposite_edge_interior( get_prev_edge_interior( oeID));
      return oeID;
    }
  }
  
  Edge_ID get_next_real_edge( const Edge_ID &eID) const {
    if ( !eID.is_border()) 
      return get_next_real_edge_interior( eID);
    else {
      Edge_ID oeID = get_opposite_real_edge( eID);
      while ( !oeID.is_border()) 
        oeID = get_opposite_real_edge_interior
          ( get_prev_real_edge_interior( oeID));
      return oeID;
    }
  }
  
  Edge_ID get_next_ghost_edge( const Edge_ID &eID) const {
    if ( !eID.is_border()) 
      return get_next_ghost_edge_interior( eID);
    else {
      Edge_ID oeID = get_opposite_ghost_edge( eID);
      while ( !oeID.is_border()) 
        oeID = get_opposite_ghost_edge_interior
          ( get_prev_ghost_edge_interior( oeID));
      return oeID;
    }
  }
  //\}
  
  int get_origin( Edge_ID eID, Element_node_enumerator *ene_in=NULL) const  {
    if ( eID.is_border()) {
      Edge_ID opp;
      if (is_real_border_edge( eID)) opp = get_opposite_real_edge_border( eID);
      else opp = get_opposite_ghost_edge_border( eID);

      Element_node_enumerator ene( _pane, opp.eid());
      return ene[opp.lid()+1==ene.size_of_edges()?0:opp.lid()+1];
    }
    else {
      if ( ene_in) 
        return (*ene_in)[eID.lid()];
      else 
        return Element_node_enumerator( _pane, eID.eid())[eID.lid()];
    }
  }

  int get_destination( Edge_ID eID, Element_node_enumerator *ene_in=NULL) const {
    if ( eID.is_border()) {
      Edge_ID opp;
      if (is_real_border_edge( eID)) opp = get_opposite_real_edge_border( eID);
      else opp = get_opposite_ghost_edge_border( eID);
      
      Element_node_enumerator ene( _pane, opp.eid());
      return ene[opp.lid()];
    }
    else {
      if ( ene_in)
        return (*ene_in)[eID.lid()+1==ene_in->size_of_edges()?0:eID.lid()+1];
      else {
        Element_node_enumerator ene( _pane, eID.eid());
        return ene[eID.lid()+1==ene.size_of_edges()?0:eID.lid()+1];
      }
    }
  }
  
  Edge_ID get_incident_edge( int vID) const { 
    Edge_ID eID;
    if ( _is_str || !is_ghost_node( vID))
      eID = _ieIDs_real_or_str[ vID-1]; 
    else
      eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];

    // If the edge is between real and ghost, then return the real edge.
    if ( eID.is_border() && eID.eid()>_size_real_borders && 
         eID.eid()<=_size_real_borders+_size_rg_borders) {
      eID = _oeIDs_real_or_str[ get_edge_index(_beIDs[eID.eid()-1])];
      COM_assertion( get_origin( eID)==vID);
    }
    return eID;
  }

  Edge_ID get_incident_real_edge( int vID) const {
    COM_assertion( is_real_node( vID));
    Edge_ID eID = _ieIDs_real_or_str[ vID-1]; 

    if ( eID.is_border() && eID.eid()<=int(_beIDs.size()) &&
         eID.eid()>_size_real_borders+_size_rg_borders) {
      // If vID is between real and ghost, and on the ghost boundary,
      // get the border edge between real and ghost.
      Edge_ID eID0 = eID = get_opposite_ghost_edge_border( eID);
      while ( (eID = get_opposite_ghost_edge_interior
               ( get_next_ghost_edge_interior(eID))) != eID0 &&
              !is_real_border_edge( eID));
      COM_assertion_msg( eID.is_border() && get_origin( eID)==vID,
                         "No real edge incident on given vertex"); 
    }

    return eID;
  }

  Edge_ID get_incident_ghost_edge( int vID) const {
    bool isghost = is_ghost_node( vID);
    Edge_ID eID;
    if ( _is_str || !isghost)
      eID = _ieIDs_real_or_str[ vID-1]; 
    else
      eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];
    if ( isghost) return eID;

    if ( eID.is_border() && eID.eid()<=_size_real_borders) {
      // If vID is between real and ghost, and on the real boundary,
      // get the border edge between real and ghost.
      eID = get_opposite_real_edge_border( eID);
      Edge_ID eID0 = eID;
      while ( (eID = get_opposite_real_edge_interior
               ( get_next_real_edge_interior(eID))) != eID0 &&
              !is_ghost_border_edge( eID));
      COM_assertion_msg( eID.is_border(),
                         "No ghost edge incident on given vertex"); 
    }

    return eID;
  }
  //\}

  bool is_border_edge( const Edge_ID &eID) const { 
    if ( !eID.is_border()) return false;
    if ( eID.eid()>int(_beIDs.size())) return false;

    return !_with_ghost || eID.eid() <= _size_real_borders ||
      eID.eid() > _size_real_borders+_size_rg_borders;
  }

  bool is_pure_real_border_edge( const Edge_ID & eID) const {
    if ( !eID.is_border()) return false;

    return !_with_ghost || eID.eid() <= _size_real_borders;
  }

  bool is_real_border_edge( const Edge_ID & eID) const {
    if ( !eID.is_border()) return false;

    return !_with_ghost || eID.eid() <= _size_real_borders+_size_rg_borders;
  }

  bool is_ghost_border_edge( const Edge_ID & eID) const  {
    if ( !eID.is_border()) return false;
    if ( eID.eid()>int(_beIDs.size())) return false;

    return _with_ghost && eID.eid() > _size_real_borders;
  }

  bool is_isolated_node( int vID) const {
    // Ghost nodes are not allowed to be isolated.
    if ( _is_str || vID>_maxsize_real_nodes) return false;

    Edge_ID eID = _ieIDs_real_or_str[ vID-1];
    return eID.is_border() && eID.eid()>int(_beIDs.size());
  }
  
  bool is_real_border_node( int vID) const { 
    if ( !is_real_node( vID)) return false;
    Edge_ID eID;
    if ( _is_str || !is_ghost_node( vID))
      eID = _ieIDs_real_or_str[ vID-1]; 
    else
      eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];

    return eID.is_border() && eID.eid() <= int(_beIDs.size()); 
  }

  bool is_ghost_border_node( int vID) const { 
    Edge_ID eID;
    if ( _is_str || !is_ghost_node( vID))
      eID = _ieIDs_real_or_str[ vID-1]; 
    else
      eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];

    return eID.is_border() && eID.eid() <= int(_beIDs.size()); 
  }

  bool is_border_node( int vID) const  { 
    Edge_ID eID;
    if ( _is_str || !is_ghost_node( vID))
      eID = _ieIDs_real_or_str[ vID-1]; 
    else
      eID = _ieIDs_ghost[ vID-_maxsize_real_nodes-1];

    return is_border_edge( eID);
  }

  int get_border_edgeID( Edge_ID eID) const {
    if ( !eID.is_border()) { assert(false); return -1; }
    else return eID.eid();
  }

  Edge_ID get_a_real_border_edge() const {
    if ( _size_real_borders>0 || _size_rg_borders>0) 
      return Edge_ID( 1, Edge_ID::BndID);
    else 
      return Edge_ID();
  }

  Edge_ID get_a_ghost_border_edge() const  {
    if ( _size_ghost_borders>0 || _size_rg_borders>0) 
      return Edge_ID(_size_real_borders+_size_rg_borders+1, Edge_ID::BndID);
    else
      return Edge_ID();
  }

  Edge_ID get_a_border_edge() const { 
    if ( _size_real_borders>0) 
      return Edge_ID( 1, Edge_ID::BndID);
    else if ( _size_ghost_borders>0)
      return Edge_ID( _size_rg_borders, Edge_ID::BndID);
    else
      return Edge_ID();
  }

  int get_a_real_border_node() const { 
    if ( _size_real_borders>0 || _size_rg_borders>0) 
      return get_origin(_beIDs[0]);
    else 
      return -1;
  }

  int get_a_ghost_border_node() const {
    if ( _size_ghost_borders>0 || _size_rg_borders>0) 
      return get_origin( _beIDs[_size_real_borders]);
    else
      return -1;
  }

  int get_a_border_node() const {
    if ( _size_real_borders>0) 
      return get_origin(_beIDs[0]);
    else if ( _size_ghost_borders>0)
      return get_origin( _beIDs[_size_rg_borders]);
    else
      return -1;
  }
  //\}

  bool is_real_node( int vID) const {
    if ( !_is_str) // Unstructured mesh
      return vID <= _maxsize_real_nodes;
    else // Structured mesh
      return _isghostnode.empty() || !_isghostnode[ vID-1]; 
  }

  bool is_ghost_node( int vID) const {
    if ( !_is_str) // Unstructured mesh
      return vID > _maxsize_real_nodes;
    else // Structured mesh
      return !_isghostnode.empty() && _isghostnode[ vID-1]; 
  }

  bool is_real_element( int eid ) const {
    if ( !_is_str) // Unstructured mesh
      return eid <= _maxsize_real_elmts;
    else // Structured mesh 
      return _isghostelmt.empty() || !_isghostelmt[ eid-1]; 
  }

  bool is_ghost_element( int eid ) const {
    if ( !_is_str) // Unstructured mesh
      return eid > _maxsize_real_elmts;
    else // Structured
      return !_isghostelmt.empty() && _isghostelmt[ eid-1]; 
  }

  int get_edge_index( const Edge_ID &eid, const int offset=0) const 
  {  return (eid.eid()-offset-1)*_nspe+eid.lid(); }

  int upperbound_edge_index() const
  {  return size_of_elements()*_nspe; }

  void get_borders( std::vector< bool> &is_border, 
                    std::vector< bool> &is_isolated, 
                    std::vector< Edge_ID > *b, 
                    int *ng=NULL) const;
  
protected:
  void init (const COM::Pane *p, const Simple_manifold_2 *parent=NULL,
             bool with_ghost=true);

  void determine_ghosts();

  void determine_opposite_halfedges();

  void determine_incident_halfedges();

private:
  inline Edge_ID get_opposite_edge_interior( const Edge_ID &eID) const { 
    COM_assertion( !eID.is_border());

    if ( _is_str || !is_ghost_element( eID.eid())) {
      return _oeIDs_real_or_str[ get_edge_index( eID)];
    }
    else {
      Edge_ID opp;
      opp = _oeIDs_ghost[ get_edge_index(eID,_maxsize_real_elmts)];

      if ( !opp.is_border() || opp.eid()>_size_rg_borders+_size_real_borders)
        return opp;
      else {
        Edge_ID opp2 = _beIDs[ opp.eid()-1];
        COM_assertion( opp2 != eID);
        return opp2;
      }
    }
  }

  inline Edge_ID get_opposite_real_edge_interior( const Edge_ID &eID) const {
    COM_assertion( !eID.is_border() && is_real_element( eID.eid()));

    Edge_ID opp = _oeIDs_real_or_str[ get_edge_index(eID)]; 

    // If points to a ghost element, then we need to follow the link
    if ( !opp.is_border() && is_ghost_element( opp.eid()))
      opp = get_opposite_ghost_edge_interior( opp);

    return opp;
  }

  inline Edge_ID get_opposite_ghost_edge_interior( const Edge_ID &eID) const {
    COM_assertion( !eID.is_border() && is_ghost_element( eID.eid()));

    if ( _is_str)
      return _oeIDs_real_or_str[ get_edge_index(eID)]; 
    else
      return _oeIDs_ghost[ get_edge_index(eID,_maxsize_real_elmts)];
  }

  inline Edge_ID get_opposite_edge_border( const Edge_ID &eID) const {
    // Precondition: eID is a border edge of the whole pane
    COM_assertion( eID.is_border() && eID.eid()<=int(_beIDs.size()) &&
                   (eID.eid()<=_size_real_borders ||
                    eID.eid()>_size_real_borders+_size_rg_borders));

    return _beIDs[ eID.eid()-1]; 
  }

  inline Edge_ID get_opposite_real_edge_border( const Edge_ID &eID) const {
    // Precondition: eID is a border edge
    COM_assertion( eID.is_border() && 
                   eID.eid()<=_size_real_borders+_size_rg_borders);
    
    Edge_ID opp = _beIDs[ eID.eid()-1];
    
    // Postcondition: opp is incident on a real element.
    COM_assertion( is_real_element( opp.eid()));
    return opp;
  }

  inline Edge_ID get_opposite_ghost_edge_border( const Edge_ID &eID) const { 
    // Precondition: eID is a border edge
    COM_assertion( eID.is_border() && eID.eid()>_size_real_borders &&
                   eID.eid()<=int(_beIDs.size()));

    Edge_ID opp = _beIDs[ eID.eid()-1]; 

    if ( is_real_element( opp.eid())) {
      opp = _oeIDs_real_or_str[ get_edge_index(opp)];
      COM_assertion( opp != eID);
    }
    return opp;
  }
  //\}

  Edge_ID get_prev_edge_interior( const Edge_ID &eID) const {
    // If not a border edge, then track it within an element.
    int i=(eID.lid()?eID.lid()-1:_nspe-1);

    if ( _is_str || !is_ghost_element( eID.eid())) {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i));
      while ( _oeIDs_real_or_str[eindex--]==Edge_ID()) { --i; assert(i); }
    }
    else {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
      while ( _oeIDs_ghost[eindex--]==Edge_ID()) { --i; assert(i); }
    }
    return Edge_ID( eID.eid(), i);
  }

  Edge_ID get_prev_real_edge_interior( const Edge_ID &eID) const {
    COM_assertion( !is_ghost_element( eID.eid()));

    // If not a border edge, then track it within an element.
    int i=(eID.lid()?eID.lid()-1:_nspe-1);

    int eindex = get_edge_index( Edge_ID(eID.eid(), i));
    while ( _oeIDs_real_or_str[eindex--]==Edge_ID()) { --i; assert(i); }

    return Edge_ID( eID.eid(), i);   
  }

  Edge_ID get_prev_ghost_edge_interior( const Edge_ID &eID) const {
    COM_assertion( is_ghost_element( eID.eid()));

    // If not a border edge, then track it within an element.
    int i=(eID.lid()?eID.lid()-1:_nspe-1);

    if ( _is_str) {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i));
      while ( _oeIDs_real_or_str[eindex--]==Edge_ID()) { --i; assert(i); }
    }
    else {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
      while ( _oeIDs_ghost[eindex--]==Edge_ID()) { --i; assert(i); }
    }
    return Edge_ID( eID.eid(), i);
  }

  Edge_ID get_next_edge_interior( const Edge_ID &eID) const {
    // If not a border edge, then track it within an element.
    int i=eID.lid()+1;
    if ( i>=_nspe) return Edge_ID( eID.eid(), 0);

    if ( _is_str || !is_ghost_element( eID.eid())) {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i));
      if ( _oeIDs_real_or_str[eindex]==Edge_ID()) i=0;
    }
    else {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
      if ( _oeIDs_ghost[eindex]==Edge_ID()) i=0;
    }
    return Edge_ID( eID.eid(), i);
  }

  Edge_ID get_next_real_edge_interior( const Edge_ID &eID) const {
    COM_assertion( !is_ghost_element( eID.eid()));

    // If not a border edge, then track it within an element.
    int i=eID.lid()+1;
    if ( i>=_nspe) return Edge_ID( eID.eid(), 0);

    int eindex = get_edge_index( Edge_ID(eID.eid(), i));
    if ( _oeIDs_real_or_str[eindex]==Edge_ID()) i=0;

    return Edge_ID( eID.eid(), i);
  }

  Edge_ID get_next_ghost_edge_interior( const Edge_ID &eID) const {
    COM_assertion( is_ghost_element( eID.eid()));

    // If not a border edge, then track it within an element.
    int i=eID.lid()+1;
    if ( i>=_nspe) return Edge_ID( eID.eid(), 0);

    if ( _is_str) {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i));
      if ( _oeIDs_real_or_str[eindex]==Edge_ID()) i=0;
    }
    else {
      int eindex = get_edge_index( Edge_ID(eID.eid(), i), _maxsize_real_elmts);
      if ( _oeIDs_ghost[eindex]==Edge_ID()) i=0;
    }
    return Edge_ID( eID.eid(), i);
  }

  //\}
protected:
  const COM::Pane        *_pane;      // The associated pane object
  
  bool                   _is_str;     // Whether the pane is structured.
  bool                   _with_ghost; // Whether has ghost nodes/elements.

  // Element connectivity tables for unstructured meshes.
  std::vector<const COM::Connectivity*>  _elem_conns;
  int                    _nspe;       // Max number of sides per element

  int                    _maxsize_real_nodes; // maxnumber of real nodes.
  int                    _maxsize_real_elmts; // maxnumber of real elements.

  int                    _size_real_borders;  // #real border edges
  int                    _size_ghost_borders; // #ghost border edges
  int                    _size_rg_borders;    // #edges between real and ghost

  std::vector<bool>      _isghostnode;       // Is ghost node
  std::vector<bool>      _isghostelmt;       // Is ghost element

  // Opposite halfedge ID of each edge in real elements or in structured meshes
  std::vector<Edge_ID>   _oeIDs_real_or_str;
  // Opposite halfedge ID of each edge in ghost elements of unstructured meshes
  std::vector<Edge_ID>   _oeIDs_ghost;

  // Incident edge ID of each real node of unstructured mesh, 
  // or each node of structured meshes.
  std::vector<Edge_ID>   _ieIDs_real_or_str;
  // Incident edge ID of each ghost node of unstructured mesh
  std::vector<Edge_ID>   _ieIDs_ghost;

  // Mapping from border edges to their opposites.
  // It has three parts: pure-real, between real and ghost, and pure ghost.
  // If an edge is between real and ghost, then it has three IDs
  // (one in real element, one in ghost element, and one with border ID),
  // and they point to each other as follows:
  // 1. beID of the border instance points to the real instance
  // 2. oeID of the real instance points to the ghost instance
  // 3. oeID of the ghost instance points to the border instance.
  std::vector<Edge_ID>   _beIDs;

  // Isolated node IDs
  std::vector<int>       _isovIDs;
};

MAP_END_NAMESPACE

#endif