feat: add fault-domain-boundary (#112)

* test: pin training-value/isovalue direction agreement for stratigraphic columns

Guards against the swap fixed in 814be12: model_manager.py's per-unit
training value and LoopStructural's get_isovalues() must agree on
which direction values increase, or extracted isosurfaces get labelled
with the wrong unit while keeping correct geometry.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat: allow a fault to act as a stratigraphic domain boundary

Lets a stratigraphic-column unconformity be linked to an existing fault
instead of a flat isovalue surface, so the fault's own (non-displacing)
geometry splits the model into two domains -- built via LoopStructural's
create_and_add_domain_fault, reusing the same trace data already ingested
for the fault.

- Stratigraphic column UI gains a "fault" boundary type with a fault
  picker; faults used this way are excluded from the fault topology's
  FAULTED/ABUTTING and fault-stratigraphy tables, since those assume a
  displacement-modelled fault.
- The fault's trace is automatically extended to the model's bounding box
  edges along its own trend, and given synthetic strike/dip orientation
  constraints, so the interpolated surface spans and properly varies
  across the whole domain rather than only being reliable near the
  digitised trace.
- A domain-boundary fault is skipped by the ordinary displacement-fault
  build loop, and any region a later unconformity incorrectly attaches to
  it is stripped after each build (defensive; the root cause is fixed
  upstream in LoopStructural core separately).
- Fixes a project-load ordering bug where the model CRS was restored
  after the layers that get reprojected against it, silently skipping
  reprojection for any layer already in the project's own CRS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix: correct stratigraphic value assignment and domain-fault boundary follow-ups

Several fixes to make domain-fault-bounded stratigraphic columns build and
display correctly:

- update_foliation_features now trains each unit's basal-contact data at
  its own max() (the boundary with the next-older unit, i.e. its true
  base) instead of min() (the boundary with the next-younger unit, i.e.
  its top). Basal contacts represent a unit's base, so training at min()
  anchored every unit's own data to the wrong boundary -- confirmed on a
  live project where units evaluated into their next-younger neighbour's
  bracket instead of their own, and a basement unit with no contact data
  of its own never appeared in the model at all.
- Unit thickness now accumulates unconditionally while building that
  training data, so an undigitised placeholder unit no longer shifts
  every later unit's value by its own thickness.
- Use each fault trace point's own local tangent (rather than one global
  best-fit line) when extending a domain-boundary fault to the model's
  bounding box and deriving its orientation constraints, so a curved
  trace doesn't get flattened into the wrong extrapolation.
- Recompute stratigraphic unit value ranges after restoring a column from
  a saved project (both initial load and reload), matching what a fresh
  column already gets -- otherwise every restored unit kept the default
  (0, inf) range and couldn't be told apart from its neighbours.
- Show the generic details panel for a domain-fault feature instead of an
  empty widget.
- Skip an isosurface with no geometry when adding stratigraphic surfaces
  to the 3D viewer instead of crashing, since an undigitised unit can
  legitimately have no constrained geometry anywhere in the model.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix: increase thickness spin box limit + nelements spin box. BUmp default nelements to 50k

* fix: value should be the basal value of a unit

* style: fix black formatting and ruff lint (unnecessary generator)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix: training values no longer disagree with get_isovalues() direction

update_foliation_features re-reversed group.units, which get_groups()
already returns in the order get_isovalues() walks, so every basal
contact was trained with the wrong scalar value.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>

Author: lachlangrose

loopstructural/gui/dlg_settings.ui

@@ -274,7 +274,11 @@
        </widget>
       </item>
       <item row="3" column="1">
-       <widget class="QSpinBox" name="n_elements_spin_box"/>
+       <widget class="QSpinBox" name="n_elements_spin_box">
+        <property name="maximum">
+         <number>1000000</number>
+        </property>
+       </widget>
       </item>
      </layout>
     </widget>

loopstructural/gui/modelling/fault_adjacency_tab.py

@@ -80,7 +80,7 @@ def _update(self, observable, event, *args, **kwargs):
             self.update_fault_adjacency_table()
             self.update_stratigraphic_units_table()
 
-    def change_button_color(self, button, row, col):
+    def change_button_color(self, button, fault1, fault2):
         """Cycle the button color and update the fault relationship."""
         current_color = button.styleSheet()
         if "red" in current_color:
@@ -94,15 +94,23 @@ def change_button_color(self, button, row, col):
             relationship = FaultRelationshipType.ABUTTING
 
         button.setStyleSheet(f"background-color: {new_color};")
-        f1 = self.data_manager._fault_topology.faults[row]
-        f2 = self.data_manager._fault_topology.faults[col]
-        self.data_manager._fault_topology.update_fault_relationship(f1, f2, relationship)
+        self.data_manager._fault_topology.update_fault_relationship(fault1, fault2, relationship)
+
+    def _displacement_fault_names(self):
+        """Fault names to show in these tables, excluding faults used as
+        stratigraphic-column domain boundaries (see `set_fault_boundary`).
+        Those are non-displacing splits, not faults that cut/abut other
+        faults or offset stratigraphic units, so FAULTED/ABUTTING and
+        fault-stratigraphy relationships don't apply to them.
+        """
+        domain_boundary_faults = self.data_manager.get_fault_boundary_fault_names()
+        return [
+            f for f in self.data_manager._fault_topology.faults if f not in domain_boundary_faults
+        ]
 
     def update_fault_adjacency_table(self):
         """Update the fault adjacency table with QPushButtons."""
-        faults = (
-            self.data_manager._fault_topology.faults
-        )  # Assuming faults is a list of fault names
+        faults = self._displacement_fault_names()
         if not faults:
             self.fault_table_group.hide()
             return
@@ -145,15 +153,15 @@ def update_fault_adjacency_table(self):
                     else:
                         button.setStyleSheet("background-color: white;")
                     button.clicked.connect(
-                        lambda _, b=button, r=row, c=col: self.change_button_color(b, r, c)
+                        lambda _, b=button, f1=faults[row], f2=faults[
+                            col
+                        ]: self.change_button_color(b, f1, f2)
                     )
                     self.table.setCellWidget(row, col, button)
 
     def update_stratigraphic_units_table(self):
         """Update the stratigraphic units table with QPushButtons."""
-        faults = (
-            self.data_manager._fault_topology.faults
-        )  # Assuming faults is a list of fault names
+        faults = self._displacement_fault_names()
         group_units_pairs = self.data_manager._stratigraphic_column.get_group_unit_pairs()
 
         if not faults or not group_units_pairs:
@@ -185,11 +193,13 @@ def update_stratigraphic_units_table(self):
                     # Default to white if no relationship or not faulted
                     button.setStyleSheet("background-color: white;")
                 button.clicked.connect(
-                    lambda _, b=button, r=row, c=col: self.change_button_colour_binary(b, r, c)
+                    lambda _, b=button, u=units[row], f=faults[
+                        col
+                    ]: self.change_button_colour_binary(b, u, f)
                 )
                 self.stratigraphic_table.setCellWidget(row, col, button)
 
-    def change_button_colour_binary(self, button, row, col):
+    def change_button_colour_binary(self, button, unit_name, fault_name):
         """Cycle the button color between red, green, and black."""
 
         current_color = button.styleSheet()
@@ -199,8 +209,6 @@ def change_button_colour_binary(self, button, row, col):
         else:
             button.setStyleSheet("background-color: red;")
             flag = True
-        fault = self.data_manager._fault_topology.faults[col]
-        unit = self.data_manager._stratigraphic_column.get_group_unit_pairs()[row]
         self.data_manager._fault_topology.update_fault_stratigraphy_relationship(
-            unit[1], fault, flag
+            unit_name, fault_name, flag
         )

loopstructural/gui/modelling/geological_model_tab/geological_model_tab.py

@@ -20,6 +20,7 @@
 from .add_foliation_dialog import AddFoliationDialog
 from .add_unconformity_dialog import AddUnconformityDialog
 from .feature_details_panel import (
+    BaseFeatureDetailsPanel,
     FaultFeatureDetailsPanel,
     FoldedFeatureDetailsPanel,
     FoliationFeatureDetailsPanel,
@@ -461,6 +462,17 @@ def on_feature_selected(self, item):
             self.featureDetailsPanel = FoldedFeatureDetailsPanel(
                 feature=feature, model_manager=self.model_manager, data_manager=self.data_manager
             )
+        elif feature.type == FeatureType.DOMAINFAULT:
+            # A domain fault is built by the same GeologicalFeatureBuilder
+            # as a foliation (see create_and_add_domain_fault), just with a
+            # different .type tag -- the generic base panel (interpolator
+            # settings, data layers, export/evaluate) already applies to it
+            # unchanged. Skip FoliationFeatureDetailsPanel's fold-frame
+            # attachment controls, which don't make sense for a domain
+            # boundary.
+            self.featureDetailsPanel = BaseFeatureDetailsPanel(
+                feature=feature, model_manager=self.model_manager, data_manager=self.data_manager
+            )
         else:
             self.featureDetailsPanel = QWidget()  # Default empty panel
 

loopstructural/gui/modelling/stratigraphic_column/stratigraphic_column.py

@@ -232,7 +232,11 @@ def update_display(self):
                         widget, _ = self._widget_cache[unit.uuid]
                         # Update widget data without rebuilding
                         if hasattr(widget, 'setData'):
-                            widget.setData(unit.to_dict())
+                            unit_data = unit.to_dict()
+                            if isinstance(widget, UnconformityWidget):
+                                unit_data = self._enrich_unconformity_data(unit_data)
+                                widget.set_available_faults(self._get_available_fault_names())
+                            widget.setData(unit_data)
                 return
 
             # If order/content differs, do a full rebuild
@@ -263,7 +267,31 @@ def _full_rebuild_display(self, current_order):
             if unit.element_type == StratigraphicColumnElementType.UNIT:
                 self.add_unit(unit_data=unit.to_dict(), create_new=False)
             elif unit.element_type == StratigraphicColumnElementType.UNCONFORMITY:
-                self.add_unconformity(unconformity_data=unit.to_dict(), create_new=False)
+                self.add_unconformity(
+                    unconformity_data=self._enrich_unconformity_data(unit.to_dict()),
+                    create_new=False,
+                )
+
+    def _enrich_unconformity_data(self, unconformity_data):
+        """Merge in the plugin-side fault-boundary link for an unconformity row.
+
+        `StratigraphicUnconformity.to_dict()` (core) only knows `erode`/
+        `onlap`; the fault link is tracked separately in the data manager
+        (see `ModellingDataManager.set_fault_boundary`), so it has to be
+        folded in here for display.
+        """
+        fault_name = self.data_manager.get_fault_boundary(unconformity_data.get('uuid'))
+        if fault_name:
+            unconformity_data = dict(unconformity_data)
+            unconformity_data['unconformity_type'] = 'fault'
+            unconformity_data['fault_name'] = fault_name
+        return unconformity_data
+
+    def _get_available_fault_names(self):
+        """Fault names offered when marking an unconformity as a domain boundary."""
+        if not self.data_manager:
+            return []
+        return list(self.data_manager._fault_topology.faults)
 
     def init_stratigraphic_column_from_basal_contacts(self):
         if self.data_manager:
@@ -482,11 +510,13 @@ def add_unconformity(self, *, unconformity_data=None, create_new=True):
             widget, _ = self._widget_cache[unconformity.uuid]
             # Just update the data, don't recreate the widget
             if hasattr(widget, 'setData'):
+                widget.set_available_faults(self._get_available_fault_names())
                 widget.setData(unconformity_data)
             return
 
         unconformity_widget = UnconformityWidget(uuid=unconformity.uuid)
         unconformity_widget.deleteRequested.connect(self.delete_unit)
+        unconformity_widget.dataChanged.connect(lambda: self.update_element(unconformity_widget))
         unconformity_widget.dragHandlePressed.connect(
             lambda: self._on_drag_start(unconformity_widget)
         )
@@ -500,6 +530,8 @@ def add_unconformity(self, *, unconformity_data=None, create_new=True):
         item.setSizeHint(unconformity_widget.sizeHint())
         self.unitList.addItem(item)
         self.unitList.setItemWidget(item, unconformity_widget)
+        unconformity_widget.set_available_faults(self._get_available_fault_names())
+        unconformity_widget.setData(unconformity_data)
 
         # Cache the widget for efficient updates
         self._widget_cache[unconformity.uuid] = (unconformity_widget, item)
@@ -605,6 +637,30 @@ def update_element(self, unit_widget):
         """
         if self.data_manager:
             unit_data = unit_widget.getData()
+            if isinstance(unit_widget, UnconformityWidget):
+                fault_name = unit_data.pop('fault_name', None)
+                is_fault_boundary = unit_data.get('unconformity_type') == 'fault'
+                if is_fault_boundary:
+                    # The core stratigraphic column only knows erode/onlap --
+                    # the fault link lives in the data manager's side table
+                    # (see set_fault_boundary), so store it as a plain
+                    # erosional boundary here.
+                    unit_data['unconformity_type'] = 'erode'
+                if is_fault_boundary and fault_name:
+                    self.data_manager.set_fault_boundary(unit_widget.uuid, fault_name)
+                    if not self.data_manager.fault_spans_model_domain(fault_name):
+                        QMessageBox.information(
+                            self,
+                            "Fault Domain Boundary",
+                            f"Fault '{fault_name}' does not reach every edge of the model "
+                            "bounding box.\n\nA fault used as a domain boundary crops the "
+                            "whole model, so its digitised trace will automatically be "
+                            "extended out to the domain edges along its overall trend when "
+                            "the model is built. For best results the trace should still "
+                            "roughly follow the fault's real direction across the gap.",
+                        )
+                else:
+                    self.data_manager.clear_fault_boundary(unit_widget.uuid)
             self.data_manager._stratigraphic_column.update_element(unit_data)
             # Trigger callback to notify all listeners of the change
             if self.data_manager.stratigraphic_column_callback:

loopstructural/gui/modelling/stratigraphic_column/stratigraphic_unit.ui

@@ -80,7 +80,7 @@
       <double>0.000000000000000</double>
      </property>
      <property name="maximum">
-      <double>10000.000000000000000</double>
+      <double>100000000.000000000000000</double>
      </property>
     </widget>
    </item>

loopstructural/gui/modelling/stratigraphic_column/unconformity.py

@@ -10,6 +10,7 @@
 
 class UnconformityWidget(QWidget):
     deleteRequested = pyqtSignal(QWidget)  # Signal to request deletion
+    dataChanged = pyqtSignal()  # Type or fault-name changed
     dragHandlePressed = pyqtSignal()  # Drag handle mouse-down
     dragHandleMoved = pyqtSignal(QPoint)  # Drag handle mouse-move (global pos)
     dragHandleReleased = pyqtSignal()  # Drag handle mouse-up
@@ -25,9 +26,9 @@ def __init__(
         self.buttonDelete.clicked.connect(self.request_delete)
         self.uuid = uuid
         self.unconformity_type = 'erode'
-        # self.comboBoxUnconformityType.currentIndexChanged.connect(
-        #     lambda: setattr(self, 'unconformity_type', self.comboBoxUnconformityType.currentText())
-        # )
+        self.fault_name = None
+        self.comboBoxUnconformityType.currentIndexChanged.connect(self._on_type_changed)
+        self.comboBoxFaultName.currentIndexChanged.connect(self._on_fault_name_changed)
         # The row's combo box/buttons cover the whole widget, so a QListWidget's
         # built-in drag-and-drop can never see a mouse press to start a
         # reorder. Route presses on the dedicated grip label through here instead.
@@ -55,21 +56,73 @@ def request_delete(self):
 
         self.deleteRequested.emit(self)
 
+    def _on_type_changed(self, _index):
+        self.unconformity_type = self.comboBoxUnconformityType.currentText()
+        self.comboBoxFaultName.setVisible(self.unconformity_type == 'fault')
+        if self.unconformity_type == 'fault':
+            self.fault_name = self.comboBoxFaultName.currentText() or None
+        else:
+            self.fault_name = None
+        self.dataChanged.emit()
+
+    def _on_fault_name_changed(self, _index):
+        if self.unconformity_type != 'fault':
+            return
+        self.fault_name = self.comboBoxFaultName.currentText() or None
+        self.dataChanged.emit()
+
+    def set_available_faults(self, fault_names):
+        """Populate the fault-name picker, keeping the current selection if
+        it is still available (e.g. after the fault trace layer changes).
+        """
+        fault_names = list(fault_names or [])
+        if [
+            self.comboBoxFaultName.itemText(i) for i in range(self.comboBoxFaultName.count())
+        ] == fault_names:
+            return
+        self.comboBoxFaultName.blockSignals(True)
+        try:
+            self.comboBoxFaultName.clear()
+            self.comboBoxFaultName.addItems(fault_names)
+            if self.fault_name and self.fault_name in fault_names:
+                self.comboBoxFaultName.setCurrentText(self.fault_name)
+        finally:
+            self.comboBoxFaultName.blockSignals(False)
+
     def setData(self, data: Optional[dict] = None):
         """Set the data for the unconformity widget.
 
         Parameters
         ----------
         data : dict or None
-            Dictionary containing 'unconformity_type' key. If None, defaults are used.
+            Dictionary with an 'unconformity_type' key ('erode', 'onlap' or
+            'fault'), and a 'fault_name' key when the type is 'fault'. If
+            None, defaults are used.
         """
-        if data:
-            self.unconformity_type = data.get("unconformity_type", "")
-            # self.unconformityTypeComboBox.setCurrentIndex(
-            #     self.unconformityTypeComboBox.findText(self.unconformity_type)
-            # )
-        else:
-            self.unconformity_type = 'erode'
-            # self.unconformityTypeComboBox.setCurrentIndex(
-            #     self.unconformityTypeComboBox.findText(self.unconformity_type)
-            # )
+        self.unconformity_type = (data or {}).get("unconformity_type", "erode")
+        self.fault_name = (
+            (data or {}).get("fault_name") if self.unconformity_type == 'fault' else None
+        )
+
+        self.comboBoxUnconformityType.blockSignals(True)
+        self.comboBoxFaultName.blockSignals(True)
+        try:
+            index = self.comboBoxUnconformityType.findText(self.unconformity_type)
+            if index >= 0:
+                self.comboBoxUnconformityType.setCurrentIndex(index)
+            self.comboBoxFaultName.setVisible(self.unconformity_type == 'fault')
+            if self.fault_name:
+                self.comboBoxFaultName.setCurrentText(self.fault_name)
+        finally:
+            self.comboBoxUnconformityType.blockSignals(False)
+            self.comboBoxFaultName.blockSignals(False)
+
+    def getData(self):
+        """Return this row's data for the data manager: uuid, unconformity_type
+        and (when the boundary is fault-linked) fault_name.
+        """
+        return {
+            'uuid': self.uuid,
+            'unconformity_type': self.unconformity_type,
+            'fault_name': self.fault_name,
+        }

loopstructural/gui/modelling/stratigraphic_column/unconformity.ui

@@ -61,6 +61,11 @@
        <string>onlap</string>
       </property>
      </item>
+     <item>
+      <property name="text">
+       <string>fault</string>
+      </property>
+     </item>
     </widget>
    </item>
    <item row="0" column="1">
@@ -70,6 +75,16 @@
      </property>
     </widget>
    </item>
+   <item row="1" column="1" colspan="2">
+    <widget class="QComboBox" name="comboBoxFaultName">
+     <property name="toolTip">
+      <string>Fault whose surface realises this boundary as a domain split</string>
+     </property>
+     <property name="visible">
+      <bool>false</bool>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <resources/>

loopstructural/gui/visualisation/feature_list_widget.py

@@ -456,8 +456,18 @@ def add_stratigraphic_surfaces(self):
         stratigraphic_surfaces = self.model_manager.model.get_stratigraphic_surfaces()
 
         for surface in stratigraphic_surfaces:
+            mesh = surface.vtk()
+            if mesh.n_points == 0:
+                # A unit with no digitised data of its own (e.g. an
+                # undigitised placeholder like "Top") can have no
+                # constrained geometry anywhere in the model, so its
+                # isovalue may not intersect the solved field at all --
+                # pyvista refuses to plot an empty mesh, so skip it rather
+                # than crashing every surface after it in this loop.
+                logger.info(f"Skipping '{surface.name}': isosurface has no geometry.")
+                continue
             self.viewer.add_mesh_object(
-                surface.vtk(),
+                mesh,
                 name=surface.name,
                 color=surface.colour,
                 source_feature=surface.name,