allow broadcast multiple oppsed signs

network_process/src/post_topo/patch_propagation.cpp

@@ -14,11 +14,12 @@ std::vector<dynamic_bitset<>> propagate_subface_labels(size_t
     // in turn: [subface_index][cell_index] = sign
     std::vector<dynamic_bitset<>> cell_subface_signs(subface_count, dynamic_bitset<>(arrangement_cells.size()));
 
-    std::vector<bool>                                  visited_cells(arrangement_cells.size(), false);
+    std::vector<bool>                  visited_cells(arrangement_cells.size(), false);
-    std::vector<bool>                                  visited_subfaces(subface_count, false);
+    std::vector<bool>                  visited_subfaces(subface_count, false);
-    std::vector<std::vector<uint32_t>>                 cell_indices_of_inactive_subfaces(subface_count);
+    std::vector<std::vector<uint32_t>> cell_indices_of_inactive_subfaces(subface_count);
-    std::queue<uint32_t>                               Q{};
+    std::queue<uint32_t>               Q{};
-    flat_hash_map<uint32_t, std::pair<uint32_t, bool>> cell_neighbors_map{};
+    dynamic_bitset<>                   opposed_cells(arrangement_cells.size());
+    std::vector<uint32_t>              unique_opposed_cells{};
 
     Q.emplace(0);
     while (!Q.empty()) {
@@ -28,7 +29,8 @@ std::vector<dynamic_bitset<>> propagate_subface_labels(size_t
 
         if (!visited_cells[cell_index]) {
             visited_cells[cell_index] = true;
-            cell_neighbors_map.clear();
+            opposed_cells.reset();
+            unique_opposed_cells.clear();
 
             for (auto shell : cell) {
                 for (auto half_patch : shells[shell]) {
@@ -42,7 +44,18 @@ std::vector<dynamic_bitset<>> propagate_subface_labels(size_t
                     auto oppose_cell   = shell_to_cell[shell_of_half_patch[sign ? (half_patch + 1) : (half_patch - 1)]];
                     // bool sign          = (half_patch % 2 == 0) ? 0 : 1;
                     // auto oppose_cell   = shell_to_cell[shell_of_half_patch[!sign ? (half_patch + 1) : (half_patch - 1)]];
-                    cell_neighbors_map[oppose_cell] = std::make_pair(subface_label, sign);
+
+                    // sign broadcast
+                    if (oppose_cell != cell_index) {
+                        if (!opposed_cells[oppose_cell]) {
+                            for (uint32_t si = 0; si < subface_count; ++si)
+                                cell_subface_signs[si][oppose_cell] = cell_subface_signs[si][cell_index];
+                            opposed_cells[oppose_cell] = true;
+                            unique_opposed_cells.emplace_back(oppose_cell);
+                            if (!visited_cells[oppose_cell]) Q.emplace(oppose_cell);
+                        }
+                        cell_subface_signs[subface_label][oppose_cell] = !sign;
+                    }
 
 #ifndef RELEASE_BRANCH
                     if (visited_subfaces[subface_label] != false && cell_subface_signs[subface_label][cell_index] != sign) {
@@ -66,24 +79,11 @@ std::vector<dynamic_bitset<>> propagate_subface_labels(size_t
             for (uint32_t subface_index = 0; subface_index < subface_count; subface_index++) {
                 if (visited_subfaces[subface_index] == false) {
                     cell_indices_of_inactive_subfaces[subface_index].emplace_back(cell_index);
-                    for (const auto& [other_cell_index, _] : cell_neighbors_map) {
+                    for (const auto& other_cell_index : unique_opposed_cells) {
                         cell_indices_of_inactive_subfaces[subface_index].emplace_back(other_cell_index);
                     }
                 }
             }
-
-            // propagate to neighboring cells
-            for (const auto& [other_cell_index, other_cell_func_label] : cell_neighbors_map) {
-                if (!visited_cells[other_cell_index]) Q.emplace(other_cell_index);
-
-                const auto& [func_index, sign] = other_cell_func_label;
-                for (uint32_t subface_index = 0; subface_index < func_index; ++subface_index)
-                    cell_subface_signs[subface_index][other_cell_index] = cell_subface_signs[subface_index][cell_index];
-                // opposite cell has opposite sign on same patch
-                cell_subface_signs[func_index][other_cell_index] = !sign;
-                for (uint32_t subface_index = func_index + 1; subface_index < subface_count; ++subface_index)
-                    cell_subface_signs[subface_index][other_cell_index] = cell_subface_signs[subface_index][cell_index];
-            }
         }
     }