[MOAB-dev] commit/MOAB: 4 new changesets

commits-noreply at bitbucket.org commits-noreply at bitbucket.org
Thu Jul 3 15:22:58 CDT 2014


4 new commits in MOAB:

https://bitbucket.org/fathomteam/moab/commits/82e8ce89781e/
Changeset:   82e8ce89781e
Branch:      None
User:        nray
Date:        2014-07-03 22:22:39
Summary:     Added the HalfFacetRep class and one test code.

Affected #:  7 files

diff --git a/MeshFiles/unittest/Makefile.am b/MeshFiles/unittest/Makefile.am
index bc4f522..2bd2a8a 100644
--- a/MeshFiles/unittest/Makefile.am
+++ b/MeshFiles/unittest/Makefile.am
@@ -34,5 +34,6 @@ EXTRA_DIST  = 125hex.g \
               BedCrop2.h5m \
               mpas_p8.h5m \
               Homme_2pt.h5m \
-              surfrandomtris-4part.h5m
+              surfrandomtris-4part.h5m \
+	      hexes_mixed.vtk
 

diff --git a/MeshFiles/unittest/hexes_mixed.vtk b/MeshFiles/unittest/hexes_mixed.vtk
new file mode 100755
index 0000000..8ee5c11
--- /dev/null
+++ b/MeshFiles/unittest/hexes_mixed.vtk
@@ -0,0 +1,45 @@
+# vtk DataFile Version 3.0
+This file was written using writevtk_unstr.m
+ASCII
+DATASET UNSTRUCTURED_GRID
+POINTS 18 double
+0 -1 0
+0 1 0
+1 -1 0
+1 1 0
+-1 1 0
+-1 -1 0
+0 -1 1
+0 1 1
+1 -1 1
+1 1 1
+-1 1 1
+-1 -1 1
+0 -1 -1
+0 1 -1
+1 -1 -1 
+1 1 -1
+-1 1 -1
+-1 -1 -1
+
+CELLS 9 59
+2 0 1
+4 0 1 7 6
+4 0 2 3 1
+4 0 12 13 1
+4 0 1 4 5
+8 0 2 3 1 6 8 9 7
+8 5 0 1 4 11 6 7 10
+8 12 14 15 13 0 2 3 1
+8 17 12 13 16 5 0 1 4
+
+CELL_TYPES 9
+3
+9
+9
+9
+9
+12
+12
+12
+12

This diff is so big that we needed to truncate the remainder.

https://bitbucket.org/fathomteam/moab/commits/a56f336501f8/
Changeset:   a56f336501f8
Branch:      None
User:        nray
Date:        2014-07-03 22:22:39
Summary:     Added interface to AHF functionalities through the get_adjacencies
functions.

Affected #:  10 files

diff --git a/configure.ac b/configure.ac
index 890f70d..b0905cf 100644
--- a/configure.ac
+++ b/configure.ac
@@ -657,6 +657,13 @@ MB_OPTIONAL_TOOL([mbdepth],      [yes])
 MB_OPTIONAL_TOOL([refiner],      [no])
 MB_OPTIONAL_TOOL([h5mtools],     [yes])
 MB_OPTIONAL_TOOL([mbcslam],      [no])
+MB_OPTIONAL_TOOL([ahf],          [no])
+
+
+if test "xyes" = "x$ENABLE_ahf"; then
+  AM_CPPFLAGS="$AM_CPPFLAGS -DUSE_AHF"
+fi
+
 
 if test "xyes" = "x$ENABLE_refiner"; then
   if test "xyes" != "x$WITH_MPI"; then
@@ -1333,3 +1340,27 @@ if test "x$WARN_PARALLEL_HDF5_NO_COMPLEX" = "xyes"; then
 *************************************************************************])
 fi
 
+################################################################################
+#                             AHF OPTIONS
+################################################################################
+#AC_ARG_ENABLE([ahf],
+#[AC_HELP_STRING([--enable-ahf],[use the half facet representation])],
+#[ case "${enableval}" in 
+#	yes) ahf1=true ;;
+#        no) ahf1=false ;;
+#	*) AC_MSG_ERROR([bad value]) ;; 
+#esac],[ahf1=false])	
+ #ENABLE_AHF=$enableval],[ENABLE_AHF=no] )
+
+#if test "x$ENABLE_AHF" = "xyes"; then
+#   AM_CPPFLAGS="$AM_CPPFLAGS -DUSE_AHF"
+#fi
+#AM_CONDITIONAL([ENABLE_AHF],[test x$ahf1 = xtrue])
+#AC_SUBST(ENABLE_AHF)
+
+
+#test "xyes" != "x$WITH_AHF" || AM_CPPFLAGS="$AM_CPPFLAGS -DUSE_AHF"
+#AM_CONDITIONAL(USE_AHF, [test "xno" != "x$WITH_AHF"])
+
+
+

diff --git a/src/Core.cpp b/src/Core.cpp
index 0bd882f..3641fd5 100644
--- a/src/Core.cpp
+++ b/src/Core.cpp
@@ -56,6 +56,10 @@
 #include <errno.h>
 #include <string.h>
 
+#ifdef USE_AHF
+#include "moab/HalfFacetRep.hpp"
+#endif
+
 #ifdef USE_MPI
 /* Leave ParallelComm.hpp before mpi.h or MPICH2 will fail
  * because its C++ headers do not like SEEK_* macros.
@@ -272,6 +276,12 @@ ErrorCode Core::initialize()
   geom_dimension_tag();
   globalId_tag();
 
+#ifdef USE_AHF
+  ahfRep = new HalfFacetRep(this);
+  if (!ahfRep)
+    return MB_MEMORY_ALLOCATION_FAILED;
+#endif
+
   return MB_SUCCESS;
 }
 
@@ -322,6 +332,11 @@ void Core::deinitialize()
   if (mpiFinalize)
     MPI_Finalize();
 #endif
+
+#ifdef USE_AHF
+  delete ahfRep;
+  ahfRep = 0;
+#endif
 }
 
 ErrorCode Core::query_interface_type( const std::type_info& type, void*& ptr )
@@ -1338,6 +1353,80 @@ ErrorCode get_adjacencies_union( Core* gMB,
   return result;
 }
 
+
+///////////////////////////
+///
+#ifdef USE_AHF
+template <typename ITER> static inline
+ErrorCode get_adjacencies_intersection_ahf(Core *mb,
+                             ITER begin, ITER end,
+                             const int to_dimension,
+                             std::vector<EntityHandle>& adj_entities )
+{
+  const size_t SORT_THRESHOLD = 200;
+  std::vector<EntityHandle> temp_vec;
+  std::vector<EntityHandle>::iterator adj_it, w_it;
+  ErrorCode result = MB_SUCCESS;
+
+  if (begin == end) {
+    adj_entities.clear(); // intersection
+    return MB_SUCCESS;
+  }
+
+    // First iteration is a special case if input list is empty.
+    // Rather than returning nothing (intersecting with empty
+    // input list), we begin with the adjacencies for the first entity.
+  if (adj_entities.empty()) {
+    EntityType type = TYPE_FROM_HANDLE(*begin);
+
+    if(to_dimension == 0 && type != MBPOLYHEDRON)
+      result = mb->get_connectivity(&(*begin), 1, adj_entities);
+    else
+      result = mb->a_half_facet_rep()->get_adjacencies(*begin, to_dimension, adj_entities);
+    if (MB_SUCCESS != result)
+      return result;
+    ++begin;
+  }
+
+  for (ITER from_it = begin; from_it != end; from_it++)
+  {
+      // running results kept in adj_entities; clear temp_vec, which is working space
+    temp_vec.clear();
+
+      // get the next set of adjacencies
+    EntityType type = TYPE_FROM_HANDLE(*from_it);
+    if(to_dimension == 0 && type != MBPOLYHEDRON)
+      result = mb->get_connectivity(&(*from_it), 1, temp_vec);
+    else
+      result = mb->a_half_facet_rep()->get_adjacencies(*from_it, to_dimension, temp_vec);
+    if (MB_SUCCESS != result)
+      return result;
+
+      // otherwise intersect with the current set of results
+    w_it = adj_it = adj_entities.begin();
+    if (temp_vec.size()*adj_entities.size() < SORT_THRESHOLD) {
+      for (; adj_it != adj_entities.end(); ++adj_it)
+        if (std::find(temp_vec.begin(), temp_vec.end(), *adj_it) != temp_vec.end())
+          { *w_it = *adj_it; ++w_it; }
+    }
+    else {
+      std::sort( temp_vec.begin(), temp_vec.end() );
+      for (; adj_it != adj_entities.end(); ++adj_it)
+        if (std::binary_search(temp_vec.begin(), temp_vec.end(), *adj_it))
+          { *w_it = *adj_it; ++w_it; }
+    }
+    adj_entities.erase( w_it, adj_entities.end() );
+
+      // we're intersecting, so if there are no more results, we're done
+    if (adj_entities.empty())
+      break;
+  }
+
+  return MB_SUCCESS;
+}
+#endif
+///////////////////////////////////////////
+
 template <typename ITER> static inline
 ErrorCode get_adjacencies_intersection( Core* mb,
                              ITER begin, ITER end,
@@ -1445,37 +1534,116 @@ ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
                                      const int to_dimension,
                                      const bool create_if_missing,
                                      std::vector<EntityHandle> &adj_entities,
-                                     const int operation_type )
+                                     const int operation_type
+#ifdef USE_AHF
+                                 , const bool use_ahf)
+#else
+                                 )
+#endif
 {
-  if (operation_type == Interface::INTERSECT)
-    return get_adjacencies_intersection( this, from_entities, from_entities+num_entities,
-                                         to_dimension, create_if_missing, adj_entities );
-  else if (operation_type != Interface::UNION)
-    return MB_FAILURE;
 
-    // do union
-  ErrorCode result;
-  std::vector<EntityHandle> tmp_storage;
-  const EntityHandle* conn;
-  int len;
-  for (int i = 0; i < num_entities; ++i) {
-    if(to_dimension == 0 && TYPE_FROM_HANDLE(from_entities[0]) != MBPOLYHEDRON) {
-      result = get_connectivity(from_entities[i], conn, len, false, &tmp_storage);
-      adj_entities.insert( adj_entities.end(), conn, conn+len );
-      if (MB_SUCCESS != result)
-        return result;
+#ifdef USE_AHF
+    bool can_handle = true;
+    int source_dim = this->dimension_from_handle(from_entities[0]);
+
+    if ((source_dim > to_dimension) && (to_dimension != 0))
+    {
+        std::cout<<"Currently Not Supported by MOAB_AHF: Down Adjacencies"<<std::endl;
+        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
+        can_handle = false;
     }
-    else {
-      result = aEntityFactory->get_adjacencies(from_entities[i], to_dimension,
-                                               create_if_missing, adj_entities);
-      if (MB_SUCCESS != result)
-        return result;
+    else if (((source_dim == 0) && (to_dimension == 2))||((source_dim == 0) && (to_dimension == 3)))
+    {
+        std::cout<<"Currently Not Supported by MOAB_AHF: Vertex to face/cell"<<std::endl;
+        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
+        can_handle = false;
+    }
+    else if (TYPE_FROM_HANDLE(from_entities[0]) == MBPOLYHEDRON)
+    {
+        std::cout<<"Currently Not Supported by MOAB_AHF: Polyhedron Meshes"<<std::endl;
+        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
+        can_handle = false;
+    }
+    else if (create_if_missing)
+    {
+        std::cout<<"Currently Not Supporteded by MOAB_AHF: create_if_missing capability "<<std::endl;
+        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
+        can_handle = false;
     }
-  }
-  std::sort( adj_entities.begin(), adj_entities.end() );
-  adj_entities.erase( std::unique( adj_entities.begin(), adj_entities.end() ), adj_entities.end() );
 
-  return MB_SUCCESS;
+    if ((use_ahf) && (can_handle))
+    {
+
+        if (operation_type == Interface::INTERSECT)
+            return get_adjacencies_intersection_ahf(this, from_entities, from_entities+num_entities,
+                                                    to_dimension, adj_entities );
+        else if (operation_type != Interface::UNION)
+            return MB_FAILURE;
+
+        // do union
+        ErrorCode result;
+        std::vector<EntityHandle> tmp_storage;
+        const EntityHandle* conn;
+        int len;
+        for (int i = 0; i < num_entities; ++i) {
+            if(to_dimension == 0 && TYPE_FROM_HANDLE(from_entities[0]) != MBPOLYHEDRON) {
+                result = get_connectivity(from_entities[i], conn, len, false, &tmp_storage);
+                adj_entities.insert( adj_entities.end(), conn, conn+len );
+                if (MB_SUCCESS != result)
+                    return result;
+            }
+            else {
+                result = ahfRep->get_adjacencies(from_entities[i], to_dimension, adj_entities);
+                if (MB_SUCCESS != result)
+                    return result;
+            }
+        }
+        std::sort( adj_entities.begin(), adj_entities.end() );
+        adj_entities.erase( std::unique( adj_entities.begin(), adj_entities.end() ), adj_entities.end() );
+
+    }
+    else
+    {
+
+#endif
+
+        if (operation_type == Interface::INTERSECT)
+            return get_adjacencies_intersection( this, from_entities, from_entities+num_entities,
+                                                 to_dimension, create_if_missing, adj_entities );
+        else if (operation_type != Interface::UNION)
+            return MB_FAILURE;
+
+        // do union
+        ErrorCode result;
+        std::vector<EntityHandle> tmp_storage;
+        const EntityHandle* conn;
+        int len;
+        for (int i = 0; i < num_entities; ++i) {
+            if(to_dimension == 0 && TYPE_FROM_HANDLE(from_entities[0]) != MBPOLYHEDRON) {
+                result = get_connectivity(from_entities[i], conn, len, false, &tmp_storage);
+                adj_entities.insert( adj_entities.end(), conn, conn+len );
+                if (MB_SUCCESS != result)
+                    return result;
+            }
+            else {
+                result = aEntityFactory->get_adjacencies(from_entities[i], to_dimension,
+                                                         create_if_missing, adj_entities);
+                if (MB_SUCCESS != result)
+                    return result;
+            }
+        }
+        std::sort( adj_entities.begin(), adj_entities.end() );
+        adj_entities.erase( std::unique( adj_entities.begin(), adj_entities.end() ), adj_entities.end() );
+
+        //return MB_SUCCESS;
+
+
+#ifdef USE_AHF
+    }
+#endif
+
+return MB_SUCCESS;
+
 }
 
 

diff --git a/src/HalfFacetRep.cpp b/src/HalfFacetRep.cpp
index 95efb7e..f3818a6 100755
--- a/src/HalfFacetRep.cpp
+++ b/src/HalfFacetRep.cpp
@@ -17,21 +17,32 @@
 #pragma warning (disable : 4786)
 #endif
 
+#include "moab/HalfFacetRep.hpp"
 #include <iostream>
 #include <assert.h>
-#include <time.h>
 #include <vector>
-#include <queue>
-#include <stack>
 #include "moab/Core.hpp"
 #include "moab/Range.hpp"
 #include "moab/CN.hpp"
-#include "moab/HalfFacetRep.hpp"
 
 namespace moab {
 
   const int MAXSIZE = 500;
 
+  HalfFacetRep::HalfFacetRep(Core *impl)
+  {
+    assert(NULL != impl);
+    mb = impl;
+    mInitAHFmaps = false;
+  }
+
+  HalfFacetRep::~HalfFacetRep()
+  {
+    ErrorCode result;
+    result = deinitialize();
+    //if (MB_SUCCESS != result) return result;
+  }
+
   MESHTYPE HalfFacetRep::get_mesh_type(int nverts, int nedges, int nfaces, int ncells)
   {
     MESHTYPE mesh_type;
@@ -58,7 +69,9 @@ namespace moab {
    * initialize                                          *
    ******************************************************/
 
-  ErrorCode HalfFacetRep::initialize(){
+  ErrorCode HalfFacetRep::initialize()
+  {
+    mInitAHFmaps = true;
 
     ErrorCode error;
 
@@ -436,36 +449,100 @@ namespace moab {
    *      User interface for adjacency functions            *
    ********************************************************/
 
-   ErrorCode HalfFacetRep::get_upward_incidences(EntityHandle ent, int out_dim, std::vector<EntityHandle> &adjents, bool local_id, std::vector<int> * lids)
+  ErrorCode HalfFacetRep::get_adjacencies(const EntityHandle source_entity,
+                                          const unsigned int target_dimension,
+                                          std::vector<EntityHandle> &target_entities)
+  {
+
+      ErrorCode error;
+
+      unsigned int source_dimension = mb->dimension_from_handle(source_entity);
+
+      if (mInitAHFmaps == false)
+      {
+       error = initialize();
+       if (MB_SUCCESS != error) return error;
+      }
+
+      if ((source_dimension == 0) && (target_dimension == 1))
+      {
+          error = get_up_adjacencies_1d(source_entity, target_entities);
+          if (MB_SUCCESS != error) return error;
+      }
+
+      else if ((source_dimension == 1) && (target_dimension == 2))
+      {
+          error = get_up_adjacencies_2d(source_entity, target_entities);
+          if (MB_SUCCESS != error) return error;
+      }
+      else if ((source_dimension == 1) && (target_dimension == 3))
+      {
+          error = get_up_adjacencies_edg_3d(source_entity, target_entities);
+          if (MB_SUCCESS != error) return error;
+      }
+      else if ((source_dimension == 2) && (target_dimension ==3))
+      {
+          error = get_up_adjacencies_face_3d(source_entity, target_entities);
+          if (MB_SUCCESS != error) return error;
+      }
+      else if (source_dimension == target_dimension)
+      {
+          if (target_dimension == 1)
+          {
+              error = get_neighbor_adjacencies_1d(source_entity, target_entities);
+              if (MB_SUCCESS != error) return error;
+          }
+
+          else if (target_dimension == 2)
+          {
+              error = get_neighbor_adjacencies_2d(source_entity, target_entities);
+              if (MB_SUCCESS != error) return error;
+          }
+          else if (target_dimension == 3)
+          {
+              error = get_neighbor_adjacencies_3d(source_entity, target_entities);
+              if (MB_SUCCESS != error) return error;
+          }
+      }
+      return MB_SUCCESS;
+  }
+
+
+   ErrorCode HalfFacetRep::get_up_adjacencies(EntityHandle ent,
+                                              int out_dim,
+                                              std::vector<EntityHandle> &adjents,
+                                              bool local_id,
+                                              std::vector<int> * lids)
    {
     ErrorCode error;
     int in_dim = mb->dimension_from_handle(ent);
 
     if ((in_dim == 0) && (out_dim == 1))
       {
-        error = get_upward_incidences_1d(ent, adjents, local_id, lids);
+        error = get_up_adjacencies_1d(ent, adjents, local_id, lids);
         if (MB_SUCCESS != error) return error;
       }
 
     else if ((in_dim == 1) && (out_dim == 2))
       {
-        error = get_upward_incidences_2d(ent, adjents, local_id, lids);
+        error = get_up_adjacencies_2d(ent, adjents, local_id, lids);
         if (MB_SUCCESS != error) return error;
       }
     else if ((in_dim == 1) && (out_dim == 3))
       {
-        error = get_upward_incidences_edg_3d(ent, adjents, local_id, lids);
+        error = get_up_adjacencies_edg_3d(ent, adjents, local_id, lids);
         if (MB_SUCCESS != error) return error;
       }
     else if ((in_dim == 2) && (out_dim ==3))
       {
-        error = get_upward_incidences_face_3d(ent, adjents, local_id, lids);
+        error = get_up_adjacencies_face_3d(ent, adjents, local_id, lids);
         if (MB_SUCCESS != error) return error;
       }
     return MB_SUCCESS;
    }
 
-   ErrorCode HalfFacetRep::get_neighbor_adjacencies(EntityHandle ent, std::vector<EntityHandle> &adjents)
+   ErrorCode HalfFacetRep::get_neighbor_adjacencies(EntityHandle ent,
+                                                    std::vector<EntityHandle> &adjents)
    {
      ErrorCode error;
      int in_dim = mb->dimension_from_handle(ent);
@@ -619,8 +696,11 @@ namespace moab {
     return MB_SUCCESS;
   }
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode  HalfFacetRep::get_upward_incidences_1d( EntityHandle vid, std::vector< EntityHandle > &adjents, bool local_id, std::vector<int> * lvids){
-    ErrorCode error;     
+  ErrorCode  HalfFacetRep::get_up_adjacencies_1d( EntityHandle vid,
+                                                  std::vector< EntityHandle > &adjents,
+                                                  bool local_id,
+                                                  std::vector<int> * lvids){
+    ErrorCode error;
     EntityHandle start_eid, eid, sibeid[2];
     int start_lid, lid, siblid[2];    
    
@@ -655,7 +735,8 @@ namespace moab {
     return MB_SUCCESS;
   }
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode  HalfFacetRep::get_neighbor_adjacencies_1d( EntityHandle eid, std::vector<EntityHandle> &adjents){
+  ErrorCode  HalfFacetRep::get_neighbor_adjacencies_1d( EntityHandle eid,
+                                                        std::vector<EntityHandle> &adjents){
 
     ErrorCode error;
 
@@ -912,9 +993,65 @@ namespace moab {
     
     return MB_SUCCESS;
   }
+  ///////////////////////////////////////////////////////////////////
+ /* ErrorCode HalfFacetRep::get_up_adjacencies_2d(EntityHandle vid, std::vector<EntityHandle> &adjents)
+  {
+    ErrorCode error;
+
+    EntityHandle fid; int lid;
+    error = mb->tag_get_data(v2he_fid, &vid, 1, &fid);
+    if (MB_SUCCESS != error) return error;
+    error = mb->tag_get_data(v2he_leid, &vid, 1, &lid);
+    if (MB_SUCCESS != error) return error;
+
+    if (fid != 0)
+      {
+        adjents.push_back(fid);
+
+        EntityHandle queue_fid[MAXSIZE], trackfaces[MAXSIZE];
+        int queue_lid[MAXSIZE];
+        for (int i = 0; i< MAXSIZE; i++)
+          {
+            queue_fid[i] = 0;
+            queue_lid[i] = 0;
+            trackfaces[i] = 0;
+          }
+        int qsize = 0, tcount = -1;
+        int num_qvals = 0;
+        error = gather_halfedges(vid, fid, lid, queue_fid, queue_lid, &qsize, trackfaces, &tcount);
+        if (MB_SUCCESS != error) return error;
+
+        while (num_qvals < *qsize)
+          {
+            EntityHandle curfid = queue_fid[num_qvals];
+            int curlid = queue_lid[num_qvals];
+            num_qvals += 1;
+
+            EntityHandle he2_fid; int he2_lid;
+            error = another_halfedge(vid, curfid, curlid, &he2_fid, &he2_lid);
+            if (MB_SUCCESS != error) return error;
 
+            bool found_ent = find_match_in_array(he2_fid, trackfaces, tcount[0]);
+
+            if (found_ent)
+              continue;
+            tcount[0] += 1;
+            trackfaces[tcount[0]] = he2_fid;
+
+            error = get_up_adjacencies_2d(he2_fid, he2_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
+            if (MB_SUCCESS != error) return error;
+
+            adjents.push_back(he2_fid);
+
+          }
+      }
+  }
+*/
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode  HalfFacetRep::get_upward_incidences_2d( EntityHandle eid, std::vector<EntityHandle> &adjents, bool local_id, std::vector<int>  * leids)
+  ErrorCode  HalfFacetRep::get_up_adjacencies_2d( EntityHandle eid,
+                                                  std::vector<EntityHandle> &adjents,
+                                                  bool local_id,
+                                                  std::vector<int>  * leids)
 {
 
   // Given an explicit edge eid, find the incident faces.
@@ -928,7 +1065,7 @@ namespace moab {
     // Step 2: If there is a corresponding half-edge, collect all sibling half-edges and store the incident faces.
     if (found)
       { 
-        error = get_upward_incidences_2d(he_fid, he_lid, true, adjents, local_id, leids);
+        error = get_up_adjacencies_2d(he_fid, he_lid, true, adjents, local_id, leids);
         if (MB_SUCCESS != error) return error;
       }
 
@@ -936,7 +1073,12 @@ namespace moab {
   }
 
   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode HalfFacetRep::get_upward_incidences_2d( EntityHandle fid,  int leid, bool add_inent, std::vector<EntityHandle> &fids, bool local_id, std::vector<int> * leids)
+  ErrorCode HalfFacetRep::get_up_adjacencies_2d( EntityHandle fid,
+                                                 int leid,
+                                                 bool add_inent,
+                                                 std::vector<EntityHandle> &fids,
+                                                 bool local_id,
+                                                 std::vector<int> * leids)
   {
     // Given an implicit half-edge <fid, leid>, find the incident half-edges.
     ErrorCode error;
@@ -982,7 +1124,13 @@ namespace moab {
   }
 
   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   ErrorCode HalfFacetRep::get_upward_incidences_2d(EntityHandle fid,  int lid, EntityHandle *queue_fid, int *queue_lid, int *qsize, EntityHandle *trackfaces, int *tcount)
+   ErrorCode HalfFacetRep::get_up_adjacencies_2d(EntityHandle fid,
+                                                 int lid,
+                                                 EntityHandle *queue_fid,
+                                                 int *queue_lid,
+                                                 int *qsize,
+                                                 EntityHandle *trackfaces,
+                                                 int *tcount)
   {
 
     ErrorCode error; 
@@ -1035,7 +1183,9 @@ namespace moab {
    }
 
   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  bool HalfFacetRep::find_matching_halfedge( EntityHandle eid, EntityHandle *hefid, int *helid){
+  bool HalfFacetRep::find_matching_halfedge( EntityHandle eid,
+                                             EntityHandle *hefid,
+                                             int *helid){
     ErrorCode error;
     std::vector<EntityHandle> conn(2);
     error = mb->get_connectivity(&eid, 1, conn);
@@ -1071,7 +1221,14 @@ namespace moab {
     return found;
   }
   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   ErrorCode HalfFacetRep::gather_halfedges( EntityHandle vid,  EntityHandle he_fid,  int he_lid, EntityHandle *queue_fid, int *queue_lid, int *qsize, EntityHandle *trackfaces, int *tcount)
+   ErrorCode HalfFacetRep::gather_halfedges( EntityHandle vid,
+                                             EntityHandle he_fid,
+                                             int he_lid,
+                                             EntityHandle *queue_fid,
+                                             int *queue_lid,
+                                             int *qsize,
+                                             EntityHandle *trackfaces,
+                                             int *tcount)
   {  
     ErrorCode error;
     EntityHandle he2_fid = 0; int he2_lid = 0;
@@ -1086,16 +1243,20 @@ namespace moab {
     tcount[0] += 1;
     trackfaces[tcount[0]] = he_fid;
     
-    error = get_upward_incidences_2d(he_fid, he_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
+    error = get_up_adjacencies_2d(he_fid, he_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
     if (MB_SUCCESS != error) return error;
-    error = get_upward_incidences_2d(he2_fid, he2_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
+    error = get_up_adjacencies_2d(he2_fid, he2_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
     if (MB_SUCCESS != error) return error;
 
     return MB_SUCCESS;
   }
 
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode HalfFacetRep::another_halfedge( EntityHandle vid,  EntityHandle he_fid,  int he_lid, EntityHandle *he2_fid, int *he2_lid)
+  ErrorCode HalfFacetRep::another_halfedge( EntityHandle vid,
+                                            EntityHandle he_fid,
+                                            int he_lid,
+                                            EntityHandle *he2_fid,
+                                            int *he2_lid)
   {    
     ErrorCode error;
     int nepf;
@@ -1121,7 +1282,14 @@ namespace moab {
   }
   
   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  bool HalfFacetRep::collect_and_compare(std::vector<EntityHandle> &edg_vert, EntityHandle *queue_fid, int *queue_lid, int *qsize, EntityHandle *trackfaces, int *tcount, EntityHandle *he_fid, int *he_lid)
+  bool HalfFacetRep::collect_and_compare(std::vector<EntityHandle> &edg_vert,
+                                         EntityHandle *queue_fid,
+                                         int *queue_lid,
+                                         int *qsize,
+                                         EntityHandle *trackfaces,
+                                         int *tcount,
+                                         EntityHandle *he_fid,
+                                         int *he_lid)
   {
     ErrorCode error;
     int nepf = local_maps_2d(*_faces.begin());
@@ -1162,7 +1330,7 @@ namespace moab {
 	error = another_halfedge(edg_vert[0], curfid, curlid, &he2_fid, &he2_lid);
 
 	if (MB_SUCCESS != error) return error;
-	error = get_upward_incidences_2d(he2_fid, he2_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
+	error = get_up_adjacencies_2d(he2_fid, he2_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
 	if (MB_SUCCESS != error) return error;      
 
 	counter += 1;
@@ -1174,14 +1342,15 @@ namespace moab {
   }
   
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode  HalfFacetRep::get_neighbor_adjacencies_2d( EntityHandle fid, std::vector<EntityHandle> &adjents)
+  ErrorCode  HalfFacetRep::get_neighbor_adjacencies_2d( EntityHandle fid,
+                                                        std::vector<EntityHandle> &adjents)
   {
     ErrorCode error; 
     if (fid != 0){
       
       int nepf = local_maps_2d(fid);
       for (int lid = 0; lid < nepf; ++lid){
-        error = get_upward_incidences_2d(fid, lid, false, adjents);
+        error = get_up_adjacencies_2d(fid, lid, false, adjents);
 	if (MB_SUCCESS != error) return error;
       }
     }
@@ -1212,7 +1381,7 @@ namespace moab {
 	int id = nepf*(*f-firstF)+l;
 	if (!trackF[id])
 	  {
-	    error = get_upward_incidences_2d(*f,l, false, adj_fids, true, &adj_lids);
+	    error = get_up_adjacencies_2d(*f,l, false, adj_fids, true, &adj_lids);
 	    if (MB_SUCCESS != error) return error;
 
 	    total_edges -= adj_fids.size();
@@ -1530,7 +1699,10 @@ namespace moab {
   }
 
  //////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode HalfFacetRep::get_upward_incidences_edg_3d( EntityHandle eid, std::vector<EntityHandle> &adjents, bool local_id, std::vector<int> * leids)
+  ErrorCode HalfFacetRep::get_up_adjacencies_edg_3d( EntityHandle eid,
+                                                     std::vector<EntityHandle> &adjents,
+                                                     bool local_id,
+                                                     std::vector<int> * leids)
   {
     ErrorCode error; 
     
@@ -1542,7 +1714,7 @@ namespace moab {
     //Find all incident cells     
     if (found)
       {
-        error =get_upward_incidences_edg_3d(cid, leid, adjents, local_id, leids);
+        error =get_up_adjacencies_edg_3d(cid, leid, adjents, local_id, leids);
         if (MB_SUCCESS != error) return error;
       }
 
@@ -1550,7 +1722,11 @@ namespace moab {
   }
 
   //////////////////////////////////////////////////////////////
-  ErrorCode HalfFacetRep::get_upward_incidences_edg_3d( EntityHandle cid,  int leid, std::vector<EntityHandle> &adjents, bool local_id, std::vector<int> * leids)
+  ErrorCode HalfFacetRep::get_up_adjacencies_edg_3d( EntityHandle cid,
+                                                     int leid,
+                                                     std::vector<EntityHandle> &adjents,
+                                                     bool local_id,
+                                                     std::vector<int> * leids)
   {
     ErrorCode error;
 
@@ -1648,7 +1824,10 @@ namespace moab {
   }
  
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  ErrorCode  HalfFacetRep::get_upward_incidences_face_3d( EntityHandle fid, std::vector<EntityHandle> &adjents, bool local_id, std::vector<int> * lfids)
+  ErrorCode  HalfFacetRep::get_up_adjacencies_face_3d( EntityHandle fid,
+                                                       std::vector<EntityHandle> &adjents,
+                                                       bool local_id,
+                                                       std::vector<int> * lfids)
   {
     ErrorCode error;
 
@@ -1657,14 +1836,18 @@ namespace moab {
     bool found = find_matching_halfface(fid, &cid, &lid);
 
     if (found){
-      error = get_upward_incidences_face_3d(cid, lid, adjents, local_id, lfids);
+      error = get_up_adjacencies_face_3d(cid, lid, adjents, local_id, lfids);
       if (MB_SUCCESS != error) return error;
       }
 
     return MB_SUCCESS;
   }
   ///////////////////////////////////////////
-  ErrorCode HalfFacetRep::get_upward_incidences_face_3d( EntityHandle cid,  int lfid, std::vector<EntityHandle> &adjents, bool local_id, std::vector<int> * lfids)
+  ErrorCode HalfFacetRep::get_up_adjacencies_face_3d( EntityHandle cid,
+                                                      int lfid,
+                                                      std::vector<EntityHandle> &adjents,
+                                                      bool local_id,
+                                                      std::vector<int> * lfids)
   {
     ErrorCode error;
 
@@ -1701,7 +1884,9 @@ namespace moab {
     return MB_SUCCESS;
   }
   /////////////////////////////////////////////////////////////////
- bool HalfFacetRep::find_matching_implicit_edge_in_cell( EntityHandle eid, EntityHandle *cid, int *leid)
+ bool HalfFacetRep::find_matching_implicit_edge_in_cell( EntityHandle eid,
+                                                         EntityHandle *cid,
+                                                         int *leid)
   {
     ErrorCode error;
 

diff --git a/src/Makefile.am b/src/Makefile.am
index e2bf713..6fac039 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -226,6 +226,12 @@ if HAVE_CGM
   AM_CPPFLAGS += @CGM_CPPFLAGS@ -DCGM @MOAB_CGM_DEFINES@
 endif
 
+# if ENABLE_ahf
+  # libMOAB_la_SOURCES += HalfFacetRep.cpp
+  # nobase_libMOAB_la_include_HEADERS += moab/HalfFacetRep.hpp
+#  AM_CPPFLAGS += -DUSE_AHF  
+# endif 
+
 MBCN_protos.h: MBCN.h $(top_srcdir)/itaps/mkprotos.sh
 	$(AM_V_GEN)$(top_srcdir)/itaps/mkprotos.sh MBCN MOAB $< $@ MOAB_FCDefs.h
 

diff --git a/src/moab/Core.hpp b/src/moab/Core.hpp
index aa7d9da..941129a 100644
--- a/src/moab/Core.hpp
+++ b/src/moab/Core.hpp
@@ -35,6 +35,10 @@ class EntitySequence;
 class FileOptions;
 class SetIterator;
 
+#ifdef USE_AHF
+class HalfFacetRep;
+#endif
+
 #ifdef XPCOM_MB
 
 #define MBCORE_CID \
@@ -311,12 +315,18 @@ public:
             get_adjacencies( from_entities, MB_1D_ENTITY, adjacencies ); 
             \endcode */
 
-    virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
-                                         const int num_entities,
-                                         const int to_dimension,
-                                         const bool create_if_missing,
-                                         std::vector<EntityHandle>& adj_entities,
-                                         const int operation_type = Interface::INTERSECT);
+  virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
+                                       const int num_entities,
+                                       const int to_dimension,
+                                       const bool create_if_missing,
+                                       std::vector<EntityHandle>& adj_entities,
+                                       const int operation_type = Interface::INTERSECT
+    #ifdef USE_AHF
+      , const bool use_ahf = false);
+    #else
+      );
+    #endif
+
 
     virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
                                         const int num_entities,
@@ -1126,7 +1136,12 @@ public:
     //! return the a_entity_factory pointer
   AEntityFactory *a_entity_factory() { return aEntityFactory; }
   const AEntityFactory *a_entity_factory() const { return aEntityFactory; }
-  
+
+#ifdef USE_AHF
+  HalfFacetRep *a_half_facet_rep() { return ahfRep; }
+  const HalfFacetRep *a_half_facet_rep() const {return ahfRep; }
+#endif
+
     //! return set of registered IO tools
   ReaderWriterSet* reader_writer_set() { return readerWriterSet; }
 
@@ -1347,6 +1362,10 @@ private:
 
     //! list of iterators 
   std::vector<SetIterator*> setIterators;
+
+#ifdef USE_AHF
+  HalfFacetRep *ahfRep;
+#endif
   
 };
 

diff --git a/src/moab/HalfFacetRep.hpp b/src/moab/HalfFacetRep.hpp
index eca5e91..3d1069a 100755
--- a/src/moab/HalfFacetRep.hpp
+++ b/src/moab/HalfFacetRep.hpp
@@ -52,14 +52,15 @@ namespace moab {
    VOLUME_MIXED //Volume mesh with embedded curves and surfaces
   };
 
-   
+  class Core;
+
   class HalfFacetRep{
        
   public:
     
-    HalfFacetRep(Interface *impl) : mb(impl) {}
+    HalfFacetRep(Core *impl);
     
-    ~HalfFacetRep() {}
+    ~HalfFacetRep();
 
     // User interface functions
 
@@ -74,6 +75,12 @@ namespace moab {
     //! Prints the tag values.
     ErrorCode print_tags();
     
+
+    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.
      * Parameters:
@@ -84,7 +91,11 @@ namespace moab {
      * \param lids Vector in which the local id's are returned.
      */
 
-    ErrorCode get_upward_incidences(EntityHandle ent, int out_dim, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int> * lids = NULL );
+    ErrorCode get_up_adjacencies(EntityHandle ent,
+                                 int out_dim,
+                                 std::vector<EntityHandle> &adjents,
+                                 bool local_id = false,
+                                 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.
@@ -94,7 +105,8 @@ namespace moab {
      * \param adjents Vector in which the neighbor entities are returned.
      */
 
-    ErrorCode get_neighbor_adjacencies(EntityHandle ent, std::vector<EntityHandle> &adjents);
+    ErrorCode get_neighbor_adjacencies(EntityHandle ent,
+                                       std::vector<EntityHandle> &adjents);
 
     // 1D Maps and queries
 
@@ -127,7 +139,10 @@ namespace moab {
      * \param lvids Vector returning the local vertex id's
     */
 
-    ErrorCode get_upward_incidences_1d(EntityHandle vid, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int> * lvids = NULL);
+    ErrorCode get_up_adjacencies_1d(EntityHandle vid,
+                                    std::vector<EntityHandle> &adjents,
+                                    bool local_id = false,
+                                    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.
@@ -136,7 +151,8 @@ namespace moab {
      * \param adjents Vector returning neighbor edges
     */
     
-    ErrorCode get_neighbor_adjacencies_1d(EntityHandle eid, std::vector<EntityHandle> &adjents);
+    ErrorCode get_neighbor_adjacencies_1d(EntityHandle eid,
+                                          std::vector<EntityHandle> &adjents);
     
     
     // 2D Maps and queries    
@@ -161,6 +177,9 @@ namespace moab {
 
     ErrorCode determine_incident_halfedges(Range &faces);
 
+   /* ErrorCode get_up_adjacencies_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.
@@ -171,7 +190,10 @@ namespace moab {
      * \param leids Vector returning local edge ids
     */
 
-    ErrorCode get_upward_incidences_2d(EntityHandle eid, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int> * leids = NULL);
+    ErrorCode get_up_adjacencies_2d(EntityHandle eid,
+                                    std::vector<EntityHandle> &adjents,
+                                    bool local_id = false,
+                                    std::vector<int> * leids = NULL);
 
     //! Given a half-edge <fid, leid>, finds the faces incident on it.
     /**
@@ -184,7 +206,12 @@ namespace moab {
      * \param leids Vector returning local edge ids
     */
 
-    ErrorCode get_upward_incidences_2d(EntityHandle fid, int leid, bool add_inent, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int> * leids = NULL);
+    ErrorCode get_up_adjacencies_2d(EntityHandle fid,
+                                    int leid,
+                                    bool add_inent,
+                                    std::vector<EntityHandle> &adjents,
+                                    bool local_id = false,
+                                    std::vector<int> * leids = 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.
@@ -193,7 +220,8 @@ namespace moab {
      * \param adjents Vector returning neighbor faces
     */
        
-    ErrorCode get_neighbor_adjacencies_2d(EntityHandle fid, std::vector<EntityHandle> &adjents);
+    ErrorCode get_neighbor_adjacencies_2d(EntityHandle fid,
+                                          std::vector<EntityHandle> &adjents);
 
     //! Given a range of faces, finds the total number of edges.
     
@@ -229,7 +257,8 @@ namespace moab {
      * \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);
+    ErrorCode determine_border_vertices( Range &cells,
+                                         Tag isborder);
 
     //! 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
@@ -241,7 +270,10 @@ namespace moab {
      * \param leids Vector returning local edge ids
     */
 
-    ErrorCode get_upward_incidences_edg_3d(EntityHandle eid, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int> * leids = NULL);
+    ErrorCode get_up_adjacencies_edg_3d(EntityHandle eid,
+                                        std::vector<EntityHandle> &adjents,
+                                        bool local_id = false,
+                                        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.
@@ -253,7 +285,10 @@ namespace moab {
      * \param leids Vector returning local edge ids
     */
 
-    ErrorCode get_upward_incidences_edg_3d(EntityHandle cid, int leid, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int> * leids = NULL);
+    ErrorCode get_up_adjacencies_edg_3d(EntityHandle cid,
+                                        int leid, std::vector<EntityHandle> &adjents,
+                                        bool local_id = false,
+                                        std::vector<int> * leids = 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
@@ -265,7 +300,10 @@ namespace moab {
      * \param leids Vector returning local face ids
     */
 
-    ErrorCode get_upward_incidences_face_3d(EntityHandle fid, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int>  * lfids = NULL);
+    ErrorCode get_up_adjacencies_face_3d(EntityHandle fid,
+                                         std::vector<EntityHandle> &adjents,
+                                         bool local_id = false,
+                                         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.
@@ -277,7 +315,11 @@ namespace moab {
      * \param lfids Vector returning local face ids
     */
 
-    ErrorCode get_upward_incidences_face_3d(EntityHandle cid, int lfid, std::vector<EntityHandle> &adjents, bool local_id = false, std::vector<int> * lfids = NULL);
+    ErrorCode get_up_adjacencies_face_3d(EntityHandle cid,
+                                         int lfid,
+                                         std::vector<EntityHandle> &adjents,
+                                         bool local_id = false,
+                                         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.
@@ -286,12 +328,17 @@ namespace moab {
      * \param adjents Vector returning neighbor cells
     */
 
-    ErrorCode get_neighbor_adjacencies_3d(EntityHandle cid, std::vector<EntityHandle> &adjents);
+    ErrorCode get_neighbor_adjacencies_3d(EntityHandle cid,
+                                          std::vector<EntityHandle> &adjents);
     
 
   protected:
 
-    Interface * mb;
+    Core * mb;
+
+    HalfFacetRep();
+
+    bool mInitAHFmaps;
 
     enum {
       MAX_VERTICES = 8,
@@ -351,14 +398,23 @@ namespace moab {
      * 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.
      * Parameters:
-     * \param <EntityHandle he_fid, int he_lid>  The query half-edge
-     * \param queue_fid, queue_lid, qsize Array of faces and local edge ids. qsize is the current size of the queue_fid.
+     * \param he_fid EntityHandle of query half-edge
+     * \param he_lid Local id of query half-edge
+     * \param queue_fid
+     * \param queue_lid
+     * \param qsize Array of faces and local edge ids. qsize is the current size of the queue_fid.
      * \param trackfaces Array containing faces. If fid of an incident half-edge doesn't belong to trackfaces,
      *  the half-edge is added to the queue.
      * \param tcount Current size of trackfaces
      */
 
-    ErrorCode get_upward_incidences_2d(EntityHandle he_fid, int he_lid, EntityHandle *queue_fid, int *queue_lid, int *qsize, EntityHandle *trackfaces, int *tcount);
+    ErrorCode get_up_adjacencies_2d(EntityHandle he_fid,
+                                    int he_lid,
+                                    EntityHandle *queue_fid,
+                                    int *queue_lid,
+                                    int *qsize,
+                                    EntityHandle *trackfaces,
+                                    int *tcount);
 
     //! 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
@@ -369,7 +425,9 @@ namespace moab {
      * \param hefid, helid: Returns the matching half-edge corresponding to the query edge.
     */
 
-    bool find_matching_halfedge( EntityHandle eid, EntityHandle *hefid, int *helid);
+    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
@@ -381,7 +439,14 @@ namespace moab {
      * \param trackfaces, tcount
     */
 
-    ErrorCode gather_halfedges( EntityHandle vid,  EntityHandle he_fid,  int he_lid, EntityHandle *queue_fid, int *queue_lid, int *qsize, EntityHandle *trackfaces, int *tcount);
+    ErrorCode gather_halfedges( EntityHandle vid,
+                                EntityHandle he_fid,
+                                int he_lid,
+                                EntityHandle *queue_fid,
+                                int *queue_lid,
+                                int *qsize,
+                                EntityHandle *trackfaces,
+                                int *tcount);
 
     //! 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
@@ -392,7 +457,11 @@ namespace moab {
      * \param <EntityHandle he2_fid, int he2_lid>: Returns another half-edge in the same he_fid sharing vid.
     */
 
-    ErrorCode another_halfedge( EntityHandle vid,  EntityHandle he_fid,  int he_lid, EntityHandle *he2_fid, int *he2_lid);
+    ErrorCode another_halfedge( EntityHandle vid,
+                                EntityHandle he_fid,
+                                int he_lid,
+                                EntityHandle *he2_fid,
+                                int *he2_lid);
 
     //! 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
@@ -404,7 +473,14 @@ namespace moab {
      * \param <EntityHandle he_fid, int he_lid>: Returns matching half-edge
     */
 
-    bool collect_and_compare(std::vector<EntityHandle> &edg_vert, EntityHandle *queue_fid, int *queue_lid, int *qsize, EntityHandle *trackfaces, int *tcount, EntityHandle *he_fid, int *he_lid);
+    bool collect_and_compare(std::vector<EntityHandle> &edg_vert,
+                             EntityHandle *queue_fid,
+                             int *queue_lid,
+                             int *qsize,
+                             EntityHandle *trackfaces,
+                             int *tcount,
+                             EntityHandle *he_fid,
+                             int *he_lid);
 
 
     //! The local maps for 3D entities.
@@ -469,7 +545,9 @@ namespace moab {
      * \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, EntityHandle *cid, int *leid);
+    bool find_matching_implicit_edge_in_cell( EntityHandle eid,
+                                              EntityHandle *cid,
+                                              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.
@@ -479,9 +557,15 @@ namespace moab {
      * \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_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);
+    bool find_match_in_array(EntityHandle ent,
+                             EntityHandle *ent_list,
+                             int count,
+                             bool get_index = false,
+                             int *index = NULL);
 
   };
 

diff --git a/src/moab/Interface.hpp b/src/moab/Interface.hpp
index 09f4219..bfd5fb0 100644
--- a/src/moab/Interface.hpp
+++ b/src/moab/Interface.hpp
@@ -624,7 +624,12 @@ public:
                                       const int to_dimension,
                                       const bool create_if_missing,
                                       std::vector<EntityHandle>& adj_entities,
-                                      const int operation_type = Interface::INTERSECT) = 0;
+                                      const int operation_type = Interface::INTERSECT
+    #ifdef USE_AHF
+      , const bool use_ahf = false) = 0;
+    #else
+      ) = 0;
+    #endif
 
     //! Get the adjacencies associated with a vector of entities to entities of a specfied dimension.
     /** Identical to vector-based get_adjacencies function, except results are returned in a

diff --git a/test/Makefile.am b/test/Makefile.am
index fe7edb6..34432d0 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -61,6 +61,10 @@ if HDF5_FILE
         lloyd_smoother_test
 endif
 
+if ENABLE_ahf
+  TESTS += ahf_mbintf_test
+endif
+
 #                 merge_test \         # input files no longer exist?
 #                 test_tag_server \    # fails
 
@@ -154,6 +158,11 @@ lloyd_smoother_test_SOURCES = lloyd_smoother_test.cpp
 
 ahf_test_SOURCES = test_ahf_moab.cpp
 
+if ENABLE_ahf
+ahf_mbintf_test_SOURCES = test_ahf_mb_interface.cpp
+endif
+
+
 if PARALLEL
 moab_test_CPPFLAGS += -I$(top_srcdir)/src/parallel
 kd_tree_test_CPPFLAGS += -I$(top_srcdir)/src/parallel

diff --git a/test/test_ahf_mb_interface.cpp b/test/test_ahf_mb_interface.cpp
new file mode 100755
index 0000000..9bf76ef
--- /dev/null
+++ b/test/test_ahf_mb_interface.cpp
@@ -0,0 +1,174 @@
+/*This function tests the AHF datastructures on CST meshes*/
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include "moab/Core.hpp"
+#include "moab/Range.hpp"
+#include "moab/MeshTopoUtil.hpp"
+#include "moab/HalfFacetRep.hpp"
+#include "TestUtil.hpp"
+
+using namespace moab;
+
+#ifdef MESHDIR
+static const char example[] = STRINGIFY(MESHDIR) "/hexes_mixed.vtk";
+#else
+static const char example[] = "/hexes_mixed.vtk";
+#endif
+
+void ahf_mbintf_test()
+{
+
+  Core moab;
+  Interface* mbImpl = &moab;
+  MeshTopoUtil mtu(mbImpl);
+
+  ErrorCode error = mbImpl->load_file(example);
+  CHECK_ERR(error);
+
+  /*Create ranges for handles of explicit elements of the mixed mesh*/
+  Range verts, edges, faces, cells;
+  error = mbImpl->get_entities_by_dimension( 0, 0, verts);
+  error = mbImpl->get_entities_by_dimension( 0, 1, edges);
+  error = mbImpl->get_entities_by_dimension( 0, 2, faces);
+  error = mbImpl->get_entities_by_dimension( 0, 3, cells);
+
+  //Perform queries
+  std::vector<EntityHandle> adjents;
+  Range mbents, ahfents;
+
+  //1D Queries //
+  //IQ1: For every vertex, obtain incident edges
+  for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
+    adjents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents, Interface::INTERSECT, true);
+    CHECK_ERR(error);
+    mbents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 1, false, mbents );
+    CHECK_ERR(error);
+
+    CHECK_EQUAL(adjents.size(),mbents.size());
+
+    std::sort(adjents.begin(), adjents.end());
+    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+    mbents = subtract(mbents, ahfents);
+    CHECK(!mbents.size());
+  }
+
+  //NQ1:  For every edge, obtain neighbor edges
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+    adjents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents, Interface::INTERSECT, true);
+    CHECK_ERR(error);
+    mbents.clear();
+    error = mtu.get_bridge_adjacencies( *i, 0, 1, mbents);
+    CHECK_ERR(error);
+
+    CHECK_EQUAL(adjents.size(), mbents.size());
+
+    std::sort(adjents.begin(), adjents.end());
+    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+    mbents = subtract(mbents, ahfents);
+    CHECK(!mbents.size());
+  }
+
+  // 2D Queries
+  //IQ2: For every edge, obtain incident faces
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+    adjents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents, Interface::INTERSECT, true);
+    CHECK_ERR(error);
+    mbents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 2, false, mbents);
+    CHECK_ERR(error);
+
+    CHECK_EQUAL(adjents.size(), mbents.size());
+
+    std::sort(adjents.begin(), adjents.end());
+    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+    mbents = subtract(mbents, ahfents);
+    CHECK(!mbents.size());
+  }
+
+  //NQ2: For every face, obtain neighbor faces
+  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
+    adjents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents, Interface::INTERSECT, true);
+    CHECK_ERR(error);
+    mbents.clear();
+    error = mtu.get_bridge_adjacencies( *i, 1, 2, mbents);
+    CHECK_ERR(error);
+
+    CHECK_EQUAL(adjents.size(), mbents.size());
+
+    std::sort(adjents.begin(), adjents.end());
+    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+    mbents = subtract(mbents, ahfents);
+    CHECK(!mbents.size());
+  }
+
+  // 3D Queries
+  // IQ 31: For every edge, obtain incident cells
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+    adjents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents, Interface::INTERSECT, true);
+    CHECK_ERR(error);
+    mbents.clear();
+    error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
+    CHECK_ERR(error);
+
+    CHECK_EQUAL(adjents.size(), mbents.size());
+
+    std::sort(adjents.begin(), adjents.end());
+    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+    mbents = subtract(mbents, ahfents);
+    CHECK(!mbents.size());
+  }
+
+  //IQ32: For every face, obtain incident cells
+  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
+    adjents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents, Interface::INTERSECT, true);
+    CHECK_ERR(error);
+    mbents.clear();
+    error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
+    CHECK_ERR(error);
+
+    CHECK_EQUAL(adjents.size(), mbents.size());
+
+    std::sort(adjents.begin(), adjents.end());
+    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+    mbents = subtract(mbents, ahfents);
+    CHECK(!mbents.size());
+  }
+
+  //NQ3: For every cell, obtain neighbor cells
+  for (Range::iterator i = cells.begin(); i != cells.end(); ++i) {
+    adjents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents, Interface::INTERSECT, true);
+    CHECK_ERR(error);
+    mbents.clear();
+    error = mtu.get_bridge_adjacencies( *i, 2, 3, mbents);
+    CHECK_ERR(error);
+
+    CHECK_EQUAL(adjents.size(), mbents.size());
+
+    std::sort(adjents.begin(), adjents.end());
+    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+    mbents = subtract(mbents, ahfents);
+    CHECK(!mbents.size());
+  }
+
+}
+
+int main(int argc, char *argv[])
+{
+  int result = 0;
+
+  argv[0] = argv[argc - argc]; // Followed read_mpas_nc.cpp test for removing warnings in serial mode about unused variables.
+
+  result += RUN_TEST(ahf_mbintf_test);
+
+  return result;
+}
+

diff --git a/test/test_ahf_moab.cpp b/test/test_ahf_moab.cpp
index ff97fb1..93bd947 100755
--- a/test/test_ahf_moab.cpp
+++ b/test/test_ahf_moab.cpp
@@ -34,7 +34,7 @@ void ahf_test()
   error = mbImpl->get_entities_by_dimension( 0, 3, cells);
 
   // Create an ahf instance
-  HalfFacetRep ahf(mbImpl);
+  HalfFacetRep ahf(&moab);
 
   // Call the initialize function which creates the maps for each dimension
   ahf.initialize();
@@ -47,7 +47,7 @@ void ahf_test()
   //IQ1: For every vertex, obtain incident edges
   for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
     adjents.clear();
-    error = ahf.get_upward_incidences( *i, 1, adjents);
+    error = ahf.get_up_adjacencies( *i, 1, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies( &*i, 1, 1, false, mbents );
@@ -82,7 +82,7 @@ void ahf_test()
   //IQ2: For every edge, obtain incident faces
   for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
     adjents.clear();
-    error = ahf.get_upward_incidences( *i, 2, adjents);
+    error = ahf.get_up_adjacencies( *i, 2, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies( &*i, 1, 2, false, mbents);
@@ -117,7 +117,7 @@ void ahf_test()
   // IQ 31: For every edge, obtain incident cells
   for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
     adjents.clear();
-    error = ahf.get_upward_incidences( *i, 3, adjents);
+    error = ahf.get_up_adjacencies( *i, 3, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
@@ -134,7 +134,7 @@ void ahf_test()
   //IQ32: For every face, obtain incident cells
   for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
     adjents.clear();
-    error = ahf.get_upward_incidences( *i, 3, adjents);
+    error = ahf.get_up_adjacencies( *i, 3, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
@@ -165,7 +165,7 @@ void ahf_test()
     CHECK(!mbents.size());
   }
 
-  ahf.deinitialize();
+  //ahf.deinitialize();
 
 }
 


https://bitbucket.org/fathomteam/moab/commits/d60db2acc5f9/
Changeset:   d60db2acc5f9
Branch:      None
User:        nray
Date:        2014-07-03 22:22:39
Summary:     Removed tag_iterate from sibling half-facet maps. Changed input to
test_ahf_moab to read in meshfile from command line. Added a test code
for timing and memory requirements.

Affected #:  9 files

diff --git a/src/Core.cpp b/src/Core.cpp
index 3641fd5..692495b 100644
--- a/src/Core.cpp
+++ b/src/Core.cpp
@@ -1540,6 +1540,12 @@ ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
 #else
                                  )
 #endif
+/*ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
+                                     const int num_entities,
+                                     const int to_dimension,
+                                     const bool create_if_missing,
+                                     std::vector<EntityHandle> &adj_entities,
+                                     const int operation_type)*/
 {
 
 #ifdef USE_AHF
@@ -1558,6 +1564,12 @@ ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
         std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
         can_handle = false;
     }
+    else if (to_dimension == 4)
+    {
+        std::cout<<"Currently Not Supported by MOAB_AHF: meshsets"<<std::endl;
+        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
+        can_handle = false;
+    }
     else if (TYPE_FROM_HANDLE(from_entities[0]) == MBPOLYHEDRON)
     {
         std::cout<<"Currently Not Supported by MOAB_AHF: Polyhedron Meshes"<<std::endl;
@@ -1571,7 +1583,9 @@ ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
         can_handle = false;
     }
 
+
     if ((use_ahf) && (can_handle))
+    //if (can_handle)
     {
 
         if (operation_type == Interface::INTERSECT)

diff --git a/src/HalfFacetRep.cpp b/src/HalfFacetRep.cpp
index f3818a6..449a48a 100755
--- a/src/HalfFacetRep.cpp
+++ b/src/HalfFacetRep.cpp
@@ -27,7 +27,7 @@
 
 namespace moab {
 
-  const int MAXSIZE = 500;
+  const int MAXSIZE = 150;
 
   HalfFacetRep::HalfFacetRep(Core *impl)
   {
@@ -573,15 +573,6 @@ namespace moab {
   {
     ErrorCode error;
 
-    EntityHandle start_edge = *edges.begin();
-    int count, *sibhvs_lvid_ptr; EntityHandle *sibhvs_eid_ptr;
-    error = mb->tag_iterate(sibhvs_eid, edges.begin(), edges.end(), count, (void*&)sibhvs_eid_ptr);
-    if (MB_SUCCESS != error) return error;
-    assert(count == (int) edges.size());
-    error = mb->tag_iterate(sibhvs_lvid, edges.begin(), edges.end(), count, (void*&)sibhvs_lvid_ptr);
-    if (MB_SUCCESS != error) return error;
-    assert(count == (int) edges.size());
-
     //Step 1: Create an index list storing the starting position for each vertex
     int nv = _verts.size();
     int *is_index = new int[nv+1];
@@ -595,8 +586,10 @@ namespace moab {
         error = mb->get_connectivity(&*eid, 1, conn);
         if (MB_SUCCESS != error) return error;
 
-        is_index[conn[0]-*_verts.begin()+1] += 1;
-        is_index[conn[1]-*_verts.begin()+1] += 1;
+        int index = _verts.index(conn[0]);
+        is_index[index+1] += 1;
+        index = _verts.index(conn[1]);
+        is_index[index+1] += 1;
       }
     is_index[0] = 0;
 
@@ -615,7 +608,7 @@ namespace moab {
 
         for (int j = 0; j< 2; j++)
           {
-            int v = conn[j] - *_verts.begin();
+            int v = _verts.index(conn[j]);
             v2hv_map_eid[is_index[v]] = *eid;
             v2hv_map_lvid[is_index[v]] = j;
             is_index[v] += 1;
@@ -633,26 +626,59 @@ namespace moab {
         error = mb->get_connectivity(&*eid, 1, conn);
         if (MB_SUCCESS != error) return error;
 
+        EntityHandle sibeid[2];
+        int siblvid[2];
+
+        error = mb->tag_get_data(sibhvs_eid, &*eid, 1, sibeid);
+        if (MB_SUCCESS != error) return error;
+
+        error = mb->tag_get_data(sibhvs_lvid, &*eid, 1, siblvid);
+        if (MB_SUCCESS != error) return error;
+
         for (int k =0; k<2; k++)
           {
-            if (sibhvs_eid_ptr[2*(*eid-start_edge)+k] != 0)
+
+            if (sibeid[k] != 0)
               continue;
 
-            int v = conn[k] - *_verts.begin();
+            int v = _verts.index(conn[k]);
             int last = is_index[v+1] - 1;
             if (last > is_index[v])
               {
                 EntityHandle prev_eid = v2hv_map_eid[last];
                 int prev_lvid = v2hv_map_lvid[last];
+
+                EntityHandle seteid[2];
+                int setlvid[2];
+                error = mb->tag_get_data(sibhvs_eid, &prev_eid, 1, seteid);
+                if (MB_SUCCESS != error) return error;
+
+                error = mb->tag_get_data(sibhvs_lvid, &prev_eid, 1, setlvid);
+                if (MB_SUCCESS != error) return error;
+
                 for (int i=is_index[v]; i<=last; i++)
                   {
                     EntityHandle cur_eid = v2hv_map_eid[i];
                     int cur_lvid = v2hv_map_lvid[i];
-                    sibhvs_eid_ptr[2*(prev_eid-start_edge) + prev_lvid] = cur_eid;
-                    sibhvs_lvid_ptr[2*(prev_eid-start_edge) + prev_lvid] = cur_lvid;
+
+
+                    seteid[prev_lvid] = cur_eid;
+                    setlvid[prev_lvid] = cur_lvid;
+
+                    error = mb->tag_set_data(sibhvs_eid, &prev_eid, 1, seteid);
+                    if (MB_SUCCESS != error) return error;
+
+                    error = mb->tag_set_data(sibhvs_lvid, &prev_eid, 1, setlvid);
+                    if (MB_SUCCESS != error) return error;
 
                     prev_eid = cur_eid;
                     prev_lvid = cur_lvid;
+                    error = mb->tag_get_data(sibhvs_eid, &prev_eid, 1, seteid);
+                    if (MB_SUCCESS != error) return error;
+
+                    error = mb->tag_get_data(sibhvs_lvid, &prev_eid, 1, setlvid);
+                    if (MB_SUCCESS != error) return error;
+
                   }
               }
           }
@@ -663,6 +689,7 @@ namespace moab {
     delete [] is_index;
     delete [] v2hv_map_eid;
     delete [] v2hv_map_lvid;
+
     return MB_SUCCESS;
   }
 
@@ -797,7 +824,7 @@ namespace moab {
     int nepf;
     if (type == MBTRI)  nepf = 3;
     else if (type ==MBQUAD)   nepf = 4;
-    
+
     return nepf;
   }
   /////////////////////////////////////////////////////////////////////////////////
@@ -807,16 +834,13 @@ namespace moab {
     // next: Local ids of next edges
     // prev: Local ids of prev edges
 
-    if (nepf == 3)
-    {  
-      next[0] = 1; next[1] = 2; next[2] = 0;
-      prev[0] = 2; prev[1] = 0; prev[2] = 1;
-    }
-    else if (nepf == 4)
-    {
-      next[0] = 1; next[1] = 2; next[2] = 3; next[3] = 0;
-      prev[0] = 3; prev[1] = 0; prev[2] = 1; prev[3] = 2;
-    }
+    for (int k=0; k<nepf-1; k++)
+       {
+         next[k]=k+1;
+         prev[k+1]=k;
+       }
+       next[nepf-1]=0;
+       prev[0] = nepf-1;
 
     return MB_SUCCESS;
   }
@@ -826,15 +850,6 @@ namespace moab {
     ErrorCode error;
     EntityHandle start_face = *faces.begin();
 
-    // Create pointers to the tags for direct access to memory
-    int count, *sibhes_leid_ptr; EntityHandle *sibhes_fid_ptr;
-    error = mb->tag_iterate(sibhes_fid, faces.begin(), faces.end(), count, (void*&)sibhes_fid_ptr);
-    if (MB_SUCCESS != error) return error;
-    assert(count == (int) faces.size());
-    error = mb->tag_iterate(sibhes_leid, faces.begin(), faces.end(), count, (void*&)sibhes_leid_ptr);
-    if (MB_SUCCESS != error) return error;
-    assert(count == (int) faces.size());
-
     int nepf = local_maps_2d(start_face);
     int * next = new int[nepf];
     int * prev = new int[nepf];
@@ -847,6 +862,7 @@ namespace moab {
     for (int i =0; i<nv+1; i++)
       is_index[i] = 0;
 
+    int index;
     std::vector<EntityHandle> conn(nepf);
     for (Range::iterator fid = faces.begin(); fid != faces.end(); ++fid)
        {
@@ -856,7 +872,8 @@ namespace moab {
 
          for (int i = 0; i<nepf; i++)
            {
-             is_index[conn[i]-*_verts.begin()+1] += 1;
+             index = _verts.index(conn[i]);
+             is_index[index+1] += 1;
            }
        }
      is_index[0] = 0;
@@ -877,7 +894,7 @@ namespace moab {
 
          for (int j = 0; j< nepf; j++)
            {
-             int v = conn[j] - *_verts.begin();
+             int v = _verts.index(conn[j]);
              v2nv[is_index[v]] = conn[next[j]];
              v2he_map_fid[is_index[v]] = *fid;
              v2he_map_leid[is_index[v]] = j;
@@ -889,6 +906,7 @@ namespace moab {
        is_index[i+1] = is_index[i];
      is_index[0] = 0;
 
+
      //Step 3: Fill up sibling half-verts map
      for (Range::iterator fid = faces.begin(); fid != faces.end(); ++fid)
        {
@@ -896,13 +914,22 @@ namespace moab {
          error = mb->get_connectivity(&*fid, 1, conn);
          if (MB_SUCCESS != error) return error;
 
+         EntityHandle *sibfid = new EntityHandle[nepf];
+         int *sibleid = new int[nepf];
+
+         error = mb->tag_get_data(sibhes_fid, &*fid, 1, sibfid);
+         if (MB_SUCCESS != error) return error;
+
+         error = mb->tag_get_data(sibhes_leid, &*fid, 1, sibleid);
+         if (MB_SUCCESS != error) return error;
+
          for (int k =0; k<nepf; k++)
            {
-             if (sibhes_fid_ptr[nepf*(*fid-start_face)+k] != 0)
+             if (sibfid[k] != 0)
                continue;
 
-             int v = conn[k] - *_verts.begin();
-             int vn = conn[next[k]] - *_verts.begin();
+             int v = _verts.index(conn[k]);
+             int vn = _verts.index(conn[next[k]]);
 
              EntityHandle first_fid = *fid;
              int first_leid = k;
@@ -910,38 +937,87 @@ namespace moab {
              EntityHandle prev_fid = *fid;
              int prev_leid = k;
 
-             for (int index = is_index[vn]; index <= is_index[vn+1]-1; index++)
+             EntityHandle *setfid = new EntityHandle[nepf];
+             int *setleid = new int[nepf];
+
+             for (index = is_index[vn]; index <= is_index[vn+1]-1; index++)
                {
                  if (v2nv[index] == conn[k])
                    {
                      EntityHandle cur_fid = v2he_map_fid[index];
                      int cur_leid = v2he_map_leid[index];
-                     sibhes_fid_ptr[nepf*(prev_fid-start_face)+prev_leid] = cur_fid;
-                     sibhes_leid_ptr[nepf*(prev_fid-start_face)+prev_leid] = cur_leid;
+
+                     error = mb->tag_get_data(sibhes_fid, &prev_fid, 1, setfid);
+                     if (MB_SUCCESS != error) return error;
+
+                     error = mb->tag_get_data(sibhes_leid, &prev_fid, 1, setleid);
+                     if (MB_SUCCESS != error) return error;
+
+                     setfid[prev_leid] = cur_fid;
+                     setleid[prev_leid] = cur_leid;
+
+                     error = mb->tag_set_data(sibhes_fid, &prev_fid, 1, setfid);
+                     if (MB_SUCCESS != error) return error;
+
+                     error = mb->tag_set_data(sibhes_leid, &prev_fid, 1, setleid);
+                     if (MB_SUCCESS != error) return error;
+
                      prev_fid = cur_fid;
                      prev_leid = cur_leid;
+
                    }
                }
 
-             for (int index = is_index[v]; index <= is_index[v+1]-1; index++)
+             for (index = is_index[v]; index <= is_index[v+1]-1; index++)
                {
                  if ((v2nv[index] == conn[next[k]])&&(v2he_map_fid[index] != *fid))
                    {
+
                      EntityHandle cur_fid = v2he_map_fid[index];
                      int cur_leid = v2he_map_leid[index];
-                     sibhes_fid_ptr[nepf*(prev_fid-start_face)+prev_leid] = cur_fid;
-                     sibhes_leid_ptr[nepf*(prev_fid-start_face)+prev_leid] = cur_leid;
+
+                     error = mb->tag_get_data(sibhes_fid, &prev_fid, 1, setfid);
+                     if (MB_SUCCESS != error) return error;
+
+                     error = mb->tag_get_data(sibhes_leid, &prev_fid, 1, setleid);
+                     if (MB_SUCCESS != error) return error;
+
+                     setfid[prev_leid] = cur_fid;
+                     setleid[prev_leid] = cur_leid;
+
+                     error = mb->tag_set_data(sibhes_fid, &prev_fid, 1, setfid);
+                     if (MB_SUCCESS != error) return error;
+
+                     error = mb->tag_set_data(sibhes_leid, &prev_fid, 1, setleid);
+                     if (MB_SUCCESS != error) return error;
+
                      prev_fid = cur_fid;
                      prev_leid = cur_leid;
                    }
                }
 
              if (prev_fid != first_fid){
-               sibhes_fid_ptr[nepf*(prev_fid-start_face) + prev_leid] = first_fid;
-               sibhes_leid_ptr[nepf*(prev_fid-start_face) + prev_leid] = first_leid;
-             }
+                 error = mb->tag_get_data(sibhes_fid, &prev_fid, 1, setfid);
+                 if (MB_SUCCESS != error) return error;
+
+                 error = mb->tag_get_data(sibhes_leid, &prev_fid, 1, setleid);
+                 if (MB_SUCCESS != error) return error;
+
+                 setfid[prev_leid] = first_fid;
+                 setleid[prev_leid] = first_leid;
+
+                 error = mb->tag_set_data(sibhes_fid, &prev_fid, 1, setfid);
+                 if (MB_SUCCESS != error) return error;
+
+                 error = mb->tag_set_data(sibhes_leid, &prev_fid, 1, setleid);
+                 if (MB_SUCCESS != error) return error;
 
+             }
+             delete [] setfid;
+             delete [] setleid;
            }
+         delete [] sibfid;
+         delete [] sibleid;
        }
 
      delete [] next;
@@ -1311,7 +1387,7 @@ namespace moab {
 	error = mb->get_connectivity(&curfid, 1, conn);
 	if (MB_SUCCESS != error) return error;
 
-	int id = next[curlid];
+    int id = next[curlid];
 	if (((conn[curlid]==edg_vert[0])&&(conn[id]==edg_vert[1]))||((conn[curlid]==edg_vert[1])&&(conn[id]==edg_vert[0]))){
 	    *he_fid = curfid;
 	    *he_lid = curlid;
@@ -1336,7 +1412,7 @@ namespace moab {
 	counter += 1;
       }
       
-    delete [] next; 
+    delete [] next;
     delete [] prev;
     return found;
   }
@@ -1417,7 +1493,7 @@ namespace moab {
   }
 
   /////////////////////////////////////////////
-   HalfFacetRep::LocalMaps3D HalfFacetRep::lConnMap3D[4] = 
+   const HalfFacetRep::LocalMaps3D HalfFacetRep::lConnMap3D[4] =
     {
       // Tet
       {4, 6, 4, {3,3,3,3}, {{0,1,3},{1,2,3},{2,0,3},{0,2,1}},   {3,3,3,3},   {{0,2,3},{0,1,3},{1,2,3},{0,1,2}},   {{0,1},{1,2},{2,0},{0,3},{1,3},{2,3}},   {{3,0},{3,1},{3,2},{0,2},{0,1},{1,2}},   {{0,4,3},{1,5,4},{2,3,5},{2,1,0}},     {{-1,0,2,3},{0,-1,1,4},{2,1,-1,5},{3,4,5,-1}}},
@@ -1439,16 +1515,6 @@ namespace moab {
   {
     ErrorCode error;
     EntityHandle start_cell = *cells.begin();
-
-    int count, *sibhfs_lfid_ptr;
-    EntityHandle *sibhfs_cid_ptr;
-    error = mb->tag_iterate(sibhfs_cid, cells.begin(), cells.end(), count, (void*&)sibhfs_cid_ptr);
-    if (MB_SUCCESS != error) return error;
-    assert(count == (int) cells.size());
-    error = mb->tag_iterate(sibhfs_lfid, cells.begin(), cells.end(), count, (void*&)sibhfs_lfid_ptr);
-    if (MB_SUCCESS != error) return error;
-    assert(count == (int) cells.size());
-
     int index = get_index_from_type(start_cell);
     int nvpc = lConnMap3D[index].num_verts_in_cell;
     int nfpc = lConnMap3D[index].num_faces_in_cell;
@@ -1459,6 +1525,7 @@ namespace moab {
     for (int i =0; i<nv+1; i++)
       is_index[i] = 0;
 
+    int vindex;
     std::vector<EntityHandle> conn(nvpc);
     for (Range::iterator cid = cells.begin(); cid != cells.end(); ++cid)
        {
@@ -1476,7 +1543,8 @@ namespace moab {
                 if (v <= conn[id])
                   v = conn[id];
               }
-            is_index[v-*_verts.begin()+1] += 1;
+            vindex = _verts.index(v);
+            is_index[vindex+1] += 1;
           }
       }
      is_index[0] = 0;
@@ -1518,7 +1586,7 @@ namespace moab {
              error = local_maps_2d(nvF, next, prev);
              if (MB_SUCCESS != error) return error;
 
-             int v = vmax - *_verts.begin();
+             int v = _verts.index(vmax);
              v2oe_v1[is_index[v]] = vs[next[lv]];
              v2oe_v2[is_index[v]] = vs[prev[lv]];
              v2hf_map_cid[is_index[v]] = *cid;
@@ -1542,9 +1610,18 @@ namespace moab {
          error = mb->get_connectivity(&*cid, 1, conn);
          if (MB_SUCCESS != error) return error;
 
+         EntityHandle *sibcid = new EntityHandle[nfpc];
+         int *siblfid = new int[nfpc];
+
+         error = mb->tag_get_data(sibhfs_cid, &*cid, 1, sibcid);
+         if (MB_SUCCESS != error) return error;
+
+         error = mb->tag_get_data(sibhfs_lfid, &*cid, 1, siblfid);
+         if (MB_SUCCESS != error) return error;
+
          for (int i =0; i<nfpc; i++)
            {
-             if (sibhfs_cid_ptr[nfpc*(*cid-start_cell)+i] != 0)
+             if (sibcid[i] != 0)
                continue;
 
 
@@ -1568,31 +1645,60 @@ namespace moab {
              error = local_maps_2d(nvF, next, prev);
              if (MB_SUCCESS != error) return error;
 
-             int v = vmax - *_verts.begin();
+             int v = _verts.index(vmax);
              EntityHandle v1 = vs[prev[lv]];
              EntityHandle v2 = vs[next[lv]];
 
+             EntityHandle *setcid = new EntityHandle[nfpc];
+             int *setlfid = new int[nfpc];
+
              for (int ind = is_index[v]; ind <= is_index[v+1]-1; ind++)
                {
                  if ((v2oe_v1[ind] == v1)&&(v2oe_v2[ind] == v2))
                    {
-
+                     // Map to opposite hf
                      EntityHandle cur_cid = v2hf_map_cid[ind];
                      int cur_lfid = v2hf_map_lfid[ind];
 
-                     sibhfs_cid_ptr[nfpc*(*cid-start_cell)+i] = cur_cid;
-                     sibhfs_lfid_ptr[nfpc*(*cid-start_cell)+i] = cur_lfid;
+                     error = mb->tag_get_data(sibhfs_cid, &*cid, 1, setcid);
+                     if (MB_SUCCESS != error) return error;
+
+                     error = mb->tag_get_data(sibhfs_lfid, &*cid, 1, setlfid);
+                     if (MB_SUCCESS != error) return error;
+
+                     setcid[i] = cur_cid;
+                     setlfid[i] = cur_lfid;
+
+                     error = mb->tag_set_data(sibhfs_cid, &*cid, 1, setcid);
+                     if (MB_SUCCESS != error) return error;
+                     error = mb->tag_set_data(sibhfs_lfid, &*cid, 1, setlfid);
+                     if (MB_SUCCESS != error) return error;
+
+                     //Map opposite hf to current cell
+                     error = mb->tag_get_data(sibhfs_cid, &cur_cid, 1, setcid);
+                     if (MB_SUCCESS != error) return error;
+
+                     error = mb->tag_get_data(sibhfs_lfid, &cur_cid, 1, setlfid);
+                     if (MB_SUCCESS != error) return error;
 
-                     sibhfs_cid_ptr[nfpc*(cur_cid-start_cell)+cur_lfid] = *cid;
-                     sibhfs_lfid_ptr[nfpc*(cur_cid-start_cell)+cur_lfid] = i;
+                     setcid[cur_lfid] = *cid;
+                     setlfid[cur_lfid] = i;
 
+                     error = mb->tag_set_data(sibhfs_cid, &cur_cid, 1, setcid);
+                     if (MB_SUCCESS != error) return error;
+                     error = mb->tag_set_data(sibhfs_lfid, &cur_cid, 1, setlfid);
+                     if (MB_SUCCESS != error) return error;
                    }
                }
 
              delete [] next;
              delete [] prev;
              delete [] vs;
+             delete [] setcid;
+             delete [] setlfid;
            }
+         delete sibcid;
+         delete siblfid;
        }
 
 
@@ -2115,10 +2221,8 @@ namespace moab {
   bool HalfFacetRep::find_match_in_array(EntityHandle ent, EntityHandle *ent_list, int count, bool get_index, int *index)
   {
     bool found = false;
-   // std::cout<<"count = "<<count<<std::endl;
     for (int i = 0; i<= count; i++)
       {
-     //   std::cout<<"For i = "<<i<<": ent-ent_list[i] = "<<(int)(ent-ent_list[i])<<std::endl;
         if (!((int)(ent - ent_list[i])))
           {
             found = true;

diff --git a/src/moab/Core.hpp b/src/moab/Core.hpp
index 941129a..20aafdc 100644
--- a/src/moab/Core.hpp
+++ b/src/moab/Core.hpp
@@ -328,6 +328,16 @@ public:
     #endif
 
 
+  /*virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
+                                       const int num_entities,
+                                       const int to_dimension,
+                                       const bool create_if_missing,
+                                       std::vector<EntityHandle>& adj_entities,
+                                       const int operation_type = Interface::INTERSECT);*/
+
+
+
+
     virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
                                         const int num_entities,
                                          const int to_dimension,

diff --git a/src/moab/HalfFacetRep.hpp b/src/moab/HalfFacetRep.hpp
index 3d1069a..344dbd1 100755
--- a/src/moab/HalfFacetRep.hpp
+++ b/src/moab/HalfFacetRep.hpp
@@ -533,7 +533,7 @@ namespace moab {
       int lookup_leids[MAX_VERTICES][MAX_VERTICES];
     };
 
-    static  LocalMaps3D lConnMap3D[4];
+    static const LocalMaps3D lConnMap3D[4];
 
     int get_index_from_type(EntityHandle cid);
 

diff --git a/src/moab/Interface.hpp b/src/moab/Interface.hpp
index bfd5fb0..57252e9 100644
--- a/src/moab/Interface.hpp
+++ b/src/moab/Interface.hpp
@@ -630,6 +630,12 @@ public:
     #else
       ) = 0;
     #endif
+  /*virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
+                                      const int num_entities,
+                                      const int to_dimension,
+                                      const bool create_if_missing,
+                                      std::vector<EntityHandle>& adj_entities,
+                                      const int operation_type = Interface::INTERSECT) = 0; */
 
     //! Get the adjacencies associated with a vector of entities to entities of a specfied dimension.
     /** Identical to vector-based get_adjacencies function, except results are returned in a

diff --git a/test/Makefile.am b/test/Makefile.am
index 34432d0..1354e3c 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -61,9 +61,9 @@ if HDF5_FILE
         lloyd_smoother_test
 endif
 
-if ENABLE_ahf
-  TESTS += ahf_mbintf_test
-endif
+# if ENABLE_ahf
+#  TESTS += ahf_mbintf_test
+# endif
 
 #                 merge_test \         # input files no longer exist?
 #                 test_tag_server \    # fails
@@ -158,9 +158,9 @@ lloyd_smoother_test_SOURCES = lloyd_smoother_test.cpp
 
 ahf_test_SOURCES = test_ahf_moab.cpp
 
-if ENABLE_ahf
-ahf_mbintf_test_SOURCES = test_ahf_mb_interface.cpp
-endif
+# if ENABLE_ahf
+# ahf_mbintf_test_SOURCES = test_ahf_mb_interface.cpp
+# endif
 
 
 if PARALLEL

diff --git a/test/perf/Makefile.am b/test/perf/Makefile.am
index f946f94..32e2a57 100644
--- a/test/perf/Makefile.am
+++ b/test/perf/Makefile.am
@@ -7,13 +7,14 @@ AM_CPPFLAGS += -I$(top_srcdir)/src \
             
 LDADD = $(top_builddir)/src/libMOAB.la
 
-check_PROGRAMS = perf seqperf adj_time perftool
+check_PROGRAMS = perf seqperf adj_time perftool ahf_mem_time
 noinst_PROGRAMS = 
 
 perf_SOURCES = perf.cpp
 seqperf_SOURCES = seqperf.cpp
 adj_time_SOURCES = adj_time.cpp
 perftool_SOURCES = perftool.cpp
+ahf_mem_time_SOURCES = test_ahf_mem_time.cpp
 
 if ENABLE_imesh
   LDADD += $(top_builddir)/itaps/imesh/libiMesh.la

diff --git a/test/perf/test_ahf_mem_time.cpp b/test/perf/test_ahf_mem_time.cpp
new file mode 100755
index 0000000..9c72ae7
--- /dev/null
+++ b/test/perf/test_ahf_mem_time.cpp
@@ -0,0 +1,281 @@
+/*This function tests the AHF datastructures on CST meshes*/
+#include <iostream>
+#include <assert.h>
+#include <time.h>
+#include <vector>
+#include "moab/Core.hpp"
+#include "moab/Range.hpp"
+#include "moab/MeshTopoUtil.hpp"
+#include "moab/HalfFacetRep.hpp"
+#include <sys/time.h>
+
+using namespace moab;
+
+#ifdef MESHDIR
+std::string TestDir(STRINGIFY(MESHDIR));
+#else
+std::string TestDir(".");
+#endif
+
+std::string filename;
+
+double wtime() {
+  double y = -1;
+  struct timeval cur_time;  
+  gettimeofday(&cur_time, NULL);  
+  y = (double)(cur_time.tv_sec) + (double)(cur_time.tv_usec)*1.e-6;  
+  return (y);
+}
+
+int main(int argc, char **argv)
+{
+  // Read the input mesh
+    filename = TestDir + "/hexes_mixed.vtk";
+
+    if (argc==1)
+        std::cout<<"Using default input file:"<<filename<<std::endl;
+    else if (argc==2)
+        filename = argv[1];
+    else {
+            std::cerr << "Usage: " << argv[0] << " [filename]" << std::endl;
+            return 1;
+    }
+
+  ErrorCode error;
+  Core moab;
+  Interface* mbImpl = &moab;
+  MeshTopoUtil mtu(mbImpl);
+
+  error = mbImpl->load_file( filename.c_str());
+  if (MB_SUCCESS != error) {
+    std::cerr << filename <<": failed to load file." << std::endl;
+    return error;
+  }
+
+  //Create ranges for handles of explicit elements of the mixed mesh
+  Range verts, edges, faces, cells;
+  error = mbImpl->get_entities_by_dimension( 0, 0, verts);
+  error = mbImpl->get_entities_by_dimension( 0, 1, edges);
+  error = mbImpl->get_entities_by_dimension( 0, 2, faces); 
+  error = mbImpl->get_entities_by_dimension( 0, 3, cells);
+  
+  int nverts = verts.size(); 
+  int nedges = edges.size();
+  int nfaces = faces.size();
+  int ncells = cells.size();
+
+  std::cout<<"nverts = "<<nverts<<", nedges = "<<nedges<<", nfaces = "<<nfaces<<", ncells = "<<ncells<<std::endl;
+
+
+  //Storage Costs before calling ahf functionalities
+  unsigned long sTotS, sTAS, sES, sAES, sAS, sAAS, sTS, sATS;
+  sTotS = sTAS = sES = sAES = sAS = sAAS = sTS = sATS = 0;
+  mbImpl->estimated_memory_use(NULL, 0, &sTotS, &sTAS, &sES, &sAES, &sAS, &sAAS, NULL, 0, &sTS, &sATS);
+  std::cout<<std::endl;
+  std::cout<<"Total storage = "<<sTotS<<std::endl;
+  std::cout<<"Total amortized storage = "<<sTAS<<std::endl;
+  std::cout<<"Entity storage = "<<sES<<std::endl;
+  std::cout<<"Amortized entity storage = "<<sAES<<std::endl;
+  std::cout<<"Adjacency storage = "<<sAS<<std::endl;
+  std::cout<<"Amortized adjacency storage = "<<sAAS<<std::endl;
+  std::cout<<"Tag storage = "<<sTS<<std::endl;
+  std::cout<<"Amortized tag storage = "<<sATS<<std::endl;
+  std::cout<<std::endl;
+
+
+  double time_start, time_elapsed, time_avg;
+
+  // Create an ahf instance
+  HalfFacetRep ahf(&moab);
+
+  // Call the initialize function which creates the maps for each dimension
+  time_start = wtime();
+
+  ahf.initialize();
+
+  time_elapsed = wtime() - time_start;
+  std::cout << "Time taken to construct the MDS = "<<time_elapsed<<" secs"<<std::endl;
+
+  //Storage Costs after calling ahf initialize
+  unsigned long TotS, TAS, ES, AES, AS, AAS, TS, ATS;
+  TotS = TAS = ES = AES = AS = AAS = TS = ATS = 0;
+  mbImpl->estimated_memory_use(NULL, 0, &TotS, &TAS, &ES, &AES, &AS, &AAS, NULL, 0, &TS, &ATS);
+  std::cout<<std::endl;
+  std::cout<<"Total storage = "<<TotS<<std::endl;
+  std::cout<<"Total amortized storage = "<<TAS<<std::endl;
+  std::cout<<"Entity storage = "<<ES<<std::endl;
+  std::cout<<"Amortized entity storage = "<<AES<<std::endl;
+  std::cout<<"Adjacency storage = "<<AS<<std::endl;
+  std::cout<<"Amortized adjacency storage = "<<AAS<<std::endl;
+  std::cout<<"Tag storage = "<<TS<<std::endl;
+  std::cout<<"Amortized tag storage = "<<ATS<<std::endl;
+  std::cout<<std::endl;
+
+  //Perform queries
+  std::vector<EntityHandle> adjents;
+  std::vector<int> lids;
+  Range mbents;
+
+  //1D Queries //
+  //IQ1: For every vertex, obtain incident edges
+  std::cout<<"1D QUERIES"<<std::endl;
+  time_start = wtime();
+  for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {    
+    adjents.clear();
+    error = ahf.get_up_adjacencies( *i, 1, adjents);
+  }
+  time_avg = (wtime()-time_start)/(double)verts.size();
+  std::cout<<"MOAB_AHF: Average time taken to compute incident edges to a vertex =  "<< time_avg<<" secs" <<std::endl;
+
+  error = mbImpl->get_adjacencies( &*verts.begin(), 1, 1, false, mbents );
+  time_start = wtime();
+  for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
+    mbents.clear();
+    error = mbImpl->get_adjacencies( &*i, 1, 1, false, mbents );
+  }
+  time_avg = (wtime()-time_start)/(double)verts.size();
+  std::cout<<"MOAB: Average time taken to compute incident edges to a vertex =  "<< time_avg<<" secs" <<std::endl;
+  std::cout<<std::endl;
+
+
+  //NQ1:  For every edge, obtain neighbor edges  
+  time_start = wtime();
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {    
+    adjents.clear();
+    error = ahf.get_neighbor_adjacencies( *i, adjents);
+  }
+  time_avg = (wtime()-time_start)/(double)edges.size();
+  std::cout<<"MOAB_AHF: Average time taken to compute neighbor edges of an edge = "<<time_avg<<" secs" << std::endl;
+
+  error = mtu.get_bridge_adjacencies( *edges.begin(), 0, 1, mbents);
+  time_start = wtime();
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+    mbents.clear();
+    error = mtu.get_bridge_adjacencies( *i, 0, 1, mbents);
+  }
+  time_avg = (wtime()-time_start)/(double)edges.size();
+  std::cout<<"MOAB: Average time taken to compute neighbor edges of an edge = "<<time_avg<<" secs" << std::endl;
+  std::cout<<std::endl;
+
+
+  // 2D Queries
+  //IQ21: For every edge, obtain incident faces
+  std::cout<<"2D QUERIES"<<std::endl;
+  time_start = wtime();
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {   
+    adjents.clear();
+    error = ahf.get_up_adjacencies( *i, 2, adjents);
+  }
+  time_avg = (wtime()-time_start)/(double)edges.size();
+  std::cout<<"MOAB_AHF: Average time taken to compute incident faces on an edge =  "<<time_avg<<" secs" <<std::endl;
+
+  error = mbImpl->get_adjacencies( &*edges.begin(), 1, 2, false, mbents);
+  time_start = wtime();
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+      mbents.clear();
+      error = mbImpl->get_adjacencies( &*i, 1, 2, false, mbents);
+  }
+  time_avg = (wtime()-time_start)/(double)edges.size();
+  std::cout<<"MOAB: Average time taken to compute incident faces on an edge =  "<<time_avg<<" secs" <<std::endl;
+  std::cout<<std::endl;
+
+  //NQ2: For every face, obtain neighbor faces 
+  time_start = wtime();
+  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {   
+    adjents.clear();
+    error = ahf.get_neighbor_adjacencies( *i, adjents);
+  }
+  time_avg = (wtime()-time_start)/(double)faces.size();
+  std::cout<<"MOAB_AHF: Average time taken to compute neighbor faces of a face = "<< time_avg<<" secs" <<std::endl;
+
+  error = mtu.get_bridge_adjacencies( *faces.begin(), 1, 2, mbents);
+  time_start = wtime();
+  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
+    mbents.clear();
+    error = mtu.get_bridge_adjacencies( *i, 1, 2, mbents);
+  }
+  time_avg = (wtime()-time_start)/(double)faces.size();
+  std::cout<<"MOAB: Average time taken to compute neighbor faces of a face = "<< time_avg<<" secs" <<std::endl;
+  std::cout<<std::endl;
+
+
+  // 3D Queries
+  // IQ 31: For every edge, obtain incident cells
+  std::cout<<"3D QUERIES"<<std::endl;
+  time_start = wtime();
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+    adjents.clear();
+    error = ahf.get_up_adjacencies( *i, 3, adjents);
+  }
+  time_avg = (wtime()-time_start)/(double)edges.size();
+  std::cout<<"MOAB_AHF: Average time taken to compute incident cells on an edge  =  "<<time_avg <<" secs"<<std::endl;
+
+  error = mbImpl->get_adjacencies(&*edges.begin(), 1, 3, false, mbents);
+  time_start = wtime();
+  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+    mbents.clear();
+    error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
+  }
+  time_avg = (wtime()-time_start)/(double)edges.size();
+  std::cout<<"MOAB: Average time taken to compute incident cells on an edge  =  "<<time_avg <<" secs"<<std::endl;
+  std::cout<<std::endl;
+
+  //IQ32: For every face, obtain incident cells
+  time_start = wtime();
+  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
+    adjents.clear();
+    error = ahf.get_up_adjacencies( *i, 3, adjents);
+
+  }
+  time_avg = (wtime()-time_start)/(double)faces.size();
+  std::cout<<"MOAB_AHF: Average time taken to compute incident cells on a face  =  "<<time_avg <<" secs"<<std::endl;
+
+  error = mbImpl->get_adjacencies(&*faces.begin(), 1, 3, false, mbents);
+  time_start = wtime();
+  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
+    mbents.clear();
+    error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
+  }
+  time_avg = (wtime()-time_start)/(double)faces.size();
+  std::cout<<"MOAB: Average time taken to compute incident cells on a face  =  "<<time_avg <<" secs"<<std::endl;
+  std::cout<<std::endl;
+
+  //NQ3: For every cell, obtain neighbor cells
+  time_start = wtime();
+  for (Range::iterator i = cells.begin(); i != cells.end(); ++i) {   
+    adjents.clear();
+    error = ahf.get_neighbor_adjacencies( *i, adjents);
+  }
+  time_avg = (wtime()-time_start)/(double)cells.size();
+  std::cout<<"MOAB_AHF: Average time taken to compute neighbor cells of a cell =  "<< time_avg <<" secs" << std::endl;
+
+  error = mtu.get_bridge_adjacencies( *cells.begin(), 2, 3, mbents);
+  time_start = wtime();
+  for (Range::iterator i = cells.begin(); i != cells.end(); ++i) {
+    mbents.clear();
+    error = mtu.get_bridge_adjacencies( *i, 2, 3, mbents);
+  }
+  time_avg = (wtime()-time_start)/(double)cells.size();
+  std::cout<<"MOAB: Average time taken to compute neighbor cells of a cell =  "<< time_avg <<" secs" << std::endl;
+  std::cout<<std::endl;
+
+  ahf.deinitialize();
+
+  //Storage Costs after calling ahf deinitialize
+  unsigned long eTotS, eTAS, eES, eAES, eAS, eAAS, eTS, eATS;
+  eTotS = eTAS = eES = eAES = eAS = eAAS = eTS = eATS = 0;
+  mbImpl->estimated_memory_use(NULL, 0, &eTotS, &eTAS, &eES, &eAES, &eAS, &eAAS, NULL, 0, &eTS, &eATS);
+  std::cout<<std::endl;
+  std::cout<<"Total storage = "<<eTotS<<std::endl;
+  std::cout<<"Total amortized storage = "<<eTAS<<std::endl;
+  std::cout<<"Entity storage = "<<eES<<std::endl;
+  std::cout<<"Amortized entity storage = "<<eAES<<std::endl;
+  std::cout<<"Adjacency storage = "<<eAS<<std::endl;
+  std::cout<<"Amortized adjacency storage = "<<eAAS<<std::endl;
+  std::cout<<"Tag storage = "<<eTS<<std::endl;
+  std::cout<<"Amortized tag storage = "<<eATS<<std::endl;
+  std::cout<<std::endl;
+
+  return 0;
+}
+

diff --git a/test/test_ahf_moab.cpp b/test/test_ahf_moab.cpp
index 93bd947..e415186 100755
--- a/test/test_ahf_moab.cpp
+++ b/test/test_ahf_moab.cpp
@@ -11,172 +11,203 @@
 using namespace moab;
 
 #ifdef MESHDIR
-static const char example[] = STRINGIFY(MESHDIR) "/hexes_mixed.vtk";
+std::string TestDir(STRINGIFY(MESHDIR));
 #else
-static const char example[] = "/hexes_mixed.vtk";
+std::string TestDir(".");
 #endif
 
-void ahf_test()
-{
-
-  Core moab;
-  Interface* mbImpl = &moab;
-  MeshTopoUtil mtu(mbImpl);
-
-  ErrorCode error = mbImpl->load_file(example);
-  CHECK_ERR(error);
-
-  /*Create ranges for handles of explicit elements of the mixed mesh*/
-  Range verts, edges, faces, cells;
-  error = mbImpl->get_entities_by_dimension( 0, 0, verts);
-  error = mbImpl->get_entities_by_dimension( 0, 1, edges);
-  error = mbImpl->get_entities_by_dimension( 0, 2, faces);
-  error = mbImpl->get_entities_by_dimension( 0, 3, cells);
-
-  // Create an ahf instance
-  HalfFacetRep ahf(&moab);
-
-  // Call the initialize function which creates the maps for each dimension
-  ahf.initialize();
-
-  //Perform queries
-  std::vector<EntityHandle> adjents;
-  Range mbents, ahfents;
-
-  //1D Queries //
-  //IQ1: For every vertex, obtain incident edges
-  for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
-    adjents.clear();
-    error = ahf.get_up_adjacencies( *i, 1, adjents);
-    CHECK_ERR(error);
-    mbents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 1, false, mbents );
-    CHECK_ERR(error);
-
-    CHECK_EQUAL(adjents.size(),mbents.size());
-
-    std::sort(adjents.begin(), adjents.end());
-    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
-    mbents = subtract(mbents, ahfents);
-    CHECK(!mbents.size());
-  }
-
-  //NQ1:  For every edge, obtain neighbor edges
-  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
-    adjents.clear();
-    error = ahf.get_neighbor_adjacencies( *i, adjents);
-    CHECK_ERR(error);
-    mbents.clear();
-    error = mtu.get_bridge_adjacencies( *i, 0, 1, mbents);
-    CHECK_ERR(error);
-
-    CHECK_EQUAL(adjents.size(), mbents.size());
-
-    std::sort(adjents.begin(), adjents.end());
-    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
-    mbents = subtract(mbents, ahfents);
-    CHECK(!mbents.size());
-  }
-
-  // 2D Queries
-  //IQ2: For every edge, obtain incident faces
-  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
-    adjents.clear();
-    error = ahf.get_up_adjacencies( *i, 2, adjents);
-    CHECK_ERR(error);
-    mbents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 2, false, mbents);
-    CHECK_ERR(error);
-
-    CHECK_EQUAL(adjents.size(), mbents.size());
+std::string filename;
 
-    std::sort(adjents.begin(), adjents.end());
-    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
-    mbents = subtract(mbents, ahfents);
-    CHECK(!mbents.size());
-  }
+int number_tests_successful = 0;
+int number_tests_failed = 0;
 
-  //NQ2: For every face, obtain neighbor faces
-  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
-    adjents.clear();
-    error = ahf.get_neighbor_adjacencies( *i, adjents);
-    CHECK_ERR(error);
-    mbents.clear();
-    error = mtu.get_bridge_adjacencies( *i, 1, 2, mbents);
-    CHECK_ERR(error);
-
-    CHECK_EQUAL(adjents.size(), mbents.size());
-
-    std::sort(adjents.begin(), adjents.end());
-    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
-    mbents = subtract(mbents, ahfents);
-    CHECK(!mbents.size());
+void handle_error_code(ErrorCode rv, int &number_failed, int &number_successful)
+{
+  if (rv == MB_SUCCESS) {
+    std::cout << "Success";
+    number_successful++;
+  } else {
+    std::cout << "Failure";
+    number_failed++;
   }
+}
 
-  // 3D Queries
-  // IQ 31: For every edge, obtain incident cells
-  for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
-    adjents.clear();
-    error = ahf.get_up_adjacencies( *i, 3, adjents);
-    CHECK_ERR(error);
-    mbents.clear();
-    error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
-    CHECK_ERR(error);
-
-    CHECK_EQUAL(adjents.size(), mbents.size());
-
-    std::sort(adjents.begin(), adjents.end());
-    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
-    mbents = subtract(mbents, ahfents);
-    CHECK(!mbents.size());
-  }
 
-  //IQ32: For every face, obtain incident cells
-  for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
-    adjents.clear();
-    error = ahf.get_up_adjacencies( *i, 3, adjents);
-    CHECK_ERR(error);
-    mbents.clear();
-    error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
-    CHECK_ERR(error);
-
-    CHECK_EQUAL(adjents.size(), mbents.size());
+ErrorCode ahf_test(Core *moab)
+{
 
-    std::sort(adjents.begin(), adjents.end());
-    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
-    mbents = subtract(mbents, ahfents);
-    CHECK(!mbents.size());
-  }
+    Interface* mbImpl = &*moab;
+    MeshTopoUtil mtu(mbImpl);
 
-  //NQ3: For every cell, obtain neighbor cells
-  for (Range::iterator i = cells.begin(); i != cells.end(); ++i) {
-    adjents.clear();
-    error = ahf.get_neighbor_adjacencies( *i, adjents);
-    CHECK_ERR(error);
-    mbents.clear();
-    error = mtu.get_bridge_adjacencies( *i, 2, 3, mbents);
+    ErrorCode error = mbImpl->load_file(filename.c_str());
     CHECK_ERR(error);
 
-    CHECK_EQUAL(adjents.size(), mbents.size());
-
-    std::sort(adjents.begin(), adjents.end());
-    std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
-    mbents = subtract(mbents, ahfents);
-    CHECK(!mbents.size());
-  }
-
-  //ahf.deinitialize();
+    /*Create ranges for handles of explicit elements of the mixed mesh*/
+    Range verts, edges, faces, cells;
+    error = mbImpl->get_entities_by_dimension( 0, 0, verts);
+    error = mbImpl->get_entities_by_dimension( 0, 1, edges);
+    error = mbImpl->get_entities_by_dimension( 0, 2, faces);
+    error = mbImpl->get_entities_by_dimension( 0, 3, cells);
+
+    // Create an ahf instance
+    HalfFacetRep ahf(&*moab);
+
+    // Call the initialize function which creates the maps for each dimension
+    ahf.initialize();
+
+    //ahf.print_tags();
+
+    //Perform queries
+    std::vector<EntityHandle> adjents;
+    Range mbents, ahfents;
+
+    //1D Queries //
+    //IQ1: For every vertex, obtain incident edges
+    for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_up_adjacencies( *i, 1, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mbImpl->get_adjacencies( &*i, 1, 1, false, mbents );
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(),mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    //NQ1:  For every edge, obtain neighbor edges
+    for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_neighbor_adjacencies( *i, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mtu.get_bridge_adjacencies( *i, 0, 1, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    // 2D Queries
+    //IQ2: For every edge, obtain incident faces
+    for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_up_adjacencies( *i, 2, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mbImpl->get_adjacencies( &*i, 1, 2, false, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    //NQ2: For every face, obtain neighbor faces
+    for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_neighbor_adjacencies( *i, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mtu.get_bridge_adjacencies( *i, 1, 2, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    // 3D Queries
+    // IQ 31: For every edge, obtain incident cells
+    for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_up_adjacencies( *i, 3, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    //IQ32: For every face, obtain incident cells
+    for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_up_adjacencies( *i, 3, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    //NQ3: For every cell, obtain neighbor cells
+    for (Range::iterator i = cells.begin(); i != cells.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_neighbor_adjacencies( *i, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mtu.get_bridge_adjacencies( *i, 2, 3, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    return MB_SUCCESS;
 
 }
 
 int main(int argc, char *argv[])
 {
-  int result = 0;
-
-  argv[0] = argv[argc - argc]; // Followed read_mpas_nc.cpp test for removing warnings in serial mode about unused variables.
-
-  result += RUN_TEST(ahf_test);
-
-  return result;
+    filename = TestDir + "/hexes_mixed.vtk";
+
+    if (argc==1)
+        std::cout<<"Using default input file:"<<filename<<std::endl;
+    else if (argc==2)
+        filename = argv[1];
+    else {
+            std::cerr << "Usage: " << argv[0] << " [filename]" << std::endl;
+            return 1;
+    }
+
+    Core moab;
+    ErrorCode result;
+
+    std::cout<<" ahf_test: ";
+    result = ahf_test(&moab);
+    handle_error_code(result, number_tests_failed, number_tests_successful);
+    std::cout<<"\n";
+
+    return number_tests_failed;
 }
 


https://bitbucket.org/fathomteam/moab/commits/fcf20c1271d9/
Changeset:   fcf20c1271d9
Branch:      nray/feature_ahf
User:        nray
Date:        2014-07-03 22:22:39
Summary:     Removed 'use_ahf' flag from get_adjacencies interface in Core/Interface.
Passed make check.

Affected #:  9 files

diff --git a/src/Core.cpp b/src/Core.cpp
index 692495b..3340934 100644
--- a/src/Core.cpp
+++ b/src/Core.cpp
@@ -280,6 +280,7 @@ ErrorCode Core::initialize()
   ahfRep = new HalfFacetRep(this);
   if (!ahfRep)
     return MB_MEMORY_ALLOCATION_FAILED;
+  mesh_modified = false;
 #endif
 
   return MB_SUCCESS;
@@ -1353,14 +1354,11 @@ ErrorCode get_adjacencies_union( Core* gMB,
   return result;
 }
 
-
-///////////////////////////
-///
-#ifdef USE_AHF
 template <typename ITER> static inline
-ErrorCode get_adjacencies_intersection_ahf(Core *mb,
+ErrorCode get_adjacencies_intersection( Core* mb,
                              ITER begin, ITER end,
                              const int to_dimension,
+                             const bool create_if_missing,
                              std::vector<EntityHandle>& adj_entities )
 {
   const size_t SORT_THRESHOLD = 200;
@@ -1378,11 +1376,13 @@ ErrorCode get_adjacencies_intersection_ahf(Core *mb,
     // input list), we begin with the adjacencies for the first entity.
   if (adj_entities.empty()) {
     EntityType type = TYPE_FROM_HANDLE(*begin);
-
-    if(to_dimension == 0 && type != MBPOLYHEDRON)
+    if (to_dimension == CN::Dimension(type))
+      adj_entities.push_back(*begin);
+    else if(to_dimension == 0 && type != MBPOLYHEDRON)
       result = mb->get_connectivity(&(*begin), 1, adj_entities);
     else
-      result = mb->a_half_facet_rep()->get_adjacencies(*begin, to_dimension, adj_entities);
+      result = mb->a_entity_factory()->get_adjacencies(*begin, to_dimension,
+                                                   create_if_missing, adj_entities);
     if (MB_SUCCESS != result)
       return result;
     ++begin;
@@ -1395,10 +1395,13 @@ ErrorCode get_adjacencies_intersection_ahf(Core *mb,
 
       // get the next set of adjacencies
     EntityType type = TYPE_FROM_HANDLE(*from_it);
-    if(to_dimension == 0 && type != MBPOLYHEDRON)
+    if (to_dimension == CN::Dimension(type))
+      temp_vec.push_back(*from_it);
+    else if(to_dimension == 0 && type != MBPOLYHEDRON)
       result = mb->get_connectivity(&(*from_it), 1, temp_vec);
     else
-      result = mb->a_half_facet_rep()->get_adjacencies(*from_it, to_dimension, temp_vec);
+      result = mb->a_entity_factory()->get_adjacencies(*from_it, to_dimension,
+                                                   create_if_missing, temp_vec);
     if (MB_SUCCESS != result)
       return result;
 
@@ -1424,14 +1427,43 @@ ErrorCode get_adjacencies_intersection_ahf(Core *mb,
 
   return MB_SUCCESS;
 }
-#endif
-///////////////////////////////////////////
 
 template <typename ITER> static inline
 ErrorCode get_adjacencies_intersection( Core* mb,
                              ITER begin, ITER end,
                              const int to_dimension,
                              const bool create_if_missing,
+                             Range& adj_entities )
+{
+  std::vector<EntityHandle> results;
+  ErrorCode rval = moab::get_adjacencies_intersection( mb, begin, end, to_dimension,
+						       create_if_missing, results );
+  if (MB_SUCCESS != rval)
+    return rval;
+
+  if (adj_entities.empty()) {
+    std::copy( results.begin(), results.end(), range_inserter(adj_entities) );
+    return MB_SUCCESS;
+  }
+
+  Range::iterator it = adj_entities.begin();
+  while (it != adj_entities.end()) {
+    if (std::find( results.begin(), results.end(), *it) == results.end())
+      it = adj_entities.erase( it );
+    else
+      ++it;
+  }
+  return MB_SUCCESS;
+}
+
+///////////////////////////////////////////////////////////////////
+//////////////////////////////////////////
+#ifdef USE_AHF
+
+template <typename ITER> static inline
+ErrorCode get_adjacencies_intersection_ahf(Core *mb,
+                             ITER begin, ITER end,
+                             const int to_dimension,
                              std::vector<EntityHandle>& adj_entities )
 {
   const size_t SORT_THRESHOLD = 200;
@@ -1449,13 +1481,11 @@ ErrorCode get_adjacencies_intersection( Core* mb,
     // input list), we begin with the adjacencies for the first entity.
   if (adj_entities.empty()) {
     EntityType type = TYPE_FROM_HANDLE(*begin);
-    if (to_dimension == CN::Dimension(type))
-      adj_entities.push_back(*begin);
-    else if(to_dimension == 0 && type != MBPOLYHEDRON)
+
+    if(to_dimension == 0 && type != MBPOLYHEDRON)
       result = mb->get_connectivity(&(*begin), 1, adj_entities);
     else
-      result = mb->a_entity_factory()->get_adjacencies(*begin, to_dimension,
-                                                   create_if_missing, adj_entities);
+      result = mb->a_half_facet_rep()->get_adjacencies(*begin, to_dimension, adj_entities);
     if (MB_SUCCESS != result)
       return result;
     ++begin;
@@ -1468,13 +1498,10 @@ ErrorCode get_adjacencies_intersection( Core* mb,
 
       // get the next set of adjacencies
     EntityType type = TYPE_FROM_HANDLE(*from_it);
-    if (to_dimension == CN::Dimension(type))
-      temp_vec.push_back(*from_it);
-    else if(to_dimension == 0 && type != MBPOLYHEDRON)
+    if(to_dimension == 0 && type != MBPOLYHEDRON)
       result = mb->get_connectivity(&(*from_it), 1, temp_vec);
     else
-      result = mb->a_entity_factory()->get_adjacencies(*from_it, to_dimension,
-                                                   create_if_missing, temp_vec);
+      result = mb->a_half_facet_rep()->get_adjacencies(*from_it, to_dimension, temp_vec);
     if (MB_SUCCESS != result)
       return result;
 
@@ -1500,52 +1527,16 @@ ErrorCode get_adjacencies_intersection( Core* mb,
 
   return MB_SUCCESS;
 }
+#endif
 
-template <typename ITER> static inline
-ErrorCode get_adjacencies_intersection( Core* mb,
-                             ITER begin, ITER end,
-                             const int to_dimension,
-                             const bool create_if_missing,
-                             Range& adj_entities )
-{
-  std::vector<EntityHandle> results;
-  ErrorCode rval = moab::get_adjacencies_intersection( mb, begin, end, to_dimension,
-						       create_if_missing, results );
-  if (MB_SUCCESS != rval)
-    return rval;
-
-  if (adj_entities.empty()) {
-    std::copy( results.begin(), results.end(), range_inserter(adj_entities) );
-    return MB_SUCCESS;
-  }
-
-  Range::iterator it = adj_entities.begin();
-  while (it != adj_entities.end()) {
-    if (std::find( results.begin(), results.end(), *it) == results.end())
-      it = adj_entities.erase( it );
-    else
-      ++it;
-  }
-  return MB_SUCCESS;
-}
+///////////////////////////////////////////
 
 ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
                                      const int num_entities,
                                      const int to_dimension,
                                      const bool create_if_missing,
                                      std::vector<EntityHandle> &adj_entities,
-                                     const int operation_type
-#ifdef USE_AHF
-                                 , const bool use_ahf)
-#else
-                                 )
-#endif
-/*ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
-                                     const int num_entities,
-                                     const int to_dimension,
-                                     const bool create_if_missing,
-                                     std::vector<EntityHandle> &adj_entities,
-                                     const int operation_type)*/
+                                     const int operation_type)
 {
 
 #ifdef USE_AHF
@@ -1553,41 +1544,22 @@ ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
     int source_dim = this->dimension_from_handle(from_entities[0]);
 
     if ((source_dim > to_dimension) && (to_dimension != 0))
-    {
-        std::cout<<"Currently Not Supported by MOAB_AHF: Down Adjacencies"<<std::endl;
-        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
-        can_handle = false;
-    }
-    else if (((source_dim == 0) && (to_dimension == 2))||((source_dim == 0) && (to_dimension == 3)))
-    {
-        std::cout<<"Currently Not Supported by MOAB_AHF: Vertex to face/cell"<<std::endl;
-        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
-        can_handle = false;
-    }
+        can_handle = false; //NOT SUPPORTED: Down adjacencies
     else if (to_dimension == 4)
-    {
-        std::cout<<"Currently Not Supported by MOAB_AHF: meshsets"<<std::endl;
-        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
-        can_handle = false;
-    }
-    else if (TYPE_FROM_HANDLE(from_entities[0]) == MBPOLYHEDRON)
-    {
-        std::cout<<"Currently Not Supported by MOAB_AHF: Polyhedron Meshes"<<std::endl;
-        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
-        can_handle = false;
-    }
+        can_handle = false; // NOT SUPPORTED: meshsets
     else if (create_if_missing)
-    {
-        std::cout<<"Currently Not Supporteded by MOAB_AHF: create_if_missing capability "<<std::endl;
-        std::cout<<"Reverting to MOAB adjacency functionality"<<std::endl;
+        can_handle = false;//NOT SUPPORTED: create_if_missing
+
+    bool mixed = ahfRep->check_mixed_entity_type(); //NOT SUPPORTED: mixed entity types or polygonal/hedrals types
+    if (mixed)
         can_handle = false;
-    }
 
+    if (mesh_modified)
+        can_handle = false;
 
-    if ((use_ahf) && (can_handle))
-    //if (can_handle)
+    if (can_handle)
     {
-
+        ErrorCode result;
         if (operation_type == Interface::INTERSECT)
             return get_adjacencies_intersection_ahf(this, from_entities, from_entities+num_entities,
                                                     to_dimension, adj_entities );
@@ -1595,7 +1567,7 @@ ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
             return MB_FAILURE;
 
         // do union
-        ErrorCode result;
+
         std::vector<EntityHandle> tmp_storage;
         const EntityHandle* conn;
         int len;
@@ -1668,14 +1640,14 @@ ErrorCode Core::get_adjacencies( const EntityHandle *from_entities,
                                      Range &adj_entities,
                                      const int operation_type )
 {
-  if (operation_type == Interface::INTERSECT)
-    return get_adjacencies_intersection( this, from_entities, from_entities + num_entities,
-                                         to_dimension, create_if_missing, adj_entities );
-  else if (operation_type == Interface::UNION)
-    return get_adjacencies_union( this, from_entities, from_entities + num_entities,
-                                  to_dimension, create_if_missing, adj_entities );
-  else
-    return MB_FAILURE;
+    if (operation_type == Interface::INTERSECT)
+        return get_adjacencies_intersection( this, from_entities, from_entities + num_entities,
+                                             to_dimension, create_if_missing, adj_entities );
+    else if (operation_type == Interface::UNION)
+        return get_adjacencies_union( this, from_entities, from_entities + num_entities,
+                                      to_dimension, create_if_missing, adj_entities );
+    else
+        return MB_FAILURE;
 }
 
 ErrorCode Core::get_connectivity( const Range& from_entities,
@@ -2754,6 +2726,11 @@ ErrorCode Core::create_element(const EntityType type,
   if (MB_SUCCESS == status)
     status = aEntityFactory->notify_create_entity( handle, connectivity, num_nodes);
 
+#ifdef USE_AHF
+  mesh_modified = true;
+#endif
+
+
   return status;
 }
 

diff --git a/src/HalfFacetRep.cpp b/src/HalfFacetRep.cpp
index 449a48a..18a8a0d 100755
--- a/src/HalfFacetRep.cpp
+++ b/src/HalfFacetRep.cpp
@@ -34,6 +34,8 @@ namespace moab {
     assert(NULL != impl);
     mb = impl;
     mInitAHFmaps = false;
+    chk_mixed = false;
+    is_mixed = false;
   }
 
   HalfFacetRep::~HalfFacetRep()
@@ -65,6 +67,89 @@ namespace moab {
     return mesh_type;
   }
 
+  const HalfFacetRep::adj_matrix HalfFacetRep::adjMatrix[7] =
+  {
+      // Stores the adjacency matrix for each mesh type.
+      //CURVE
+      {{{0,1,0,0},{1,1,0,0},{0,0,0,0},{0,0,0,0}}},
+
+      //SURFACE
+      {{{0,0,1,0},{0,0,0,0},{1,0,1,0},{0,0,0,0}}},
+
+      //SURFACE_MIXED
+      {{{0,1,1,0},{1,1,1,0},{1,0,1,0},{0,0,0,0}}},
+
+      //VOLUME
+      {{{0,0,0,1},{0,0,0,0},{0,0,0,0},{1,0,0,1}}},
+
+      //VOLUME_MIXED_1
+      {{{0,1,0,1},{1,1,0,1},{0,0,0,0},{1,0,0,1}}},
+
+      //VOLUME_MIXED_2
+      {{{0,0,1,1},{0,0,0,0},{1,0,1,1},{1,0,0,1}}},
+
+      //VOLUME_MIXED
+      {{{0,1,1,1},{1,1,1,1},{1,0,1,1},{1,0,0,1}}}
+  };
+
+  int HalfFacetRep::get_index_for_meshtype(MESHTYPE mesh_type)
+  {
+      int index;
+      if (mesh_type == CURVE) index = 0;
+      else if (mesh_type == SURFACE) index = 1;
+      else if (mesh_type == SURFACE_MIXED) index = 2;
+      else if (mesh_type == VOLUME)  index = 3;
+      else if (mesh_type == VOLUME_MIXED_1) index = 4;
+      else if (mesh_type == VOLUME_MIXED_2) index = 5;
+      else if (mesh_type == VOLUME_MIXED) index = 6;
+      return index;
+  }
+
+  bool HalfFacetRep::check_mixed_entity_type()
+  {
+      if (!chk_mixed)
+      {
+          chk_mixed = true;
+
+          ErrorCode error;
+          Range felems, celems;
+
+          error = mb->get_entities_by_dimension( 0, 2, felems );
+          if (MB_SUCCESS != error) return error;
+
+          if (felems.size()){
+              Range tris, quad, poly;
+              tris = felems.subset_by_type(MBTRI);
+              quad = felems.subset_by_type(MBQUAD);
+              poly = felems.subset_by_type(MBPOLYGON);
+              if ((tris.size()&&quad.size())||(tris.size()&&poly.size())||(quad.size()&&poly.size()))
+                  is_mixed = true;
+              if (poly.size())
+                  is_mixed = true;
+
+              return is_mixed;
+          }
+
+          error = mb->get_entities_by_dimension( 0, 3, celems);
+          if (MB_SUCCESS != error) return error;
+          if (celems.size()){
+              Range tet, pyr, prism, hex, polyhed;
+              tet = celems.subset_by_type(MBTET);
+              pyr = celems.subset_by_type(MBPYRAMID);
+              prism = celems.subset_by_type(MBPRISM);
+              hex = celems.subset_by_type(MBHEX);
+              polyhed = celems.subset_by_type(MBPOLYHEDRON);
+              if ((tet.size() && pyr.size())||(tet.size() && prism.size())||(tet.size() && hex.size())||(tet.size()&&polyhed.size())||(pyr.size() && prism.size())||(pyr.size() && hex.size()) ||(pyr.size()&&polyhed.size())|| (prism.size() && hex.size())||(prism.size()&&polyhed.size())||(hex.size()&&polyhed.size()))
+                  is_mixed = true;
+
+              if (polyhed.size())
+                  is_mixed = true;
+              return is_mixed;
+          }
+      }
+      return is_mixed;
+  }
+
   /*******************************************************
    * initialize                                          *
    ******************************************************/
@@ -93,8 +178,10 @@ namespace moab {
     int ncells = _cells.size();
 
     MESHTYPE mesh_type = get_mesh_type(nverts, nedges, nfaces, ncells);
-    std::cout<<"MeshType = "<<mesh_type<<std::endl;
- 
+    thismeshtype = mesh_type;
+    std::cout<<"MeshType = "<<thismeshtype<<std::endl;
+  
+    //Initialize mesh type specific maps
     if (mesh_type == CURVE){
         error = init_curve();
         if (MB_SUCCESS != error) return error;
@@ -460,50 +547,78 @@ namespace moab {
 
       if (mInitAHFmaps == false)
       {
-       error = initialize();
-       if (MB_SUCCESS != error) return error;
-      }
-
-      if ((source_dimension == 0) && (target_dimension == 1))
-      {
-          error = get_up_adjacencies_1d(source_entity, target_entities);
+          error = initialize();
           if (MB_SUCCESS != error) return error;
       }
 
-      else if ((source_dimension == 1) && (target_dimension == 2))
-      {
-          error = get_up_adjacencies_2d(source_entity, target_entities);
-          if (MB_SUCCESS != error) return error;
-      }
-      else if ((source_dimension == 1) && (target_dimension == 3))
-      {
-          error = get_up_adjacencies_edg_3d(source_entity, target_entities);
-          if (MB_SUCCESS != error) return error;
-      }
-      else if ((source_dimension == 2) && (target_dimension ==3))
-      {
-          error = get_up_adjacencies_face_3d(source_entity, target_entities);
-          if (MB_SUCCESS != error) return error;
-      }
-      else if (source_dimension == target_dimension)
+      int mindex = get_index_for_meshtype(thismeshtype);
+      int adj_possible = adjMatrix[mindex].val[source_dimension][target_dimension];
+
+      if (adj_possible)
       {
-          if (target_dimension == 1)
+
+          if (source_dimension == 0) // Vertex to up adjacencies
           {
-              error = get_neighbor_adjacencies_1d(source_entity, target_entities);
-              if (MB_SUCCESS != error) return error;
+              if (target_dimension == 1)
+              {
+                  error = get_up_adjacencies_1d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
+              else if (target_dimension == 2)
+              {
+                  error = get_up_adjacencies_vert_2d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
+              else if (target_dimension == 3)
+              {
+                  error = get_up_adjacencies_vert_3d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
           }
 
-          else if (target_dimension == 2)
+          else if (source_dimension == 1) // Edge to up adjacencies
           {
-              error = get_neighbor_adjacencies_2d(source_entity, target_entities);
-              if (MB_SUCCESS != error) return error;
+              if (target_dimension == 2)
+              {
+                  error = get_up_adjacencies_2d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
+              else if (target_dimension == 3)
+              {
+                  error = get_up_adjacencies_edg_3d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
           }
-          else if (target_dimension == 3)
+
+          else if ((source_dimension == 2) && (target_dimension ==3)) // Face to up adjacencies
           {
-              error = get_neighbor_adjacencies_3d(source_entity, target_entities);
+              error = get_up_adjacencies_face_3d(source_entity, target_entities);
               if (MB_SUCCESS != error) return error;
           }
+
+          else if (source_dimension == target_dimension) // Same dimensional adjacencies
+          {
+              if (target_dimension == 1)
+              {
+                  error = get_neighbor_adjacencies_1d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
+
+              else if (target_dimension == 2)
+              {
+                  error = get_neighbor_adjacencies_2d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
+              else if (target_dimension == 3)
+              {
+                  error = get_neighbor_adjacencies_3d(source_entity, target_entities);
+                  if (MB_SUCCESS != error) return error;
+              }
+          }
       }
+      else
+          return MB_SUCCESS;
+
       return MB_SUCCESS;
   }
 
@@ -517,10 +632,23 @@ namespace moab {
     ErrorCode error;
     int in_dim = mb->dimension_from_handle(ent);
 
-    if ((in_dim == 0) && (out_dim == 1))
+    if (in_dim == 0)
       {
-        error = get_up_adjacencies_1d(ent, adjents, local_id, lids);
-        if (MB_SUCCESS != error) return error;
+        if (out_dim == 1)
+        {
+            error = get_up_adjacencies_1d(ent, adjents, local_id, lids);
+            if (MB_SUCCESS != error) return error;
+        }
+        else if (out_dim == 2)
+        {
+            error = get_up_adjacencies_vert_2d(ent, adjents);
+            if (MB_SUCCESS != error) return error;
+        }
+        else if (out_dim == 3)
+        {
+            error = get_up_adjacencies_vert_3d(ent, adjents);
+            if (MB_SUCCESS != error) return error;
+        }
       }
 
     else if ((in_dim == 1) && (out_dim == 2))
@@ -1070,7 +1198,7 @@ namespace moab {
     return MB_SUCCESS;
   }
   ///////////////////////////////////////////////////////////////////
- /* ErrorCode HalfFacetRep::get_up_adjacencies_2d(EntityHandle vid, std::vector<EntityHandle> &adjents)
+  ErrorCode HalfFacetRep::get_up_adjacencies_vert_2d(EntityHandle vid, std::vector<EntityHandle> &adjents)
   {
     ErrorCode error;
 
@@ -1092,12 +1220,12 @@ namespace moab {
             queue_lid[i] = 0;
             trackfaces[i] = 0;
           }
-        int qsize = 0, tcount = -1;
+        int qsize = 0, count = -1;
         int num_qvals = 0;
-        error = gather_halfedges(vid, fid, lid, queue_fid, queue_lid, &qsize, trackfaces, &tcount);
+        error = gather_halfedges(vid, fid, lid, queue_fid, queue_lid, &qsize, trackfaces, &count);
         if (MB_SUCCESS != error) return error;
 
-        while (num_qvals < *qsize)
+        while (num_qvals < qsize)
           {
             EntityHandle curfid = queue_fid[num_qvals];
             int curlid = queue_lid[num_qvals];
@@ -1107,22 +1235,23 @@ namespace moab {
             error = another_halfedge(vid, curfid, curlid, &he2_fid, &he2_lid);
             if (MB_SUCCESS != error) return error;
 
-            bool found_ent = find_match_in_array(he2_fid, trackfaces, tcount[0]);
+            bool found_ent = find_match_in_array(he2_fid, trackfaces, count);
 
             if (found_ent)
               continue;
-            tcount[0] += 1;
-            trackfaces[tcount[0]] = he2_fid;
+            count += 1;
+            trackfaces[count] = he2_fid;
 
-            error = get_up_adjacencies_2d(he2_fid, he2_lid, queue_fid, queue_lid, qsize, trackfaces, tcount);
+            error = get_up_adjacencies_2d(he2_fid, he2_lid, queue_fid, queue_lid, &qsize, trackfaces, &count);
             if (MB_SUCCESS != error) return error;
 
             adjents.push_back(he2_fid);
 
           }
       }
+    return MB_SUCCESS;
   }
-*/
+
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   ErrorCode  HalfFacetRep::get_up_adjacencies_2d( EntityHandle eid,
                                                   std::vector<EntityHandle> &adjents,
@@ -1803,6 +1932,85 @@ namespace moab {
 
     return MB_SUCCESS;
   }
+  ////////////////////////////////////////////////////////////////////////
+  ErrorCode HalfFacetRep::get_up_adjacencies_vert_3d(EntityHandle vid, std::vector<EntityHandle> &adjents)
+  {
+      ErrorCode error;
+
+      // Obtain a half-face incident on v
+      EntityHandle cur_cid = 0;
+      error = mb->tag_get_data(v2hf_cid, &vid, 1, &cur_cid);
+      if (MB_SUCCESS != error) return error;
+
+      int index = get_index_from_type(cur_cid);
+      int nvpc = lConnMap3D[index].num_verts_in_cell;
+      int nfpc = lConnMap3D[index].num_faces_in_cell;
+
+      // Collect all incident cells
+      if (cur_cid != 0){
+          EntityHandle Stkcells[MAXSIZE], trackcells[MAXSIZE];
+          for (int i = 0; i< MAXSIZE; i++)
+            {
+              Stkcells[i] = 0;
+              trackcells[i] = 0;
+            }
+          int Stksize = 0, count = -1;
+          Stkcells[0] = cur_cid;
+
+          while (Stksize >= 0 ){
+              cur_cid = Stkcells[Stksize];
+              Stksize -= 1 ;
+
+              bool found = find_match_in_array(cur_cid, trackcells, count);
+              if (!found){
+                  count += 1;
+                  trackcells[count] = cur_cid;
+
+                  // Add the current cell
+                  adjents.push_back(cur_cid);
+              }
+
+              // Connectivity of the cell
+              std::vector<EntityHandle> conn;
+              error = mb->get_connectivity(&cur_cid, 1, conn);
+              if (MB_SUCCESS != error) return error;
+
+              // Local id of vid in the cell and the half-faces incident on it
+              int lv;
+              for (int i = 0; i< nvpc; ++i){
+                  if (conn[i] == vid)
+                      lv = i;
+              };
+
+              int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
+
+              // Add other cells that are incident on vid to the stack
+              std::vector<EntityHandle> sib_cids(nfpc);
+              error = mb->tag_get_data(sibhfs_cid, &cur_cid, 1, &sib_cids[0]);
+              if (MB_SUCCESS != error) return error;
+
+              // Add new cells into the stack
+              EntityHandle ngb;
+              for (int i = 0; i < nhf_thisv; ++i){
+                  int ind = lConnMap3D[index].v2hf[lv][i];
+                  ngb = sib_cids[ind];
+
+                  if (ngb) {
+                      bool found_ent = find_match_in_array(ngb, trackcells, count);
+
+                      if (!found_ent){
+                          Stksize += 1;
+                          Stkcells[Stksize] = ngb;
+                      }
+                  }
+              }
+              // Add the current cell
+              //adjents.push_back(cur_cid);
+          }
+      }
+
+      return MB_SUCCESS;
+  }
 
  //////////////////////////////////////////////////////////////////////////////////////////////
   ErrorCode HalfFacetRep::get_up_adjacencies_edg_3d( EntityHandle eid,
@@ -2126,23 +2334,23 @@ namespace moab {
             error = mb->get_connectivity(&cur_cid, 1, conn);
             if (MB_SUCCESS != error) return error;
 
-	    // Local id of fid_verts[0] in the cell
-	    int lv0;
-	    for (int i = 0; i< nvpc; ++i){
-		if (conn[i] == fid_verts[0])
-		  {
-		    lv0 = i;
-		  }
+            // Local id of fid_verts[0] in the cell
+            int lv0;
+            for (int i = 0; i< nvpc; ++i){
+                if (conn[i] == fid_verts[0])
+                {
+                    lv0 = i;
+                }
 	      };
 
-	    int nhf_thisv = lConnMap3D[index].v2hf_num[lv0];
+            int nhf_thisv = lConnMap3D[index].v2hf_num[lv0];
 
             // Search each half-face to match input face
             for(int i = 0; i < nhf_thisv; ++i){
                 int lfid = lConnMap3D[index].v2hf[lv0][i];
                 int nv_curF = lConnMap3D[index].hf2v_num[lfid];
                 if (nv_curF != nvF)
-                  continue;
+                    continue;
 
                 // Connectivity of the current half-face
 
@@ -2150,7 +2358,7 @@ namespace moab {
                 for(int l = 0; l < nvF; ++l){
                     int ind = lConnMap3D[index].hf2v[lfid][l];
                     vthisface[l] = conn[ind];
-                  };
+                };
 
 
                 // Match this half-face with input fid
@@ -2163,32 +2371,32 @@ namespace moab {
                     lid[0] = lfid;
 
                     break;
-                  }
-              }
+                }
+            }
 
-	    // Add other cells that are incident on fid_verts[0]
-	    std::vector<EntityHandle> sib_cids(nfpc);
-	    error = mb->tag_get_data(sibhfs_cid, &cur_cid, 1, &sib_cids[0]);
-	    if (MB_SUCCESS != error) return error;
+            // Add other cells that are incident on fid_verts[0]
+            std::vector<EntityHandle> sib_cids(nfpc);
+            error = mb->tag_get_data(sibhfs_cid, &cur_cid, 1, &sib_cids[0]);
+            if (MB_SUCCESS != error) return error;
 
-	    // Add new cells into the stack
-	    EntityHandle ngb;
-	    for (int i = 0; i < nhf_thisv; ++i){
-		int ind = lConnMap3D[index].v2hf[lv0][i];
-		ngb = sib_cids[ind];
+            // Add new cells into the stack
+            EntityHandle ngb;
+            for (int i = 0; i < nhf_thisv; ++i){
+                int ind = lConnMap3D[index].v2hf[lv0][i];
+                ngb = sib_cids[ind];
 
-		if (ngb) {
+                if (ngb) {
 
-		    bool found_ent = find_match_in_array(ngb, trackcells, count);
+                    bool found_ent = find_match_in_array(ngb, trackcells, count);
 
-		    if (!found_ent){
-			Stksize += 1;
-			Stkcells[Stksize] = ngb;
-		      }
-		  }
-	      }
-	  }
-      }
+                    if (!found_ent){
+                        Stksize += 1;
+                        Stkcells[Stksize] = ngb;
+                    }
+                }
+            }
+        }
+    }
     return found;
   }
 

diff --git a/src/moab/Core.hpp b/src/moab/Core.hpp
index 20aafdc..d8b155e 100644
--- a/src/moab/Core.hpp
+++ b/src/moab/Core.hpp
@@ -315,30 +315,16 @@ public:
             get_adjacencies( from_entities, MB_1D_ENTITY, adjacencies ); 
             \endcode */
 
-  virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
+   virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
                                        const int num_entities,
                                        const int to_dimension,
                                        const bool create_if_missing,
                                        std::vector<EntityHandle>& adj_entities,
-                                       const int operation_type = Interface::INTERSECT
-    #ifdef USE_AHF
-      , const bool use_ahf = false);
-    #else
-      );
-    #endif
-
-
-  /*virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
-                                       const int num_entities,
-                                       const int to_dimension,
-                                       const bool create_if_missing,
-                                       std::vector<EntityHandle>& adj_entities,
-                                       const int operation_type = Interface::INTERSECT);*/
-
+                                       const int operation_type = Interface::INTERSECT);
 
 
 
-    virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
+   virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
                                         const int num_entities,
                                          const int to_dimension,
                                          const bool create_if_missing,
@@ -1375,6 +1361,7 @@ private:
 
 #ifdef USE_AHF
   HalfFacetRep *ahfRep;
+  bool mesh_modified;
 #endif
   
 };

diff --git a/src/moab/HalfFacetRep.hpp b/src/moab/HalfFacetRep.hpp
index 344dbd1..a228520 100755
--- a/src/moab/HalfFacetRep.hpp
+++ b/src/moab/HalfFacetRep.hpp
@@ -62,6 +62,8 @@ namespace moab {
     
     ~HalfFacetRep();
 
+    bool check_mixed_entity_type();
+
     // User interface functions
 
     //! Creates all the necessary tags to store the maps. Constructs the sibling-half-facet and vertex-to-incident-half-facet maps for each dimension present in the input.
@@ -177,8 +179,7 @@ namespace moab {
 
     ErrorCode determine_incident_halfedges(Range &faces);
 
-   /* ErrorCode get_up_adjacencies_2d(EntityHandle vid,
-                                       std::vector<EntityHandle> &adjents);*/
+    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
@@ -260,6 +261,9 @@ namespace moab {
     ErrorCode determine_border_vertices( Range &cells,
                                          Tag isborder);
 
+
+    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.
@@ -353,9 +357,20 @@ namespace moab {
     Tag sibhes_fid, sibhes_leid, v2he_fid, v2he_leid;
     Tag sibhfs_cid, sibhfs_lfid, v2hf_cid, v2hf_lfid;
 
-
+    MESHTYPE thismeshtype;
     MESHTYPE get_mesh_type(int nverts, int nedges, int nfaces, int ncells);
 
+    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();
@@ -364,6 +379,7 @@ namespace moab {
     ErrorCode deinit_surface();
     ErrorCode deinit_volume();
 
+
     //! Contains the local information for 2D entities
     /** Given a face, find the face type specific information
      * Parameters:

diff --git a/src/moab/Interface.hpp b/src/moab/Interface.hpp
index 57252e9..0b9e8e9 100644
--- a/src/moab/Interface.hpp
+++ b/src/moab/Interface.hpp
@@ -619,23 +619,13 @@ public:
             get_adjacencies( from_entities, 2, 1, false, adjacencies, Interface::INTERSECT); 
             \endcode 
     */
+
   virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
                                       const int num_entities,
                                       const int to_dimension,
                                       const bool create_if_missing,
                                       std::vector<EntityHandle>& adj_entities,
-                                      const int operation_type = Interface::INTERSECT
-    #ifdef USE_AHF
-      , const bool use_ahf = false) = 0;
-    #else
-      ) = 0;
-    #endif
-  /*virtual ErrorCode get_adjacencies(const EntityHandle *from_entities,
-                                      const int num_entities,
-                                      const int to_dimension,
-                                      const bool create_if_missing,
-                                      std::vector<EntityHandle>& adj_entities,
-                                      const int operation_type = Interface::INTERSECT) = 0; */
+                                      const int operation_type = Interface::INTERSECT) = 0;
 
     //! Get the adjacencies associated with a vector of entities to entities of a specfied dimension.
     /** Identical to vector-based get_adjacencies function, except results are returned in a

diff --git a/test/MBTest.cpp b/test/MBTest.cpp
index d70753f..a4f5d8a 100644
--- a/test/MBTest.cpp
+++ b/test/MBTest.cpp
@@ -6559,7 +6559,7 @@ ErrorCode mb_skin_verts_common( unsigned dim, bool skin_elems )
     std::cout << "Extra/non-returned elements created: " << extra << std::endl;
     return MB_FAILURE;
   }
-    
+
     // check that each skin vertex has the correct number of adjacent quads
   missing.clear(); extra.clear();
   for (Range::iterator i = expected.begin(); i != expected.end(); ++i) {

diff --git a/test/Makefile.am b/test/Makefile.am
index 1354e3c..33ca518 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -61,9 +61,9 @@ if HDF5_FILE
         lloyd_smoother_test
 endif
 
-# if ENABLE_ahf
-#  TESTS += ahf_mbintf_test
-# endif
+if ENABLE_ahf
+  TESTS += ahf_mbintf_test
+endif
 
 #                 merge_test \         # input files no longer exist?
 #                 test_tag_server \    # fails
@@ -158,9 +158,9 @@ lloyd_smoother_test_SOURCES = lloyd_smoother_test.cpp
 
 ahf_test_SOURCES = test_ahf_moab.cpp
 
-# if ENABLE_ahf
-# ahf_mbintf_test_SOURCES = test_ahf_mb_interface.cpp
-# endif
+if ENABLE_ahf
+ ahf_mbintf_test_SOURCES = test_ahf_mb_interface.cpp
+endif
 
 
 if PARALLEL

diff --git a/test/test_ahf_mb_interface.cpp b/test/test_ahf_mb_interface.cpp
index 9bf76ef..3d8257f 100755
--- a/test/test_ahf_mb_interface.cpp
+++ b/test/test_ahf_mb_interface.cpp
@@ -41,7 +41,7 @@ void ahf_mbintf_test()
   //IQ1: For every vertex, obtain incident edges
   for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
     adjents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents, Interface::INTERSECT, true);
+    error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies( &*i, 1, 1, false, mbents );
@@ -58,7 +58,7 @@ void ahf_mbintf_test()
   //NQ1:  For every edge, obtain neighbor edges
   for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
     adjents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents, Interface::INTERSECT, true);
+    error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mtu.get_bridge_adjacencies( *i, 0, 1, mbents);
@@ -76,7 +76,7 @@ void ahf_mbintf_test()
   //IQ2: For every edge, obtain incident faces
   for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
     adjents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents, Interface::INTERSECT, true);
+    error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies( &*i, 1, 2, false, mbents);
@@ -93,7 +93,7 @@ void ahf_mbintf_test()
   //NQ2: For every face, obtain neighbor faces
   for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
     adjents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents, Interface::INTERSECT, true);
+    error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mtu.get_bridge_adjacencies( *i, 1, 2, mbents);
@@ -111,7 +111,7 @@ void ahf_mbintf_test()
   // IQ 31: For every edge, obtain incident cells
   for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
     adjents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents, Interface::INTERSECT, true);
+    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
@@ -128,7 +128,7 @@ void ahf_mbintf_test()
   //IQ32: For every face, obtain incident cells
   for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
     adjents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents, Interface::INTERSECT, true);
+    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
@@ -145,7 +145,7 @@ void ahf_mbintf_test()
   //NQ3: For every cell, obtain neighbor cells
   for (Range::iterator i = cells.begin(); i != cells.end(); ++i) {
     adjents.clear();
-    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents, Interface::INTERSECT, true);
+    error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents);
     CHECK_ERR(error);
     mbents.clear();
     error = mtu.get_bridge_adjacencies( *i, 2, 3, mbents);

diff --git a/test/test_ahf_moab.cpp b/test/test_ahf_moab.cpp
index e415186..a9185ae 100755
--- a/test/test_ahf_moab.cpp
+++ b/test/test_ahf_moab.cpp
@@ -97,7 +97,25 @@ ErrorCode ahf_test(Core *moab)
     }
 
     // 2D Queries
-    //IQ2: For every edge, obtain incident faces
+
+    // IQ21: For every vertex, obtain incident faces
+    for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_up_adjacencies( *i, 2, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mbImpl->get_adjacencies( &*i, 1, 2, false, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    //IQ22: For every edge, obtain incident faces
     for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
         adjents.clear();
         error = ahf.get_up_adjacencies( *i, 2, adjents);
@@ -132,7 +150,24 @@ ErrorCode ahf_test(Core *moab)
     }
 
     // 3D Queries
-    // IQ 31: For every edge, obtain incident cells
+    //IQ 31: For every vertex, obtain incident cells
+    for (Range::iterator i = verts.begin(); i != verts.end(); ++i) {
+        adjents.clear();
+        error = ahf.get_up_adjacencies( *i, 3, adjents);
+        CHECK_ERR(error);
+        mbents.clear();
+        error = mbImpl->get_adjacencies(&*i, 1, 3, false, mbents);
+        CHECK_ERR(error);
+
+        CHECK_EQUAL(adjents.size(), mbents.size());
+
+        std::sort(adjents.begin(), adjents.end());
+        std::copy(adjents.begin(), adjents.end(), range_inserter(ahfents));
+        mbents = subtract(mbents, ahfents);
+        CHECK(!mbents.size());
+    }
+
+    // IQ 32: For every edge, obtain incident cells
     for (Range::iterator i = edges.begin(); i != edges.end(); ++i) {
         adjents.clear();
         error = ahf.get_up_adjacencies( *i, 3, adjents);
@@ -149,7 +184,7 @@ ErrorCode ahf_test(Core *moab)
         CHECK(!mbents.size());
     }
 
-    //IQ32: For every face, obtain incident cells
+    //IQ33: For every face, obtain incident cells
     for (Range::iterator i = faces.begin(); i != faces.end(); ++i) {
         adjents.clear();
         error = ahf.get_up_adjacencies( *i, 3, adjents);

Repository URL: https://bitbucket.org/fathomteam/moab/

--

This is a commit notification from bitbucket.org. You are receiving
this because you have the service enabled, addressing the recipient of
this email.


More information about the moab-dev mailing list