fix: code cleaning

FernsAlvanevs · FernsAlvanevs · commit 72b94e1119d7 · 2022-02-10T13:24:12.000+11:00
diff --git a/LoopStructural/modelling/intrusions/geom_conceptual_models.py b/LoopStructural/modelling/intrusions/geom_conceptual_models.py
@@ -19,12 +19,10 @@ def ellipse_function(
 
     a = (maxP - minP) / 2
     b = (maxS - minS) / 10
-    #     b = abs(minS)
 
     po = minP + (maxP - minP) / 2
 
     p_locations = lateral_contact_data.loc[:, "coord1"].copy().to_numpy()
-    #     s_values = lateral_contact_data.loc[:,'coord2'].copy().to_numpy()
 
     s = np.zeros([len(p_locations), 2])
     
diff --git a/LoopStructural/modelling/intrusions/intrusion_body.py b/LoopStructural/modelling/intrusions/intrusion_body.py
@@ -4,7 +4,8 @@
 from LoopStructural.utils import getLogger
 
 logger = getLogger(__name__)
-# GSLIB library
+
+# import GSLIB library
 try:
     import geostatspy.GSLIB as GSLIB  # GSLIB utilities, viz and wrapped functions
     import geostatspy.geostats as geostats  # GSLIB converted to Python
@@ -655,21 +656,8 @@ def simulate_s_thresholds(self):
             simulation_s_thresholds.coord1 > maxP,["min_s_threshold", "max_s_threshold"]
             ] = [0.00001, 0.00001]
 
-
-        # for j in range(len(simulation_s_thresholds)):
-        #     if simulation_s_thresholds.loc[j, "coord1"] < minP:
-        #         simulation_s_thresholds.loc[
-        #             j, ["min_s_threshold", "max_s_threshold"]
-        #         ] = [0.00001, 0.00001]
-        #     if simulation_s_thresholds.loc[j, "coord1"] > maxP:
-        #         simulation_s_thresholds.loc[
-        #             j, ["min_s_threshold", "max_s_threshold"]
-        #         ] = [0.00001, 0.00001]
-
         self.simulated_s_thresholds = simulation_s_thresholds
 
-    #         return simulation_s_thresholds
-
     def simulate_g_thresholds(self):
         """
         Simulate g residual values and compute g thresholds for each point of a pre-defined grid.
@@ -741,11 +729,11 @@ def simulate_g_thresholds(self):
         if self.simulation_g_parameters.get("nx") == None:
             self.simulation_g_parameters["nx"] = grid_points[4][
                 0
-            ]  # *2 # grid X spacing
+            ]  
         if self.simulation_g_parameters.get("ny") == None:
             self.simulation_g_parameters["ny"] = grid_points[4][
                 1
-            ]  # *2 # grid Y spacing
+            ]  
         if self.simulation_g_parameters.get("xmn") == None:
             self.simulation_g_parameters["xmn"] = np.nanmin(grid_points_coord1)
         if self.simulation_g_parameters.get("ymn") == None:
@@ -926,7 +914,4 @@ def simulate_g_thresholds(self):
         g_maximum = conceptual_maxg[:, 1] - g_residual[:, 5]
         simulation_g_threshold.loc[:, "g_maximum"] = g_maximum
 
-        self.simulated_g_thresholds = simulation_g_threshold
-
-
-#         return simulation_g_threshold
+        self.simulated_g_thresholds = simulation_g_threshold
diff --git a/LoopStructural/modelling/intrusions/intrusion_feature.py b/LoopStructural/modelling/intrusions/intrusion_feature.py
@@ -179,7 +179,6 @@ def evaluate_value(self, points):
         #         ------- intrusion_sf: final distance scalar field
         # Transform the scalar fields given by the frame coordinates, using the thresholds.
         # This aims to generate a scalar field with its isovalue = 0 on the intrusion contact
-        # print('modifying thresholds')
 
         a = intrusion_coord2_pts >= s_maxside_threshold
         b = intrusion_coord2_pts <= s_minside_threshold
@@ -228,149 +227,4 @@ def evaluate_value(self, points):
         ]
         self.intrusion_indicator_function = indicator_fx
     
-        return intrusion_sf  # , indicator_fx, intrusion_sf2_temp, intrusion_sf0_temp,
-
-    def evaluate_value2(self, points):
-
-        """
-        points : array (x,y,z),  points where the intrusion is evaluated.
-
-        """
-
-        simulation_g_data = self.simulation_growth_data
-        simulation_s_data = self.simulation_lateral_data
-        inet_polygon = None
-        intrusion_frame = self.structural_frame
-        model = self.model
-
-        # points = model.scale(points, inplace = False)
-
-        # ---> returns indicator function and scalar field with isovalue 0 = intrusion boundary
-
-        # compute coordinates values for each evaluated point
-        # intrusion_coord0_pts = intrusion_frame[0].evaluate_value(model.rescale(points, inplace = False))
-        # intrusion_coord1_pts = intrusion_frame[1].evaluate_value(model.rescale(points, inplace = False))
-        # intrusion_coord2_pts = intrusion_frame[2].evaluate_value(model.rescale(points, inplace = False))
-        intrusion_coord0_pts = intrusion_frame[0].evaluate_value(points)
-        intrusion_coord1_pts = intrusion_frame[1].evaluate_value(points)
-        intrusion_coord2_pts = intrusion_frame[2].evaluate_value(points)
-        # ------ lateral extent thresholds for each of the evaluated points -------------
-        indicator_fx_intrusion = np.zeros([len(points)])
-
-        # if lateral extent values were simulated
-        if simulation_s_data is not None:
-
-            simulation_s_data.sort_values(["coord1"], ascending=[True], inplace=True)
-            s_minside_threshold = np.zeros(len(intrusion_coord1_pts))
-            s_maxside_threshold = np.zeros(len(intrusion_coord1_pts))
-
-            for i in range(len(simulation_s_data)):
-                for j in range(len(intrusion_coord0_pts)):
-                    if s_minside_threshold[j] == 0 and s_maxside_threshold[j] == 0:
-                        if (
-                            intrusion_coord1_pts[j]
-                            <= simulation_s_data.loc[i, "coord1"]
-                        ):
-                            s_minside_threshold[j] = simulation_s_data.loc[
-                                i, "min_s_threshold"
-                            ]
-                            s_maxside_threshold[j] = simulation_s_data.loc[
-                                i, "max_s_threshold"
-                            ]
-
-            # ---- indicator function to define area of intrusion - w/out considering growth threshold
-            min_inet_coord0 = simulation_g_data.loc[:, "g_minimum"].min()
-            for i in range(len(points)):
-                if indicator_fx_intrusion[i] == 0:
-                    if (
-                        intrusion_coord0_pts[i] >= min_inet_coord0
-                    ):  # >=0 #constaint for intrusion network
-                        if (
-                            s_minside_threshold[i]
-                            <= intrusion_coord2_pts[i]
-                            <= s_maxside_threshold[i]
-                        ):  # constraint for lateral extent
-                            indicator_fx_intrusion[i] = 1
-
-        # if lateral extent polygon is given
-        elif inet_polygon != None:
-            from shapely.geometry import Point, Polygon
-
-            for i in range(len(intrusion_coord1_pts)):
-                p = Point(intrusion_coord1_pts[i], intrusion_coord2_pts[i])
-                if (
-                    intrusion_coord0_pts[i] >= min_inet_coord0
-                ):  # >=0 #constaint for intrusion network
-                    if p.within(inet_polygon) == True:
-                        indicator_fx_intrusion[i] = 1
-
-        # ------ growth threshold (only computed for points indicator_fx_intrusion[i] == 1)
-        growth_threshold = np.zeros([len(intrusion_coord0_pts)])
-        inet_threshold = np.zeros([len(intrusion_coord0_pts)])
-        for i in range(len(points)):
-            if indicator_fx_intrusion[i] == 1:
-                for j in range(len(simulation_g_data)):
-                    if intrusion_coord1_pts[i] <= simulation_g_data.loc[j, "coord1"]:
-                        if (
-                            intrusion_coord2_pts[i]
-                            <= simulation_g_data.loc[j, "coord2"]
-                        ):
-                            growth_threshold[i] = simulation_g_data.loc[j, "g_maximum"]
-                            inet_threshold[i] = simulation_g_data.loc[j, "g_minimum"]
-                            break
-
-        # ------ Correct indicator function using growth threshold
-
-        for i in range(len(points)):
-            if indicator_fx_intrusion[i] == 1:
-                if (
-                    intrusion_coord0_pts[i] > growth_threshold[i]
-                    or intrusion_coord0_pts[i] < inet_threshold[i]
-                ):
-                    indicator_fx_intrusion[i] = 0
-
-        #         ------- intrusion_sf: final distance scalar field
-
-        # containers for distance scalar field of each coordinate
-        intrusion_sf0_temp = np.zeros(len(intrusion_coord0_pts))
-        intrusion_sf1_temp = np.zeros(len(intrusion_coord1_pts))
-        intrusion_sf2_temp = np.zeros(len(intrusion_coord2_pts))
-        intrusion_sf = np.zeros(len(points))
-
-        for i in range(len(points)):  # growth scalar field
-            if intrusion_coord0_pts[i] < 0:
-                intrusion_sf0_temp[i] = abs(intrusion_coord0_pts[i])
-            elif intrusion_coord0_pts[i] >= growth_threshold[i]:
-                intrusion_sf0_temp[i] = abs(
-                    intrusion_coord0_pts[i] - growth_threshold[i]
-                )
-            else:
-                intrusion_sf0_temp[i] = intrusion_coord0_pts[i] - growth_threshold[i]
-
-        # for i in range(len(points)): #strike scalar field
-        #     if intrusion_coord2_pts[i] >= s_maxside_threshold[i]:
-        #         intrusion_sf2_temp[i] = intrusion_coord2_pts[i] - s_maxside_threshold[i]
-        #     elif intrusion_coord2_pts[i] <= s_minside_threshold[i]:
-        #         intrusion_sf2_temp[i] = abs(intrusion_coord2_pts[i] - s_minside_threshold[i])
-        #     elif 0 <= intrusion_coord2_pts[i] < s_maxside_threshold[i]:
-        #         intrusion_sf2_temp[i] = intrusion_coord2_pts[i] - s_maxside_threshold[i]
-        #     elif 0 > intrusion_coord2_pts[i] > s_minside_threshold[i]:
-        #         intrusion_sf2_temp[i] = -(intrusion_coord2_pts[i] - s_minside_threshold[i])
-        #     else: continue
-
-        intrusion_sf = intrusion_sf0_temp
-
-        # for i in range(len(indicator_fx_intrusion)):
-        #     if indicator_fx_intrusion[i] == 1:
-        #         intrusion_sf[i] = -10
-        #     else:
-        #         intrusion_sf[i] = 1 + abs(intrusion_coord0_pts[i]) + abs(intrusion_coord1_pts[i]) + abs(intrusion_coord2_pts[i])
-
-        self.evaluated_points = [
-            points,
-            intrusion_coord0_pts,
-            intrusion_coord1_pts,
-            intrusion_coord2_pts,
-        ]
-        self.intrusion_indicator_function = indicator_fx_intrusion
-        return intrusion_sf  # , indicator_fx_intrusion
+        return intrusion_sf 
diff --git a/LoopStructural/modelling/intrusions/intrusion_frame.py b/LoopStructural/modelling/intrusions/intrusion_frame.py
@@ -12,8 +12,7 @@ def __init__(
         self, 
         interpolator=None, 
         interpolators=None, 
-        model=None, 
-        # name=None, 
+        model=None,
         **kwargs
     ):
         """A specialised structural frame builder for building an intrusion
@@ -32,7 +31,6 @@ def __init__(
         self.origin = np.array([np.nan, np.nan, np.nan])
         self.maximum = np.array([np.nan, np.nan, np.nan])
         self.model = model
-        # self.name = name
 
         self.minimum_origin = self.model.bounding_box[0, :]
         self.maximum_maximum = self.model.bounding_box[1, :]
diff --git a/LoopStructural/modelling/intrusions/intrusion_network.py b/LoopStructural/modelling/intrusions/intrusion_network.py
diff --git a/LoopStructural/modelling/intrusions/intrusion_support_functions.py b/LoopStructural/modelling/intrusions/intrusion_support_functions.py
