HalfFacetRep.hpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
 
#ifndef MOAB_HALF_FACET_REP_HPP
#define MOAB_HALF_FACET_REP_HPP
 
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/CN.hpp"
 
namespace moab
{
 
/*!
 *  \brief   HalfFacetRep class implements the Array-Based Half-Facet(AHF) Mesh data structure on
 * top of MOAB. \        It is based on a generalized notion of a half-facet derived from that a
 * half-edge/half-face data structure for 2D/3D. \        The core construct of AHF are its two
 * maps: sibling-half-facets(SIBHFS) and vertex-to-half-facet(V2HF) \        1. SIBHFS: Maps every
 * half-facet in the mesh to its sibling half-facets, \        2. V2HF: Maps each vertex to an
 * incident half-facet \        Using these two maps, a range of adjacency queries is performed. The
 * maps are stored in dense tags over entities and vertices.
 *  \
 *  \        Adjacency functions:
 *  \        1. upward-incidence queries: vertex -> edge, edge -> faces, edge -> cells, face ->cells
 *  \        2. neighborhood (same-dimensional) adjacency queries: edge -> edges, face -> faces,
 * cell -> cells, etc. \        3. downward adjacency queries: face -> edges, cell -> edges, etc.
 *  \
 *  \        Mesh types supported:
 *  \        1D(edges), 2D(triangles, quads), 3D(tet, pyramid, prism, hex), Mixed dimensional meshes
 *  \
 *  \        CURRENTLY NOT SUPPORTED:
 *  \        1. Meshes with mixed entity types of same dimension. Ex. a volume mesh with both tets
 * and prisms. \        2. create_if_missing = true \        3. Modified meshes
 *  \
 */
 
typedef EntityHandle HFacet;
 
const int MAXSIZE = 200;
 
//! ENUM for the type of input mesh.
enum MESHTYPE
{
    CURVE = 0,       // Homogeneous curve mesh
    SURFACE,         // Homogeneous surface mesh
    SURFACE_MIXED,   // Mixed surface with embedded curves
    VOLUME,          // Homogeneous volume mesh
    VOLUME_MIXED_1,  // Volume mesh with embedded curves
    VOLUME_MIXED_2,  // Volume mesh with embedded surface
    VOLUME_MIXED     // Volume mesh with embedded curves and surfaces
};
 
enum
{
    MAX_VERTICES    = 8,
    MAX_EDGES       = 12,
    MAX_FACES       = 6,
    MAX_VERTS_HF    = 4,
    MAX_INCIDENT_HF = 4
};
 
class Core;
class ParallelComm;
class HalfFacetRep
{
 
  public:
    HalfFacetRep( Core* impl, ParallelComm* comm = 0, moab::EntityHandle rset = 0, bool filter_ghosts = true );
 
    ~HalfFacetRep();
 
    bool check_mixed_entity_type();
 
    // User interface functions
 
    //! Constructs the sibling-half-facet and vertex-to-incident-half-facet maps for each dimension
    //! present in the input. This routine should be called before any calls for adjacency is made.
    ErrorCode initialize();
 
    //! Deinitialize
    ErrorCode deinitialize();
 
    //! Prints the tag values.
    ErrorCode print_tags( int dim );
 
    //! Get the adjacencies associated with an entity.
    /** Given an entity of dimension <em>d</em>, gather all the adjacent <em>D</em> dimensional
     * entities where <em>D >, = , < d </em>.
     *
     * \param source_entity EntityHandle to which adjacent entities have to be found.
     * \param target_dimension Int Dimension of the desired adjacent entities.
     * \param target_entities Vector in which the adjacent EntityHandle are returned.
     */
 
    ErrorCode get_adjacencies( const EntityHandle source_entity,
                               const unsigned int target_dimension,
                               std::vector< EntityHandle >& target_entities );
 
    //! Get the upward incidences associated with an entity.
    /** Given an entity of dimension <em>d</em>, gather all the incident <em>D(>d)</em> dimensional
     * entities.
     * :
     * \param ent EntityHandle to which incident entities have to be found.
     * \param out_dim Dimension of the desired incidence information.
     * \param adjents Vector in which the incident entities are returned.
     * \param local_id Set to false by default. If true, returns the local id's of the half-facets
     * \param lids Vector in which the local id's are returned.
     */
 
    ErrorCode get_up_adjacencies( EntityHandle ent,
                                  int out_dim,
                                  std::vector< EntityHandle >& adjents,
                                  std::vector< int >* lids = NULL );
 
    //! Get the same-dimensional entities connected with an entity.
    /** Given an entity of dimension <em>d</em>, gather all the entities connected via <em>d-1</em>
     * dimensional entities. Same as bridge_adjacencies in MOAB.
     *
     * \param ent EntityHandle to which neighbor entities have to be found.
     * \param adjents Vector in which the neighbor entities are returned.
     */
 
    ErrorCode get_neighbor_adjacencies( EntityHandle ent, std::vector< EntityHandle >& adjents );
 
    //! Get the downward adjacent entities connected with an entity.
    /** Given an entity of dimension <em>d</em>, gather all the <em>d-1</em> dimensional entities.
     *
     * \param ent EntityHandle to which neighbor entities have to be found.
     * \param out_dim Dimension of the desired downward adjacency.
     * \param adjents Vector in which the neighbor entities are returned.
     */
 
    ErrorCode get_down_adjacencies( EntityHandle ent, int out_dim, std::vector< EntityHandle >& adjents );
 
    // 1D Maps and queries
 
    //! Given a range of edges, determines the map for sibling half-verts and stores them into
    //! SIBHVS_EID, SIBHVS_LVID tags.
    /** Compute all sibling half-vertices for all half-vertices in the given curve. The sibling
     * half-verts is defined in terms of the containing edge and the local id of the vertex w.r.t
     * that edge. That is, the map consists of two pieces of information: <EntityHandle eid, int
     * lvid>
     *
     * \param edges Range of edges.
     */
 
    ErrorCode determine_sibling_halfverts( Range& verts, Range& edges );
 
    //! Given a range of edges, determines the map for incident half-verts and stores them into
    //! V2HV_EID, V2HV_LVID tags.
    /** Compute a map between a vertex and an incident half-vertex. This map is not always required,
     * but is essential for local neighborhood searching as it acts like an anchor to start the
     * search.
     *
     * \param edges Range of edges
     */
 
    ErrorCode determine_incident_halfverts( Range& edges );
 
    //! Given a vertex, finds the edges incident on it.
    /** Given a vertex handle, it starts by first finding an incident half-vert by using the
     * incident half-vert map, and then obtaining all the sibling half-verts of the corresponding
     * half-vertex.
     *
     * \param vid EntityHandle of the query vertex
     * \param adjents Vector returning the incident edges
     * \param local_id False by default. If true, returns the local vertex id's corresponding to vid
     * \param lvids Vector returning the local vertex id's
     */
 
    ErrorCode get_up_adjacencies_1d( EntityHandle vid,
                                     std::vector< EntityHandle >& adjents,
                                     std::vector< int >* lvids = NULL );
 
    //! Given an edge, finds vertex-connected neighbor edges
    /** Given an edge, it gathers all the incident edges of each vertex of the edge.
     *
     * \param eid EntityHandle of the query edge
     * \param adjents Vector returning neighbor edges
     */
 
    ErrorCode get_neighbor_adjacencies_1d( EntityHandle eid, std::vector< EntityHandle >& adjents );
 
    // 2D Maps and queries
 
    //! Given a range of faces, determines the sibling half-edges and stores them into SIBHES_FID,
    //! SIBHES_LEID tags.
    /** Compute all sibling half-edges for all half-edges in the given surface.
     * The sibling half-edges is defined in terms of the containing face and the local id of the
     * edge w.r.t that entity. That is, the map consists of two pieces of information: <EntityHandle
     * fid, int leid>
     *
     * \param faces Range of faces
     */
 
    ErrorCode determine_sibling_halfedges( Range& faces );
 
    //! Given a range of faces, determines the incident half-edges and stores them into V2HE_FID,
    //! V2HE_LEID tags.
    /** Compute a map between a vertex and an incident half-edge.
     * This map is not always required, but is essential for local neighborhood searching as it acts
     * like an anchor to start the search.
     *
     * \param faces Range of faces
     */
 
    ErrorCode determine_incident_halfedges( Range& faces );
 
    //! Given a vertex, finds the faces incident on it.
    /** Given a vertex, it first finds an incident half-edge via v2he map, and then
     * collects all the incident half-edges/faces via the sibhes map.
     *
     * \param vid EntityHandle of the query vertex
     * \param adjents Vector returning the incident faces
     */
 
    ErrorCode get_up_adjacencies_vert_2d( EntityHandle vid, std::vector< EntityHandle >& adjents );
 
    //! Given an edge, finds the faces incident on it.
    /** Given an edge, it first finds a matching half-edge corresponding to eid, and then
     * collects all the incident half-edges/faces via the sibhes map.
     *
     * \param eid EntityHandle of the query edge
     * \param adjents Vector returning the incident faces
     * \param local_id By default false. If true, returns the local edge id's corresponding to the
     * input edge \param leids Vector returning local edge ids
     */
 
    ErrorCode get_up_adjacencies_2d( EntityHandle eid,
                                     std::vector< EntityHandle >& adjents,
                                     std::vector< int >* leids = NULL );
 
    //! Given a half-edge <fid, leid>, finds the faces incident on it.
    /**
     *
     * \param fid EntityHandle of the containing face
     * \param leid local id of the edge w.r.t to the face
     * \param add_inent If true, adds the input fid into the returning vector of adjents.
     * \param adjents Vector returning the incident faces
     * \param local_id By default false. If true, returns the local edge id's as well.
     * \param leids Vector returning local edge ids
     */
 
    ErrorCode get_up_adjacencies_2d( EntityHandle fid,
                                     int leid,
                                     bool add_inent,
                                     std::vector< EntityHandle >& adj_ents,
                                     std::vector< int >* adj_leids   = NULL,
                                     std::vector< int >* adj_orients = NULL );
 
    //! Given an edge, finds edge-connected neighbor face
    /** Given an face, it gathers all the neighbor faces of each local edge of the face.
     *
     * \param fid EntityHandle of the query face
     * \param adjents Vector returning neighbor faces
     */
 
    ErrorCode get_neighbor_adjacencies_2d( EntityHandle fid, std::vector< EntityHandle >& adjents );
 
    //! Given a face, finds its edges.
    /** Given a face, it first finds incident edges on each vertex of the face, and then
     *  it performs a set intersection to gather all the edges of the given face.
     *
     * \param fid EntityHandle of the query face
     * \param adjents Vector returning its edges
     */
 
    ErrorCode get_down_adjacencies_2d( EntityHandle fid, std::vector< EntityHandle >& adjents );
 
    //! Given a range of faces, finds the total number of edges.
 
    int find_total_edges_2d( Range& faces );
 
    ErrorCode get_face_edges( EntityHandle fid, std::vector< EntityHandle >& edges );
 
    // 3D Maps and queries
 
    //! Given a range of cells, determines the sibling half-faces and stores them into SIBHFS_CID,
    //! SIBHFS_LFID tags.
    /** Compute all sibling half-faces for all half-faces in the given volume.
     * The sibling half-faces is defined in terms of the containing cell and the local id of the
     * face w.r.t that cell. That is, the map consists of two pieces of information: <EntityHandle
     * cid, int lfid>
     *
     * \param faces Range of cells
     */
 
    ErrorCode determine_sibling_halffaces( Range& cells );
 
    //! Given a range of cells, determines the incident half-faces and stores them into V2HF_CID,
    //! V2HF_LFID tags.
    /** Compute a map between a vertex and an incident half-face.
     * This map is not always required, but is essential for local neighborhood searching as it acts
     * like an anchor to start the search.
     *
     * \param faces Range of cells
     */
 
    ErrorCode determine_incident_halffaces( Range& cells );
 
    //! Given a range of cells, tags all border vertices with a true value.
    /** Tag border vertices by using the sibhf_cid map. All vertices on half-faces with no sibling
     * half-faces are considered as border vertices.
     *
     * \param cells Range of cells
     * \param isborder: A dense tag over all vertices of size 1. Value is true for a border vertex,
     * otherwise is false.
     */
 
    ErrorCode determine_border_vertices( Range& cells, Tag isborder );
 
    //! Given a vertex, finds the cells incident on it.
    /** Given a vertex, it first finds an incident half-face via v2hf map, and then
     * collects all the incident half-faces via the sibhfs map.
     *
     * \param vid EntityHandle of the query vertex
     * \param adjents Vector returning the incident cells
     */
 
    ErrorCode get_up_adjacencies_vert_3d( EntityHandle vid, std::vector< EntityHandle >& adjents );
 
    //! Given an edge, finds the cells incident on it.
    /** Given an edge, it first finds a matching local edge in a cell corresponding to eid, and then
     * collects all the incident cells via the sibhfs map.
     *
     * \param eid EntityHandle of the query edge
     * \param adjents Vector returning the incident cells
     * \param local_id By default false. If true, returns the local edge id's corresponding to the
     * input edge \param leids Vector returning local edge ids
     */
 
    ErrorCode get_up_adjacencies_edg_3d( EntityHandle eid,
                                         std::vector< EntityHandle >& adjents,
                                         std::vector< int >* leids = NULL );
 
    //! Given a local edge <cid, leid>, finds the cells incident on it.
    /** Given a local edge, it gathers all the incident cells via the sibhfs map.
     *
     * \param cid EntityHandle of the cell containing the local edge
     * \param leid local edge id w.r.t the cell
     * \param adjents Vector returning the incident cells
     * \param local_id By default false. If true, returns the local edge id's corresponding to the
     * input edge \param leids Vector returning local edge ids
     */
 
    ErrorCode get_up_adjacencies_edg_3d( EntityHandle cid,
                                         int leid,
                                         std::vector< EntityHandle >& adjents,
                                         std::vector< int >* leids       = NULL,
                                         std::vector< int >* adj_orients = NULL );
 
    ErrorCode get_up_adjacencies_edg_3d_comp( EntityHandle cid,
                                              int leid,
                                              std::vector< EntityHandle >& adjents,
                                              std::vector< int >* leids       = NULL,
                                              std::vector< int >* adj_orients = NULL );
 
    //! Given an face, finds the cells incident on it.
    /** Given an face, it first finds a matching half-face in a cell corresponding to face, and then
     * collects all the incident cells via the sibhfs map.
     *
     * \param fid EntityHandle of the query face
     * \param adjents Vector returning the incident cells
     * \param local_id By default false. If true, returns the local face id's corresponding to the
     * input face \param leids Vector returning local face ids
     */
 
    ErrorCode get_up_adjacencies_face_3d( EntityHandle fid,
                                          std::vector< EntityHandle >& adjents,
                                          std::vector< int >* lfids = NULL );
 
    //! Given a local face <cid, lfid>, finds the cells incident on it.
    /** Given a local face, it gathers all the incident cells via the sibhfs map.
     *
     * \param cid EntityHandle of the cell containing the local edge
     * \param lfid local face id w.r.t the cell
     * \param adjents Vector returning the incident cells
     * \param local_id By default false. If true, returns the local face id's corresponding to the
     * input face \param lfids Vector returning local face ids
     */
 
    ErrorCode get_up_adjacencies_face_3d( EntityHandle cid,
                                          int lfid,
                                          std::vector< EntityHandle >& adjents,
                                          std::vector< int >* lfids = NULL );
 
    //! Given a cell, finds face-connected neighbor cells
    /** Given a cell, it gathers all the neighbor cells of each local face of the cell.
     *
     * \param cid EntityHandle of the query cell
     * \param adjents Vector returning neighbor cells
     */
 
    ErrorCode get_neighbor_adjacencies_3d( EntityHandle cid, std::vector< EntityHandle >& adjents );
 
    //! Given a cell, finds its edges.
    /** Given a cell, it first finds incident edges on each vertex of the cell, and then
     *  it performs a set intersection to gather all the edges of the given cell.
     *
     * \param cid EntityHandle of the query cell
     * \param adjents Vector returning its edges
     */
 
    ErrorCode get_down_adjacencies_edg_3d( EntityHandle cid, std::vector< EntityHandle >& adjents );
 
    //! Given a cell, finds its faces.
    /** Given a cell, it first finds incident faces on each vertex of the cell, and then
     *  performs a set intersection to gather all the faces of the given cell.
     *
     * \param cid EntityHandle of the query cell
     * \param adjents Vector returning its faces
     */
 
    ErrorCode get_down_adjacencies_face_3d( EntityHandle cid, std::vector< EntityHandle >& adjents );
 
    /* Find the number of edges and faces of given range of cells
     * */
    ErrorCode find_total_edges_faces_3d( const Range& cells, int* nedges, int* nfaces );
 
    ErrorCode count_subentities( Range& edges, Range& faces, Range& cells, int* nedges, int* nfaces );
 
    void get_memory_use( unsigned long long& entity_total, unsigned long long& memory_total );
 
    ErrorCode get_half_facet_in_comp( EntityHandle cid,
                                      int leid,
                                      std::vector< EntityHandle >& ents,
                                      std::vector< int >& lids,
                                      std::vector< int >& lfids );
 
    /**************************
     *  Interface to AHF maps   *
     **************************/
    HFacet create_halffacet( EntityHandle handle, int lid );
 
    EntityHandle fid_from_halfacet( const HFacet facet, EntityType type );
 
    int lid_from_halffacet( const HFacet facet );
 
    ErrorCode update_entity_ranges( EntityHandle fileset );
 
    ErrorCode resize_hf_maps( EntityHandle start_vert,
                              int nverts,
                              EntityHandle start_edge,
                              int nedges,
                              EntityHandle start_face,
                              int nfaces,
                              EntityHandle start_cell,
                              int ncells );
 
    ErrorCode get_sibling_map( EntityType type,
                               EntityHandle ent,
                               EntityHandle* sib_entids,
                               int* sib_lids,
                               int num_halffacets );
 
    ErrorCode get_sibling_map( EntityType type, EntityHandle ent, int lid, EntityHandle& sib_entid, int& sib_lid );
 
    ErrorCode set_sibling_map( EntityType type,
                               EntityHandle ent,
                               EntityHandle* set_entids,
                               int* set_lids,
                               int num_halffacets );
 
    ErrorCode set_sibling_map( EntityType type, EntityHandle ent, int lid, EntityHandle& set_entid, int& set_lid );
 
    ErrorCode get_incident_map( EntityType type,
                                EntityHandle vid,
                                std::vector< EntityHandle >& inci_entid,
                                std::vector< int >& inci_lid );
 
    ErrorCode set_incident_map( EntityType type,
                                EntityHandle vid,
                                std::vector< EntityHandle >& set_entid,
                                std::vector< int >& set_lid );
 
    bool check_nonmanifold_vertices( EntityType type, EntityHandle vid );
 
    /**********************
     *         Local Maps
     * ********************/
    //! 2D local maps
    struct LocalMaps2D
    {
        //! Number of vertices in a face
        short int num_verts_in_face;
        //! Local ids of the next half-edge
        int next[MAX_INCIDENT_HF];
        //! Local ids of the previous half-edge
        int prev[MAX_INCIDENT_HF];
    };
    static const LocalMaps2D lConnMap2D[2];
 
    //! 3D local maps
    struct LocalMaps3D
    {
        //! Number of vertices in cell
        short int num_verts_in_cell;
        //! Number of edges in cell
        short int num_edges_in_cell;
        // Number of faces in cell
        short int num_faces_in_cell;
        //! Number of vertices in each half-face
        int hf2v_num[MAX_FACES];
        //! Map: Half-face to local vertex ids
        int hf2v[MAX_FACES][MAX_VERTS_HF];
        //! Number of incident half-faces on each vertex
        int v2hf_num[MAX_VERTICES];
        //! Map: Local vertices to incident half-facets
        int v2hf[MAX_VERTICES][MAX_INCIDENT_HF];
        //!  Map: Local edges to local vertices
        int e2v[MAX_EDGES][2];
        //! Map: Local edges to incident half-faces
        int e2hf[MAX_EDGES][2];
        //! Map: Half-faces to local edges
        int f2leid[MAX_FACES][MAX_VERTS_HF];
        //! Map: local vertices to local edges
        int lookup_leids[MAX_VERTICES][MAX_VERTICES];
        //! Search edge verts:
        int search_everts[5];
        int search_fverts[2];
        int v2le[4][5];
    };
    static const LocalMaps3D lConnMap3D[4];
    MESHTYPE thismeshtype;
 
    std::map< EntityType, int > cell_index;
 
    int get_index_in_lmap( EntityHandle cid );
    ErrorCode get_entity_ranges( Range& verts, Range& edges, Range& faces, Range& cells );
    MESHTYPE get_mesh_type( int nverts, int nedges, int nfaces, int ncells );
 
    EntityHandle* get_rset()
    {
        return &_rset;
    }
 
  protected:
    HalfFacetRep();
 
    Core* mb;
    ParallelComm* pcomm;
    EntityHandle _rset;
    bool _filterghost;
    bool mInitAHFmaps;
 
    Range _verts, _edges, _faces, _cells;
 
    // AHF map storage containers for 1D, 2D, 3D
    std::vector< HFacet > sibhvs, v2hv;
    std::vector< HFacet > sibhes, v2he;
    std::vector< HFacet > sibhfs, v2hf;
 
    // AHF maps for non-manifold vertices 2D, 3D
    std::multimap< EntityHandle, HFacet > v2hes, v2hfs;
 
    // Auxiliary storage for local searches.
    EntityHandle queue_fid[MAXSIZE], Stkcells[MAXSIZE], cellq[MAXSIZE];
    EntityHandle trackfaces[MAXSIZE], trackcells[MAXSIZE];
    int queue_lid[MAXSIZE];
 
    struct adj_matrix
    {
        int val[4][4];
    };
 
    static const adj_matrix adjMatrix[7];
    int get_index_for_meshtype( MESHTYPE mesh_type );
 
    // These two flags are for checking mixed entity type meshes
    bool is_mixed;
    bool chk_mixed;
 
    ErrorCode init_curve();
    ErrorCode init_surface();
    ErrorCode init_volume();
 
    //! Contains the local information for 2D entities
    /** Given a face, find the face type specific information
     *
     * \param face EntityHandle. Used to gather info about the type of face for which local info is
     * required \param nepf: Returns the number of vertices/edges for given face type.
     */
 
    //! Contains the local information for 2D entities
    /** Given number of edges, returns local indices of next and previous local edges.
       *
       * \param nepf: The number of vertices/edges for given face type.
       * \param next, prev: Local ids of next and previous edges w.r.t to the face
       *
       * Note: For 2D entities, the number of vertices and edges are same and each local edge is
       outgoing
       * corresponding to the local vertex, i.e,
 
              v2        v3 __e2__v2
              /\          |      |
          e2 /  \ e1    e3|      |e1
            /____\        |______|
          v0  e0  v1     v0  e0  v1
      */
 
    //! Given a half-edge as <he_fid,he_lid> , finds the half-edges incident on it and adds them
    //  to an input queue if it not already added.
    /** Given an half-edge, obtain all the incident half-edges via the sibhes map and add them to a
     * given queue of half-edges, if they do not already exist in the queue. This function is used
     * to increment the search space for finding a matching half-edge.
     *
     * \param he_fid EntityHandle of query half-edge
     * \param he_lid Local id of query half-edge
     */
 
    ErrorCode get_up_adjacencies_2d( EntityHandle he_fid, int he_lid, int* qsize, int* count );
 
    //! Given an edge, finds a matching half-edge in the surface.
    /** Given an edge eid, it first collects few half-edges belonging to one-ring neighborhood of
     * the starting vertex of the given edge, and then simultaneously searches and adds to the local
     * list of half-edges for searching, till it finds a matching half-edge.
     *
     * \param eid EntityHandle of the query edge
     * \param hefid, helid: Returns the matching half-edge corresponding to the query edge.
     */
 
    bool find_matching_halfedge( EntityHandle eid, EntityHandle* hefid, int* helid );
 
    //! Gather half-edges to a queue of half-edges.
    /** Given a vertex vid, and a half-edge <he_fid,he_lid>, add another half-edge in the same face
     * sharing the vertex
     */
 
    ErrorCode gather_halfedges( EntityHandle vid, EntityHandle he_fid, int he_lid, int* qsize, int* count );
 
    //! Obtains another half-edge belonging to the same face as the input half-edge
    /** It uses the local maps to find another half-edge that is either incident or outgoing
     * depending on vid and input half-edge
     */
 
    ErrorCode another_halfedge( EntityHandle vid,
                                EntityHandle he_fid,
                                int he_lid,
                                EntityHandle* he2_fid,
                                int* he2_lid );
 
    ErrorCode mark_halfedges( EntityHandle vid,
                              EntityHandle he_fid,
                              int he_lid,
                              Range& faces,
                              std::vector< char >& markHEdgs,
                              HFacet& bnd_hf );
 
    //! Collect and compare to find a matching half-edge with the given edge connectivity.
    /** Given edge connectivity, compare to an input list of half-edges to find a matching half-edge
     * and add a list of half-edges belonging to the one-ring neighborhood to a queue till it finds
     * a match.
     */
 
    bool collect_and_compare( const EntityHandle vid,
                              const EntityHandle* edg_vert,
                              int* qsize,
                              int* count,
                              EntityHandle* he_fid,
                              int* he_lid );
 
    ErrorCode add_cells_of_single_component( EntityHandle vid,
                                             EntityHandle curcid,
                                             int curlid,
                                             std::multimap< EntityHandle, EntityHandle >& comps,
                                             HFacet& hf );
    bool find_cell_in_component( EntityHandle vid,
                                 EntityHandle cell,
                                 std::multimap< EntityHandle, EntityHandle >& comps );
 
    //! Given an edge, finds a matching local edge in an incident cell.
    /** Find a local edge with the same connectivity as the input edge, belonging to an incident
     * cell.
     *
     * \param eid EntityHandle of the edge
     * \param cid Returns EntityHandle of the incident cell
     * \param leid Returns the local id of the edge corresponding to the input edge w.r.t the
     * incident cell.
     */
 
    bool find_matching_implicit_edge_in_cell( EntityHandle eid,
                                              std::vector< EntityHandle >& cid,
                                              std::vector< int >& leid );
 
    //! Given a face, finds a matching local face in an incident cell.
    /** Find a local face with the same connectivity as the input face, belonging to an incident
     * cell.
     *
     * \param fid EntityHandle of the face
     * \param cid Returns EntityHandle of the incident cell
     * \param lfid Returns the local id of the face corresponding to the input face w.r.t the
     * incident cell.
     */
 
    bool find_matching_halfface( EntityHandle fid, EntityHandle* cid, int* leid );
 
    bool find_match_in_array( EntityHandle ent,
                              EntityHandle* ent_list,
                              int count,
                              bool get_index = false,
                              int* index     = NULL );
};
 
}  // namespace moab
 
#endif