Merge lp:~morandini/dolfin/facet-connections into lp:~fenics-core/dolfin/trunk

[Marco Morandini]

proposed fix for Bug 928342

[Garth Wells (garth-wells)]

review: Approve

=== modified file 'dolfin/mesh/MeshDistributed.cpp'
--- dolfin/mesh/MeshDistributed.cpp	2012-03-01 12:01:06 +0000
+++ dolfin/mesh/MeshDistributed.cpp	2012-05-17 14:50:21 +0000
@@ -77,19 +77,40 @@
   // FIXME: work on optimising below code
 
   // List of indices to send
-  std::vector<uint> my_entities = entity_indices;
+  std::vector<uint> my_entities;
 
   // Remove local cells from my_entities to reduce communication
   if (dim == D)
   {
-    std::vector<uint>::iterator it;
-    for (uint i = 0; i < global_entity_indices.size(); ++i)
-    {
-      const uint global_index = global_entity_indices[i];
-      it = std::find(my_entities.begin(), my_entities.end(), global_index);
-      if (it != my_entities.end())
-        my_entities.erase(it);
-    }
+    // In order to fill vector my_entities...
+    // build and populate a local set for non-local cells
+    std::set<uint> set_of_my_entities;
+    for (uint j = 0; j < entity_indices.size(); j++) {
+      set_of_my_entities.insert(entity_indices[j]);
+    }
+
+    // Remove local cells from set_of_my_entities to reduce communication
+    std::set<uint>::iterator it;
+    for (uint j = 0; j < global_entity_indices.size(); ++j)
+    {
+      const uint global_index = global_entity_indices[j];
+      it = set_of_my_entities.find(global_index);
+      if (it != set_of_my_entities.end()) {
+        set_of_my_entities.erase(it);
+      }
+    }
+ 
+    //copy entries from set_of_my_entities to my_entities
+    my_entities.resize(set_of_my_entities.size());
+    {
+      uint j = 0;
+      for (std::set<uint>::iterator it = set_of_my_entities.begin(); it != set_of_my_entities.end(); it++) {
+        my_entities[j] = *it;
+        j++;
+      }
+    }
+  } else {
+    my_entities = entity_indices;
   }
 
   // FIXME: handle case when my_entities.empty()
@@ -114,17 +135,25 @@
     // Check if this process owns received entities, and if so
     // store local index
     std::vector<uint> my_hosted_entities;
-    for (uint j = 0; j < recv_entity_count; ++j)
     {
-      // Check if this process hosts 'received_entity'
-      const uint received_entity = off_process_entities[j];
-      std::vector<uint>::const_iterator it;
-      it = std::find(global_entity_indices.begin(), global_entity_indices.end(), received_entity);
-      if (it != global_entity_indices.end())
-      {
-        const uint local_index = std::distance(global_entity_indices.begin(), it);
-        my_hosted_entities.push_back(received_entity);
-        my_hosted_entities.push_back(local_index);
+      // Build a temporary map hosting global_entity_indices
+      std::map<uint, uint> map_of_global_entity_indices;
+      for (uint j = 0; j < global_entity_indices.size(); j++) 
+      {
+        map_of_global_entity_indices[global_entity_indices[j]] = j;
+      }
+      for (uint j = 0; j < recv_entity_count; j++)
+      {
+        // Check if this process hosts 'received_entity'
+        const uint received_entity = off_process_entities[j];
+        std::map<uint, uint>::const_iterator it;
+        it = map_of_global_entity_indices.find(received_entity);
+        if (it != map_of_global_entity_indices.end())
+        {
+          const uint local_index = it->second;
+          my_hosted_entities.push_back(received_entity);
+          my_hosted_entities.push_back(local_index);
+        }
       }
     }
 

=== modified file 'dolfin/mesh/MeshPartitioning.h'
--- dolfin/mesh/MeshPartitioning.h	2011-11-18 12:14:50 +0000
+++ dolfin/mesh/MeshPartitioning.h	2012-05-17 14:50:21 +0000
@@ -216,14 +216,20 @@
     // Add local (to this process) data to domain marker
     std::vector<uint>::iterator it;
     std::vector<uint> off_process_global_cell_entities;
+    // Build and populate a local map for global_entity_indices
+    std::map<uint, uint> map_of_global_entity_indices;
+    for (uint i = 0; i < global_entity_indices.size(); i++) {
+      map_of_global_entity_indices[global_entity_indices[i]] = i;
+    }
+
     for (uint i = 0; i < ldata.size(); ++i)
     {
       const uint global_cell_index = ldata[i].first.first;
-      std::vector<uint>::const_iterator it;
-      it = std::find(global_entity_indices.begin(), global_entity_indices.end(), global_cell_index);
-      if (it != global_entity_indices.end())
+      std::map<uint, uint>::const_iterator it;
+      it = map_of_global_entity_indices.find(global_cell_index);
+      if (it != map_of_global_entity_indices.end())
       {
-        const uint local_cell_index = std::distance(global_entity_indices.begin(), it);
+        const uint local_cell_index = it->second;
         const uint entity_local_index = ldata[i].first.second;
         const T value = ldata[i].second;
         markers.set_value(local_cell_index, entity_local_index, value);
@@ -242,34 +248,40 @@
     std::vector<uint> destinations0;
     std::vector<uint> destinations1;
     std::map<uint, std::set<std::pair<uint, uint> > >::const_iterator entity_host;
-    for (entity_host = entity_hosts.begin(); entity_host != entity_hosts.end(); ++entity_host)
+    
     {
-      const uint host_global_cell_index = entity_host->first;
-      const std::set<std::pair<uint, uint> >& processes_data = entity_host->second;
-
-      // Loop over local data
-      for (uint i = 0; i < ldata.size(); ++i)
+      // Build a convenience map in order to speedup the loop over local data
+      std::map<uint, std::set<uint> > map_of_ldata;
+      for (uint i = 0; i < ldata.size(); ++i) {
+        map_of_ldata[ldata[i].first.first].insert(i);
+      }
+      for (entity_host = entity_hosts.begin(); entity_host != entity_hosts.end(); ++entity_host)
       {
-        const uint local_global_cell_index = ldata[i].first.first;
-        if (local_global_cell_index == host_global_cell_index)
-        {
-          const uint local_entity_index = ldata[i].first.second;
-          const T domain_value = ldata[i].second;
-
-          std::set<std::pair<uint, uint> >::const_iterator process_data;
-          for (process_data = processes_data.begin(); process_data != processes_data.end(); ++process_data)
-          {
-            const uint proc = process_data->first;
-            const uint local_cell_entity = process_data->second;
-
-            send_data0.push_back(local_cell_entity);
-            send_data0.push_back(local_entity_index);
-            destinations0.insert(destinations0.end(), 2, proc);
-
-            send_data1.push_back(domain_value);
-            destinations1.push_back(proc);
+        const uint host_global_cell_index = entity_host->first;
+        const std::set<std::pair<uint, uint> >& processes_data = entity_host->second;
+
+        // Loop over local data
+        std::map<uint, std::set<uint> >::const_iterator ldata_it = map_of_ldata.find(host_global_cell_index);
+        if (ldata_it != map_of_ldata.end()) {
+          for (std::set<uint>::const_iterator it = ldata_it->second.begin(); it != ldata_it->second.end(); it++) {
+            const uint local_entity_index = ldata[*it].first.second;
+            const T domain_value = ldata[*it].second;
+          
+            std::set<std::pair<uint, uint> >::const_iterator process_data;
+            for (process_data = processes_data.begin(); process_data != processes_data.end(); ++process_data)
+            {
+              const uint proc = process_data->first;
+              const uint local_cell_entity = process_data->second;
+
+              send_data0.push_back(local_cell_entity);
+              send_data0.push_back(local_entity_index);
+              destinations0.insert(destinations0.end(), 2, proc);
+
+              send_data1.push_back(domain_value);
+              destinations1.push_back(proc);
+            }
           }
-        }
+	}
       }
     }