[BUG] Refactor left_right_codes propagation in dual contouring pipeline

Streamlined handling of `left_right_codes` across functions and classes, updating method signatures and data structures for consistency. Removed unused `left_right_codes` parameters in parallel processing functions and restructured relevant logic to improve maintainability.

Author: Leguark

gempy_engine/API/dual_contouring/multi_scalar_dual_contouring.py

@@ -125,6 +125,7 @@ def dual_contouring_multi_scalar(
                             else octree_leaves.grid_centers.octree_grid.values[mask]
                     ),
                     dxdydz=octree_leaves.grid_centers.octree_dxdydz,
+                    left_right_codes=all_left_right_codes[n_scalar_field],
                     gradients=output_on_edges[n_scalar_field][slice_object],
                     n_surfaces_to_export=n_scalar_field,
                     tree_depth=options.number_octree_levels
@@ -135,7 +136,6 @@ def dual_contouring_multi_scalar(
         from gempy_engine.modules.dual_contouring._dual_contouring_v2 import compute_dual_contouring_v2
         all_meshes = compute_dual_contouring_v2(
             dc_data_list=dc_data_per_surface_all,
-            left_right_codes=all_left_right_codes[0],
         )
     # endregion
     if (options.debug or len(all_left_right_codes) > 1) and False:
@@ -168,7 +168,7 @@ def _compute_meshes_legacy(all_left_right_codes: list[Any], all_mask_arrays: np.
 
     meshes: List[DualContouringMesh] = compute_dual_contouring(
         dc_data_per_stack=dc_data,
-        left_right_codes=all_left_right_codes[0],
+        left_right_codes=all_left_right_codes[n_scalar_field],
         debug=options.debug
     )
 

gempy_engine/core/data/dual_contouring_data.py

@@ -12,11 +12,11 @@ class DualContouringData:
     dxdydz: np.ndarray | tuple[float, float, float]
 
     n_surfaces_to_export: int
+    left_right_codes: np.ndarray
     gradients: np.ndarray = None
 
     tree_depth: int = -1
     # Water tight 
-    mask: np.ndarray = None
 
     bias_center_mass: np.ndarray = None  # * Only for testing
     bias_normals: np.ndarray = None  # * Only for testing

gempy_engine/modules/dual_contouring/_dual_contouring_v2.py

@@ -22,9 +22,8 @@
 
 
 @gempy_profiler_decorator
-def compute_dual_contouring_v2(dc_data_list: list[DualContouringData],
-                            left_right_codes=None) -> List[DualContouringMesh]:
-    parallel_results = _parallel_process(dc_data_list, left_right_codes)
+def compute_dual_contouring_v2(dc_data_list: list[DualContouringData], ) -> List[DualContouringMesh]:
+    parallel_results = _parallel_process(dc_data_list)
 
     if parallel_results is not None:
         return parallel_results
@@ -35,25 +34,25 @@ def compute_dual_contouring_v2(dc_data_list: list[DualContouringData],
     stack_meshes: List[DualContouringMesh] = []
 
     for dc_data in dc_data_list:
-        mesh = _process_one_surface(dc_data, left_right_codes)
+        mesh = _process_one_surface(dc_data, dc_data.left_right_codes)
         stack_meshes.append(mesh)
     return stack_meshes
 
 
-def _parallel_process(dc_data_list: list[DualContouringData], left_right_codes):
+def _parallel_process(dc_data_list: list[DualContouringData]):
     # Check if we should use parallel processing
     n_surfaces_to_export = len(dc_data_list)
     use_parallel = _should_use_parallel_processing(n_surfaces_to_export, BackendTensor.engine_backend)
     parallel_results = None
 
     if use_parallel and False:  # ! (Miguel Sep 25) I do not see a speedup
         print(f"Using parallel processing for {n_surfaces_to_export} surfaces")
-        parallel_results = _parallel_process_surfaces_v2(dc_data_list, left_right_codes)
+        parallel_results = _parallel_process_surfaces_v2(dc_data_list)
 
     return parallel_results
 
 
-def _parallel_process_surfaces_v2(dc_data_list: list[DualContouringData], left_right_codes, num_workers=None, chunk_size=2):
+def _parallel_process_surfaces_v2(dc_data_list: list[DualContouringData], num_workers=None, chunk_size=2):
     """Process surfaces in parallel using multiprocessing."""
     n_surfaces = len(dc_data_list)
 
@@ -70,6 +69,7 @@ def _parallel_process_surfaces_v2(dc_data_list: list[DualContouringData], left_r
                 'xyz_on_centers'      : dc_data.xyz_on_centers,
                 'dxdydz'              : dc_data.dxdydz,
                 'gradients'           : dc_data.gradients,
+                'left_right_codes'    : dc_data.left_right_codes,
                 'n_surfaces_to_export': dc_data.n_surfaces_to_export,
                 'tree_depth'          : dc_data.tree_depth
         }
@@ -89,7 +89,7 @@ def _parallel_process_surfaces_v2(dc_data_list: list[DualContouringData], left_r
             for chunk in chunks:
                 result = pool.apply_async(
                     _process_surface_batch_v2,
-                    (chunk, dc_data_dicts, left_right_codes)
+                    (chunk, dc_data_dicts )
                 )
                 async_results.append(result)
 
@@ -120,11 +120,12 @@ def _process_surface_batch_v2(surface_indices, dc_data_dicts, left_right_codes):
             xyz_on_centers=dc_data_dict['xyz_on_centers'],
             dxdydz=dc_data_dict['dxdydz'],
             gradients=dc_data_dict['gradients'],
+            left_right_codes=dc_data_dict['left_right_codes'],
             n_surfaces_to_export=dc_data_dict['n_surfaces_to_export'],
             tree_depth=dc_data_dict['tree_depth']
         )
         # Process the surface
-        mesh = _process_one_surface(dc_data, left_right_codes)
+        mesh = _process_one_surface(dc_data, dc_data.left_right_codes)
         results.append(mesh)
 
     return results