fix: sync fault topo calculator with the data manager. Use the same layers and update the adjacency graph

lachlangrose · lachlangrose · commit 76aef5782797 · 2026-01-26T17:39:54.000+10:30
diff --git a/loopstructural/gui/map2loop_tools/fault_topology_widget.py b/loopstructural/gui/map2loop_tools/fault_topology_widget.py
@@ -4,38 +4,14 @@
 
 import geopandas as gpd
 from PyQt5.QtWidgets import QDialog, QMessageBox
-from qgis.PyQt import uic
 from qgis.core import QgsMapLayerProxyModel
+from qgis.PyQt import uic
 
 
 class FaultTopologyWidget(QDialog):
-    def _guess_fault_layer_and_field(self):
-        """Attempt to auto-select the fault layer and ID field based on common names."""
-        try:
-            from ...main.helpers import ColumnMatcher, get_layer_names
-        except ImportError:
-            return
-        # Guess fault layer
-        fault_layer_names = get_layer_names(self.faultLayerComboBox)
-        fault_matcher = ColumnMatcher(fault_layer_names)
-        fault_layer_match = fault_matcher.find_match('FAULTS')
-        if fault_layer_match and hasattr(self, 'data_manager') and self.data_manager:
-            fault_layer = self.data_manager.find_layer_by_name(fault_layer_match)
-            self.faultLayerComboBox.setLayer(fault_layer)
-        # Guess ID field
-        layer = self.faultLayerComboBox.currentLayer()
-        if layer:
-            fields = [field.name() for field in layer.fields()]
-            matcher = ColumnMatcher(fields)
-            for key in ["ID", "NAME", "FNAME", "id", "name", "fname"]:
-                match = matcher.find_match(key)
-                if match:
-                    self.faultIdFieldComboBox.setField(match)
-                    break
-
     """Widget for calculating fault topology from a fault layer."""
 
-    def __init__(self, parent=None, data_manager=None):
+    def __init__(self, parent=None, data_manager=None, debug_manager=None):
         super().__init__(parent)
         self.data_manager = data_manager
         # Load the UI file
@@ -45,8 +21,16 @@ def __init__(self, parent=None, data_manager=None):
 
         self.faultLayerComboBox.setFilters(QgsMapLayerProxyModel.LineLayer)
         self.faultLayerComboBox.layerChanged.connect(self._on_fault_layer_changed)
+        # react to field changes so we can update the modelling widget via the data manager
+        try:
+            # QgsFieldComboBox uses fieldChanged signal
+            self.faultIdFieldComboBox.fieldChanged.connect(self._on_fault_field_changed)
+        except Exception:
+            pass
+
         self.runButton.clicked.connect(self._run_topology)
-        self._guess_fault_layer_and_field()
+        # After attempting to guess, synchronise with current data manager state (if any)
+        self._sync_with_data_manager()
 
     def _on_fault_layer_changed(self):
         layer = self.faultLayerComboBox.currentLayer()
@@ -58,6 +42,71 @@ def _on_fault_layer_changed(self):
                 if name in fields:
                     self.faultIdFieldComboBox.setField(name)
                     break
+        # Inform the data manager / modelling widgets about the change and preserve other settings
+        self._update_data_manager_fault_layer()
+
+    def _on_fault_field_changed(self):
+        # When the selected ID field changes, update the data manager so the modelling widget updates
+        self._update_data_manager_fault_layer()
+
+    def _sync_with_data_manager(self):
+        """Set the widget UI to reflect the current fault traces selection in the data manager."""
+        if not hasattr(self, 'data_manager') or self.data_manager is None:
+            print("No data manager to sync with")
+            return
+        try:
+            fault_traces = self.data_manager.get_fault_traces()
+        except Exception:
+            fault_traces = None
+        if not fault_traces:
+            return
+        layer = fault_traces.get('layer')
+        print(f"Syncing fault topology widget with layer: {layer}")
+        if layer is not None:
+            try:
+                self.faultLayerComboBox.setLayer(layer)
+            except Exception:
+                pass
+        # set the name field if available
+        fault_name_field = fault_traces.get('fault_name_field')
+        if fault_name_field and layer is not None:
+            try:
+                self.faultIdFieldComboBox.setLayer(layer)
+                self.faultIdFieldComboBox.setField(fault_name_field)
+            except Exception:
+                pass
+
+    def _update_data_manager_fault_layer(self):
+        """Update the ModellingDataManager with the layer/field chosen in this widget.
+
+        Preserve any other fault settings already present in the data manager (dip, displacement, use_z).
+        """
+        if not hasattr(self, 'data_manager') or self.data_manager is None:
+            return
+        # Gather current selections from this widget
+        layer = self.faultLayerComboBox.currentLayer()
+        name_field = None
+        try:
+            name_field = self.faultIdFieldComboBox.currentField()
+        except Exception:
+            name_field = None
+        # Preserve existing settings from data manager if present
+        existing = self.data_manager.get_fault_traces() or {}
+        fault_dip_field = existing.get('fault_dip_field')
+        fault_displacement_field = existing.get('fault_displacement_field')
+        use_z_coordinate = existing.get('use_z_coordinate', False)
+        # Call data manager to set the fault trace layer which will notify the modelling UI
+        try:
+            self.data_manager.set_fault_trace_layer(
+                layer,
+                fault_name_field=name_field,
+                fault_dip_field=fault_dip_field,
+                fault_displacement_field=fault_displacement_field,
+                use_z_coordinate=use_z_coordinate,
+            )
+        except Exception:
+            # Fail silently to avoid breaking UI if data_manager is not fully initialised
+            return
 
     def _run_topology(self):
         layer = self.faultLayerComboBox.currentLayer()
@@ -84,10 +133,97 @@ def _run_topology(self):
             return
         topology = Topology(geology_data=None, fault_data=gdf)
         df = topology.fault_fault_relationships
-        # if self.data_manager is not None:
-        #     self.data_manager.
-        # Show or add to project
-        # addGeoDataFrameToproject(gdf, "Input Faults")
-        # addGeoDataFrameToproject(df, "Fault Topology Table")
-        QMessageBox.information(self, "Success", f"Calculated fault topology for {len(df)} pairs.")
+
+        # Update the modelling FaultTopology (so the Fault Adjacency tab refreshes)
+        if hasattr(self, 'data_manager') and self.data_manager is not None:
+            try:
+                from LoopStructural.modelling.core.fault_topology import FaultRelationshipType
+
+                ft = self.data_manager._fault_topology
+
+                # Remove existing fault-fault relationships (notify observers)
+                for f1, f2 in list(ft.adjacency.keys()):
+                    try:
+                        ft.update_fault_relationship(f1, f2, FaultRelationshipType.NONE)
+                    except Exception:
+                        pass
+
+                # Remove existing stratigraphy relationships
+                for unit, fault in list(ft.stratigraphy_fault_relationships.keys()):
+                    try:
+                        ft.update_fault_stratigraphy_relationship(unit, fault, False)
+                    except Exception:
+                        pass
+
+                # Determine faults from topology output
+                new_faults = set()
+                if df is not None and not df.empty:
+                    # Prefer standard column names
+                    if 'Fault1' in df.columns and 'Fault2' in df.columns:
+                        for _, row in df.iterrows():
+                            print(f"Found fault pair: {row['Fault1']} - {row['Fault2']}")
+                            new_faults.add(str(row['Fault1']))
+                            new_faults.add(str(row['Fault2']))
+                    else:
+                        # Fallback: take first two columns
+                        cols = list(df.columns)
+                        if len(cols) >= 2:
+                            for _, row in df.iterrows():
+                                new_faults.add(str(row[cols[0]]))
+                                new_faults.add(str(row[cols[1]]))
+
+                # Add new faults
+                for f in sorted(new_faults):
+                    if f not in ft.faults:
+                        try:
+                            ft.add_fault(f)
+                        except Exception:
+                            pass
+
+                # Remove faults not in new set
+                for existing in list(ft.faults):
+                    if existing not in new_faults:
+                        try:
+                            ft.remove_fault(existing)
+                        except Exception:
+                            pass
+
+                # Add relationships from df (mark as FAULTED)
+                if df is not None and not df.empty:
+                    for _, row in df.iterrows():
+                        try:
+                            if 'Fault1' in row.index and 'Fault2' in row.index:
+                                f1 = str(row['Fault1'])
+                                f2 = str(row['Fault2'])
+                            else:
+                                f1 = str(row.iloc[0])
+                                f2 = str(row.iloc[1])
+                            ft.update_fault_relationship(f1, f2, FaultRelationshipType.FAULTED)
+                        except Exception:
+                            pass
+
+                # Update unit-fault relationships if available from topology
+                try:
+                    uf = topology.unit_fault_relationships
+                    if uf is not None and not uf.empty:
+                        for _, r in uf.iterrows():
+                            try:
+                                unit = r.get('Unit', r.iloc[0])
+                                fault = r.get('Fault', r.iloc[1])
+                                ft.update_fault_stratigraphy_relationship(unit, str(fault), True)
+                            except Exception:
+                                pass
+                except Exception:
+                    # unit-fault relationships not available
+                    pass
+
+            except Exception:
+                # If anything fails here, still continue to show success of topology run
+                pass
+
+        QMessageBox.information(
+            self,
+            "Success",
+            f"Calculated fault topology for {len(df) if df is not None else 0} pairs.",
+        )
         return True
diff --git a/loopstructural/gui/modelling/fault_adjacency_tab.py b/loopstructural/gui/modelling/fault_adjacency_tab.py
@@ -61,15 +61,27 @@ def init_ui(self):
         self.data_manager._stratigraphic_column.attach(self.update)
         self.data_manager._fault_topology.attach(self.update)
 
-    def _update(self, event, *args, **kwargs):
-        if (
-            args[0] == "fault_relationship_updated"
-            or args[0] == "stratigraphy_fault_relationship_updated"
-        ):
-            return
-
-        self.update_fault_adjacency_table()
-        self.update_stratigraphic_units_table()
+    def _update(self, observable, event, *args, **kwargs):
+        """Observer callback invoked by Observable.notify.
+
+        Parameters follow the Observable.notify signature: (observable, event, *args, **kwargs)
+        Always refresh the tables when a topology or stratigraphy event occurs.
+        """
+        # event is a string describing what changed
+        try:
+            ev = event
+        except Exception:
+            # defensive: if call used different ordering, try to recover
+            ev = None
+
+        # Refresh the UI for any relevant event
+        if ev is None or ev.startswith('fault') or 'stratigraphy' in (ev or ''):
+            self.update_fault_adjacency_table()
+            self.update_stratigraphic_units_table()
+        else:
+            # fallback: update anyway to keep UI in sync
+            self.update_fault_adjacency_table()
+            self.update_stratigraphic_units_table()
 
     def change_button_color(self, button, row, col):
         """Cycle the button color and update the fault relationship."""
diff --git a/loopstructural/main/data_manager.py b/loopstructural/main/data_manager.py
@@ -2,10 +2,10 @@
 from collections import defaultdict
 
 import numpy as np
-from LoopStructural.datatypes import BoundingBox
 from qgis.core import QgsPointXY, QgsProject, QgsVectorLayer
 
 from LoopStructural import FaultTopology, StratigraphicColumn
+from LoopStructural.datatypes import BoundingBox
 from LoopStructural.modelling.core.stratigraphic_column import StratigraphicColumnElementType
 
 from .vectorLayerWrapper import qgsLayerToGeoDataFrame
@@ -299,7 +299,10 @@ def get_unique_faults(self):
         """Get the unique faults from the fault traces."""
         if self._fault_traces is None or self._fault_traces['layer'] is None:
             return []
+        if self._fault_traces['fault_name_field'] is None:
+            return []
         unique_faults = set()
+
         for feature in self._fault_traces['layer'].getFeatures():
             fault_name = feature[self._fault_traces['fault_name_field']]
             unique_faults.add(str(fault_name))
