fix: ✨ faults/fault builder now store the fault geometry parameters

LoopStructural/modelling/fault/fault_builder.py

@@ -48,6 +48,13 @@ def __init__(
         ] + fault_bounding_box_buffer * (
             self.model.bounding_box[1, :] - self.model.bounding_box[0, :]
         )
+        self.fault_normal_vector = None
+        self.fault_slip_vector = None
+        self.fault_strike_vector = None
+        self.fault_minor_axis = None
+        self.fault_major_axis = None
+        self.fault_intermediate_axis = None
+        self.fault_centre = None
 
     def update_geometry(self, points):
         self.origin = np.nanmin(np.array([np.min(points, axis=0), self.origin]), axis=0)
@@ -95,6 +102,12 @@ def create_data_from_geometry(
         intermediate_axis : double
             fault volume radius in the slip direction
         """
+        self.fault_normal_vector = normal_vector
+        self.fault_slip_vector = slip_vector
+        self.fault_minor_axis = minor_axis
+        self.fault_major_axis = major_axis
+        self.fault_intermediate_axis = intermediate_axis
+        self.fault_centre = fault_center
         if major_axis is None:
             fault_trace = data.loc[
                 np.logical_and(data["coord"] == 0, data["val"] == 0), ["X", "Y"]
@@ -125,6 +138,8 @@ def create_data_from_geometry(
         #     logger.info("{} : projecting slip vector onto fault plane".format(self.name))
         #     slip_vector = np.cross(normal_vector, np.cross(slip_vector ,normal_vector))
         strike_vector = np.cross(normal_vector, slip_vector)
+        self.fault_strike_vector = strike_vector
+
         fault_edges = np.zeros((2, 3))
         fault_tips = np.zeros((2, 3))
         fault_depth = np.zeros((2, 3))
@@ -160,7 +175,7 @@ def create_data_from_geometry(
                         0,
                         w,
                     ]
-                    logger.warning("Converting fault norm data to gradient data")
+                    logger.info("Converting fault norm data to gradient data")
                     mask = np.logical_and(data["coord"] == 0, ~np.isnan(data["nx"]))
                     data.loc[mask, ["gx", "gy", "gz"]] = data.loc[
                         mask, ["nx", "ny", "nz"]

LoopStructural/modelling/fault/fault_segment.py

@@ -54,6 +54,48 @@ def __init__(
         self.splay = {}
         self.abut = {}
 
+    @property
+    def fault_normal_vector(self):
+        if self.builder == None:
+            raise ValueError("Fault builder not set")
+        return self.builder.fault_normal_vector
+
+    @property
+    def fault_slip_vector(self):
+        if self.builder == None:
+            raise ValueError("Fault builder not set")
+        return self.builder.fault_slip_vector
+
+    @property
+    def fault_strike_vector(self):
+        if self.builder == None:
+            raise ValueError("Fault builder not set")
+        return self.builder.fault_strike_vector
+
+    @property
+    def fault_minor_axis(self):
+        if self.builder == None:
+            raise ValueError("Fault builder not set")
+        return self.builder.fault_minor_axis
+
+    @property
+    def fault_major_axis(self):
+        if self.builder == None:
+            raise ValueError("Fault builder not set")
+        return self.builder.fault_major_axis
+
+    @property
+    def fault_intermediate_axis(self):
+        if self.builder == None:
+            raise ValueError("Fault builder not set")
+        return self.builder.fault_intermediate_axis
+
+    @property
+    def fault_centre(self):
+        if self.builder == None:
+            raise ValueError("Fault builder not set")
+        return self.builder.fault_centre
+
     def __str__(self):
         _str = "FaultSegment - {} \n".format(self.name)
         _str += "Interpolator: {} \n".format(self.faultframe[0].interpolator.type)
@@ -381,17 +423,20 @@ def add_abutting_fault(self, abutting_fault_feature, positive=None):
             )  # get_value_constraints()
             abut_value = np.nanmedian(abutting_fault_feature.evaluate_value(pts))
             positive = abut_value > 0
+        # we want to crop the fault by the abutting fault so create a positive/neg region and include the fault centre and normal vector to help
+        # outside of the fault interpolation support
+
         if positive:
-            abutting_region = PositiveRegion(abutting_fault_feature)
+            abutting_region = PositiveRegion(
+                abutting_fault_feature,
+                vector=abutting_fault_feature.fault_normal_vector,
+                point=abutting_fault_feature.fault_centre,
+            )
         if positive == False:
-            abutting_region = NegativeRegion(abutting_fault_feature)
-            # if positive == True:
-            #      ## adding the nan check avoids truncating the fault at the edge of the abutting fault bounding box.
-            #         ## it makes the assumption that the abutted fault is not drawn across the abutting fault... but this should be ok
-            #     return np.logical_or(abutting_fault_feature.evaluate_value(pos) > 0,
-            #                             np.isnan(abutting_fault_feature.evaluate_value(pos)))
-            # if positive == False:
-            #     return np.logical_or(abutting_fault_feature.evaluate_value(pos) < 0,
-            #                             np.isnan(abutting_fault_feature.evaluate_value(pos)))
+            abutting_region = NegativeRegion(
+                abutting_fault_feature,
+                vector=abutting_fault_feature.fault_normal_vector,
+                point=abutting_fault_feature.fault_centre,
+            )
         self.abut[abutting_fault_feature.name] = abutting_region
         self.faultframe[0].add_region(abutting_region)