Merge branch 'dev' of https://github.com/Loop3D/LoopStructural into dev

Author: lachlangrose

LoopStructural/modelling/core/geological_model.py

@@ -140,7 +140,7 @@ def __init__(self, origin, maximum, rescale=True, nsteps=(40, 40, 40),
         self.bounding_box[1, :] = self.maximum - self.origin
         self.bounding_box[1, :] = self.maximum - self.origin
         if rescale:
-            self.scale_factor = np.max(lengths,dtype=float)
+            self.scale_factor = float(np.max(lengths))
             logger.info('Rescaling model using scale factor {}'.format(self.scale_factor))
         self._str+='Model rescale factor: {} \n'.format(self.scale_factor)
         self._str+='The model contains {} GeologicalFeatures \n'.format(len(self.features))
@@ -1141,25 +1141,30 @@ def create_and_add_fault(self,
         mask = np.logical_and(fault_frame_data['coord']==1,~np.isnan(fault_frame_data['gz']))
         if fault_slip_vector is None:
             fault_slip_vector = fault_frame_data.loc[mask,['gx','gy','gz']].mean(axis=0).to_numpy()
+        if fault_center is not None:
+            fault_center = self.scale(fault_center,inplace=False)
         if fault_center is None:
             # if we haven't defined a fault centre take the center of mass for lines assocaited with
             # the fault trace
             mask = np.logical_and(fault_frame_data['coord']==0,fault_frame_data['val']==0)
             fault_center = fault_frame_data.loc[mask,['X','Y','Z']].mean(axis=0).to_numpy()
-        if influence_distance:
-            influence_distance=fault_influence/self.scale_factor
-        if horizontal_radius:
-            horizontal_radius=fault_extent/self.scale_factor
-        if vertical_radius:
-            vertical_radius=fault_vectical_radius/self.scale_factor    
+        if fault_influence:
+            fault_influence=fault_influence/self.scale_factor
+        if fault_extent:
+            fault_extent=fault_extent/self.scale_factor
+        if fault_vectical_radius:
+            fault_vectical_radius=fault_vectical_radius/self.scale_factor
         fault_frame_builder.create_data_from_geometry(fault_frame_data,
-                                                      self.scale(fault_center),
+                                                      fault_center,
                                                       fault_normal_vector,
                                                       fault_slip_vector,
                                                       influence_distance=fault_influence,
                                                       horizontal_radius=fault_extent,
                                                       vertical_radius=fault_vectical_radius
                                                       )
+        if fault_influence == None or fault_extent == None or fault_vectical_radius == None:
+            fault_frame_builder.origin = self.origin
+            fault_frame_builder.maximum = self.maximum
         fault_frame_builder.set_mesh_geometry(kwargs.get('fault_buffer',0.1))
         # fault_frame_builder.add_data_from_data_frame(fault_frame_data)
         # check if this fault overprint any existing faults exist in the stack

LoopStructural/modelling/fault/fault_builder.py

@@ -51,6 +51,8 @@ def create_data_from_geometry(self,
         vertical_radius : double
             fault volume radius in the slip direction
         """
+        normal_vector/=np.linalg.norm(normal_vector)
+        slip_vector/=np.linalg.norm(slip_vector)
         strike_vector = np.cross(normal_vector,slip_vector)
         fault_edges = np.zeros((2,3))
         fault_tips = np.zeros((2,3))

LoopStructural/modelling/features/geological_feature.py

@@ -120,6 +120,9 @@ def evaluate_value(self, evaluation_points):
             numpy array containing evaluated values
 
         """
+        #TODO need to add a generic type checker for all methods
+        #if evaluation_points is not a numpy array try and convert
+        #otherwise error
         self.builder.up_to_date()
         # check if the points are within the display region
         v = np.zeros(evaluation_points.shape[0])

LoopStructural/modelling/features/structural_frame.py

@@ -107,10 +107,7 @@ def evaluate_value(self, evaluation_points):
         v[:,1] = self.features[1].evaluate_value(evaluation_points)
         v[:,2] = self.features[2].evaluate_value(evaluation_points)
         return v
-        # return (self.features[0].evaluate_value(evaluation_points),
-        #         self.features[1].evaluate_value(evaluation_points),
-        #         self.features[2].evaluate_value(evaluation_points))
-
+        
     def evaluate_gradient(self, evaluation_points, i=None):
         """
         Evaluate the gradient of the structural frame.

LoopStructural/utils/map2loop.py

@@ -317,7 +317,7 @@ def build_model(m2l_data, skip_faults = False, unconformities=False, fault_param
             faults.append(model.create_and_add_fault(f,
                                                     -m2l_data['max_displacement'][f],
                                                     faultfunction='BaseFault',
-                                                    fault_slip_vector=np.array([0,0,-1]),
+                                                    fault_slip_vector=np.array([0.,0.,-1.]),
                                                     fault_center=fault_center,
                                                     fault_extent=fault_extent,
                                                     fault_influence=fault_influence,

LoopStructural/visualisation/model_visualisation.py

@@ -492,7 +492,18 @@ def add_fault_displacements(self, cmap = 'rainbow', **kwargs):
         vmin = kwargs.get('vmin', np.nanmin(vals))
         vmax = kwargs.get('vmax', np.nanmax(vals))
         surf.colourmap(cmap, range=(vmin, vmax))
-
+        
+    def add_fault_ellipse(self, faults=None, **kwargs):
+        from matplotlib.patches import Ellipse
+        for k, f in self.model.stratigraphic_column['faults'].items():
+            center = self.model.rescale(f['FaultCenter'])
+            e = Ellipse((center[0],center[1]),
+                            f['HorizontalRadius']*2,
+                            f['InfluenceDistance']*2,
+                            360-f['FaultDipDirection'],
+                                facecolor='None',edgecolor='k')
+
+        self.ax.add_patch(e)
     def add_model_surfaces(self, faults = True, cmap=None, fault_colour='black',**kwargs):
         """Add surfaces for all of the interfaces in the model