fix: code clenaing and lateral data update

Author: FernsAlvanevs

LoopStructural/modelling/intrusions/intrusion_builder.py

@@ -77,10 +77,10 @@ def __init__(
 
         self.marginal_faults = self._feature.intrusion_frame.builder.marginal_faults
 
-        if self.marginal_faults is not None:
-            for fault_i in self.marginal_faults.keys():
-                marginal_fault = self.marginal_faults[fault_i].get('structure')
-                self.intrusion_frame[2] = marginal_fault[0]
+        # if self.marginal_faults is not None:
+        #     for fault_i in self.marginal_faults.keys():
+        #         marginal_fault = self.marginal_faults[fault_i].get('structure')
+        #         self.intrusion_frame[2] = marginal_fault[0]
 
 
         # self.growth_simulated_thresholds_grid = None
@@ -426,49 +426,35 @@ def set_data_for_lateral_thresholds(self):
 
         if self.width_data[0] == False:  # i.e., no lateral data for side L<0
             print(
-                "Not enought lateral data for simulation of side L<0, Using roof/floor data to condition the conceptual model"
+                "Not enought lateral data to constrain side L<0. Conceptual model will be used to constrain lateral extent"
             )
 
-            # -- try using vertical data to set some points and run interpolation
-            # -- only use points outside the conceptual model
-            vertical_data = pd.concat(
-                [self.vertical_contact_data[0], self.vertical_contact_data[1]]
-            )
-            vertical_data.loc[
-                :, ["conceptual_maxside", "conceptual_minside"]
-            ] = self.lateral_extent_model(
-                lateral_contact_data=vertical_data,
-                minP=minP,
-                maxP=maxP,
-                minS=minL,
-                maxS=maxL,
-            )
-
-            data_minL_temp = vertical_data[vertical_data["coord2"] < 0].copy()
-
-            data_for_min_L = data_minL_temp[data_minL_temp['coord2'] <= data_minL_temp['conceptual_minside']].loc[
-                    :,['X','Y','Z','coord0','coord1','coord2','conceptual_minside']].copy()
-            data_for_min_L.loc[:,'l_residual'] = data_for_min_L.loc[
-                :,'conceptual_minside'] - data_for_min_L.loc[:,'coord2']
-            data_for_min_L.rename(columns={'conceptual_minside': 'l_conceptual'}, inplace = True)
-            data_for_min_L.reset_index(inplace = True)
-            data_for_min_L.drop_duplicates(
-                subset = ['X','Y','Z','coord0','coord1','coord2','l_conceptual','l_residual'], 
-                inplace = True)
-
-            if len(data_for_min_L) < 3:
-                # create random points along coordinate 1, and evaluate them in conceptual model. Residual = 0. Add points to dataframe containing input for sgs
-                print(
-                    "Simulation of lateral side L<0: No enought roof/floor data to condition the conceptual model, lateral contact equivalent to conceptual"
-                )
+            random_p = pd.DataFrame(np.random.uniform(minP, maxP, 10), columns = ['coord1'])
+            conceptual_l = self.lateral_extent_model(lateral_contact_data=random_p, minP=minP, maxP=maxP, minS=minL, maxS=maxL)
+            data_for_min_L = pd.DataFrame(np.vstack([conceptual_l[:,1],random_p.loc[:,'coord1'].to_numpy()]).T, columns = ['l_conceptual','coord1'])
+            data_for_min_L.loc[:,'l_residual'] = 0
+            
 
-                random_p = pd.DataFrame(np.random.uniform(minP, maxP, 10), columns = ['coord1'])
-                conceptual_l = self.lateral_extent_model(lateral_contact_data=random_p, minP=minP, maxP=maxP, minS=minL, maxS=maxL)
-                data_for_min_L_ = pd.DataFrame(np.vstack([conceptual_l[:,1],random_p.loc[:,'coord1'].to_numpy()]).T, columns = ['l_conceptual','coord1'])
-                data_for_min_L_.loc[:,'l_residual'] = 0
+            if len(self.lateral_contact_data[1]) > 0:
+                data_minL = self.lateral_contact_data[1]
+                data_conceptual_minL = self.lateral_extent_model(
+                    lateral_contact_data=data_minL,
+                    minP=minP,
+                    maxP=maxP,
+                    minS=minL,
+                    maxS=maxL,
+                    )
+                data_residual_minL = (data_conceptual_minL[:, 1] - data_minL.loc[:, "coord2"]).to_numpy()
+                data_for_min_L_ = data_minL.loc[:, ["X", "Y", "Z", "coord0", "coord1", "coord2"]].copy()
+                data_for_min_L_.loc[:, "l_residual"] = data_residual_minL
+                data_for_min_L_.loc[:, "l_conceptual"] = data_conceptual_minL[:, 1]
+                data_for_min_L_.reset_index(inplace=True)
                 data_for_min_L = pd.concat([data_for_min_L, data_for_min_L_])
 
-            data_for_min_L.loc[:, "ref_coord"] = 0
+            
+            data_for_min_L['l_residual'] = data_for_min_L['l_residual'].astype(float)
+            data_for_min_L['coord1'] = data_for_min_L['coord1'].astype(float) 
+          
 
         else:
             # -- Side of intrusion with coord2<0 (l<0)
@@ -480,59 +466,42 @@ def set_data_for_lateral_thresholds(self):
                 minS=minL,
                 maxS=maxL,
             )
-            data_residual_minL = (
-                data_conceptual_minL[:, 1] - data_minL.loc[:, "coord2"]
-            ).to_numpy()
-            data_for_min_L = data_minL.loc[
-                :, ["X", "Y", "Z", "coord0", "coord1", "coord2"]
-            ].copy()
+            data_residual_minL = (data_conceptual_minL[:, 1] - data_minL.loc[:, "coord2"]).to_numpy()
+            data_for_min_L = data_minL.loc[:, ["X", "Y", "Z", "coord0", "coord1", "coord2"]].copy()
             data_for_min_L.loc[:, "l_residual"] = data_residual_minL
             data_for_min_L.loc[:, "l_conceptual"] = data_conceptual_minL[:, 1]
-
             data_for_min_L.reset_index(inplace=True)
-            data_for_min_L.loc[:, "ref_coord"] = 0
+            # data_for_min_L.loc[:, "ref_coord"] = 0
 
         if self.width_data[1] == False:  # i.e., no lateral data for side L>0
             print(
-                "Not enought lateral data for simulation of side L>=0, Using roof/floor data to condition the conceptual model"
-            )
-
-            # -- try using vertical data to set some points and run SGS
-            vertical_data = pd.concat(
-                [self.vertical_contact_data[0], self.vertical_contact_data[1]]
-            )
-            vertical_data.loc[
-                :, ["conceptual_maxside", "conceptual_minside"]
-            ] = self.lateral_extent_model(
-                lateral_contact_data=vertical_data,
-                minP=minP,
-                maxP=maxP,
-                minS=minL,
-                maxS=maxL,
+                "Not enought lateral data to constrain side L>0. Conceptual model will be used to constrain lateral extent"
             )
 
-            data_maxL_temp = vertical_data[vertical_data["coord2"] >= 0].copy()
-
-            data_for_max_L = data_maxL_temp[data_maxL_temp['coord2'] >= data_maxL_temp['conceptual_maxside']].loc[:,['X','Y','Z','coord0','coord1','coord2','conceptual_maxside']].copy()
-            data_for_max_L.loc[:,'l_residual'] = data_for_max_L.loc[:,'conceptual_maxside'] - data_for_max_L.loc[:,'coord2']
-            data_for_max_L.rename(columns={'conceptual_maxside': 'l_conceptual'}, inplace = True)
-            data_for_max_L.reset_index(inplace = True)
-            data_for_max_L.drop_duplicates(
-                subset = ['X','Y','Z','coord0','coord1','coord2','l_conceptual','l_residual'], 
-                inplace = True)
-
-            if len(data_for_max_L) < 3:
-                print(
-                    "Simulation of lateral side L>=0: No enought roof/floor data to condition the conceptual model, lateral contact equivalent to conceptual"
+            random_p = pd.DataFrame(np.random.uniform(minP, maxP, 10), columns = ['coord1'])
+            conceptual_l = self.lateral_extent_model(lateral_contact_data=random_p, minP=minP, maxP=maxP, minS=minL, maxS=maxL)
+            data_for_max_L = pd.DataFrame(np.vstack([conceptual_l[:,0],random_p.loc[:,'coord1'].to_numpy()]).T, columns = ['l_conceptual','coord1'])
+            data_for_max_L.loc[:,'l_residual'] = 0
+            
+            if len(self.lateral_contact_data[2]) > 0:
+                data_maxL = self.lateral_contact_data[2]
+                data_conceptual_maxL = self.lateral_extent_model(
+                    lateral_contact_data=data_maxL,
+                    minP=minP,
+                    maxP=maxP,
+                    minS=minL,
+                    maxS=maxL,
                 )
-                # create random points along coordinate 1, and evaluate them conceptual model. Residual = 0. Add points to dataframe containing input for sgs
-                random_p = pd.DataFrame(np.random.uniform(minP, maxP, 10), columns = ['coord1'])
-                conceptual_l = self.lateral_extent_model(lateral_contact_data=random_p, minP=minP, maxP=maxP, minS=minL, maxS=maxL)
-                data_for_max_L_ = pd.DataFrame(np.vstack([conceptual_l[:,0],random_p.loc[:,'coord1'].to_numpy()]).T, columns = ['l_conceptual','coord1'])
-                data_for_max_L_.loc[:,'l_residual'] = 0
+                data_residual_maxL = (data_conceptual_maxL[:, 0] - data_maxL.loc[:, "coord2"]).to_numpy()
+                data_for_max_L_ = data_maxL.loc[:, ["X", "Y", "Z", "coord0", "coord1", "coord2"]].copy()
+                data_for_max_L_.loc[:, "l_residual"] = data_residual_maxL
+                data_for_max_L_.loc[:, "l_conceptual"] = data_conceptual_maxL[:, 0]
+                data_for_max_L_.reset_index(inplace=True)
                 data_for_max_L = pd.concat([data_for_max_L, data_for_max_L_])
+          
 
-            data_for_max_L.loc[:, "ref_coord"] = 0
+            data_for_max_L['l_residual'] = data_for_max_L['l_residual'].astype(float) 
+            data_for_max_L['coord1'] = data_for_max_L['coord1'].astype(float)
 
         else:
             data_maxL = self.lateral_contact_data[2]
@@ -543,17 +512,54 @@ def set_data_for_lateral_thresholds(self):
                 minS=minL,
                 maxS=maxL,
             )
-            data_residual_maxL = (
-                data_conceptual_maxL[:, 0] - data_maxL.loc[:, "coord2"]
-            ).to_numpy()
-            data_for_max_L = data_maxL.loc[
-                :, ["X", "Y", "Z", "coord0", "coord1", "coord2"]
-            ].copy()
+            data_residual_maxL = (data_conceptual_maxL[:, 0] - data_maxL.loc[:, "coord2"]).to_numpy()
+            data_for_max_L = data_maxL.loc[:, ["X", "Y", "Z", "coord0", "coord1", "coord2"]].copy()
             data_for_max_L.loc[:, "l_residual"] = data_residual_maxL
             data_for_max_L.loc[:, "l_conceptual"] = data_conceptual_maxL[:, 0]
-
             data_for_max_L.reset_index(inplace=True)
-            data_for_max_L.loc[:, "ref_coord"] = 0
+            # data_for_max_L.loc[:, "ref_coord"] = 0
+
+        
+        # check if roof or floor data outside of conceptual model. 
+        # if so, add as constraints to conceptual model.
+        vertical_data = pd.concat([self.vertical_contact_data[0], self.vertical_contact_data[1]])
+        vertical_data.loc[:, ["conceptual_maxside", "conceptual_minside"]] = self.lateral_extent_model(
+            lateral_contact_data=vertical_data,
+            minP=minP,
+            maxP=maxP,
+            minS=minL,
+            maxS=maxL,
+            )
+
+        data_minL_temp = vertical_data[vertical_data["coord2"] < 0].copy()
+        data_for_min_L_ = data_minL_temp[data_minL_temp['coord2'] < data_minL_temp['conceptual_minside']].loc[:,['X','Y','Z','coord0','coord1','coord2','conceptual_minside']].copy()
+        data_for_min_L_.loc[:,'l_residual'] = data_for_min_L_.loc[:,'conceptual_minside'] - data_for_min_L_.loc[:,'coord2']
+        data_for_min_L_.rename(columns={'conceptual_minside': 'l_conceptual'}, inplace = True)
+        data_for_min_L_.reset_index(inplace = True)
+        data_for_min_L_.drop_duplicates(subset = ['X','Y','Z','coord0','coord1','coord2','l_conceptual','l_residual'], inplace = True)
+
+        if len(data_for_min_L_) >0:
+            print('adding data from roof/floor to constrain L<0')
+            data_for_min_L = pd.concat([data_for_min_L, data_for_min_L_])
+
+        data_maxL_temp = vertical_data[vertical_data["coord2"] >= 0].copy()
+        data_for_max_L_ = data_maxL_temp[data_maxL_temp['coord2'] > data_maxL_temp['conceptual_maxside']].loc[:,['X','Y','Z','coord0','coord1','coord2','conceptual_maxside']].copy()
+        data_for_max_L_.loc[:,'l_residual'] = data_for_max_L_.loc[:,'conceptual_maxside'] - data_for_max_L_.loc[:,'coord2']
+        data_for_max_L_.rename(columns={'conceptual_maxside': 'l_conceptual'}, inplace = True)
+        data_for_max_L_.reset_index(inplace = True)
+        data_for_max_L_.drop_duplicates(
+            subset = ['X','Y','Z','coord0','coord1','coord2','l_conceptual','l_residual'], 
+            inplace = True)
+
+        if len(data_for_max_L_) >0:
+            print('adding data from roof/floor to constrain L>0')
+            data_for_max_L = pd.concat([data_for_max_L, data_for_max_L_])
+
+        
+        data_for_min_L['l_residual'] = data_for_min_L['l_residual'].astype(float)
+        data_for_min_L['coord1'] = data_for_min_L['coord1'].astype(float) 
+        data_for_max_L['l_residual'] = data_for_max_L['l_residual'].astype(float) 
+        data_for_max_L['coord1'] = data_for_max_L['coord1'].astype(float)
 
         self.data_for_lateral_extent_calculation = [data_for_min_L, data_for_max_L]
 
@@ -625,14 +631,18 @@ def set_data_for_vertical_thresholds(self):
             inputsimdata_maxG_.loc[:, "g_conceptual"] = data_conceptual_G_[:, 1]
             inputsimdata_maxG_.loc[:, "g_residual"] = 0
 
-            inputsimdata_maxG = pd.concat(inputsimdata_maxG, inputsimdata_maxG_)
+            inputsimdata_maxG_complete = pd.concat([inputsimdata_maxG, inputsimdata_maxG_])
+
+        else:
+            inputsimdata_maxG_complete = inputsimdata_maxG
+
 
         # --- growth simulation input data for intrusion network conditioning
         inputsimdata_inetG = inet_data.loc[
             :, ["X", "Y", "Z", "coord0", "coord1", "coord2"]
         ].copy()
 
-        self.data_for_vertical_extent_calculation = [inputsimdata_maxG, inputsimdata_inetG]
+        self.data_for_vertical_extent_calculation = [inputsimdata_maxG_complete, inputsimdata_inetG]
 
     def build(
         self,

LoopStructural/modelling/intrusions/intrusion_feature.py

@@ -120,12 +120,12 @@ def interpolate_lateral_thresholds(self, points_coord1):
         inputsimdata_maxL = self.builder.data_for_lateral_extent_calculation[1]
 
         minL_inputdata_coord1 = inputsimdata_minL.coord1.to_numpy()
-        minL_inputdata_coord2 = inputsimdata_minL.coord2.to_numpy()
+        # minL_inputdata_coord2 = inputsimdata_minL.coord2.to_numpy()
         minL_inputdata_residual = inputsimdata_minL.l_residual.to_numpy()
         # minL_inputdata_conceptual = inputsimdata_minL.l_conceptual.to_numpy()
 
         maxL_inputdata_coord1 = inputsimdata_maxL.coord1.to_numpy()
-        maxL_inputdata_coord2 = inputsimdata_maxL.coord2.to_numpy()
+        # maxL_inputdata_coord2 = inputsimdata_maxL.coord2.to_numpy()
         maxL_inputdata_residual = inputsimdata_maxL.l_residual.to_numpy()
         # maxL_inputdata_conceptual = inputsimdata_maxL.l_conceptual.to_numpy()
 
@@ -322,7 +322,7 @@ def evaluate_value(self, points):
             )
 
         if self.intrusion_frame.builder.marginal_faults is not None:
-            c2_minside_threshold = np.zeros_like(intrusion_coord2_pts)
+            c2_minside_threshold = thresholds[0] #np.zeros_like(intrusion_coord2_pts)
             c2_maxside_threshold = thresholds[1]
 
 

LoopStructural/modelling/intrusions/intrusion_frame_builder.py

@@ -342,7 +342,7 @@ def set_intrusion_steps_parameters(self):
                 contact_0_mean = np.mean(contact_0_vals)
                 contact_0_std = np.std(contact_0_vals)
 
-                if contact_0_std == 0:
+                if contact_0_std == 0 or np.isnan(contact_0_std)==True:
                     contact_0_std = std_backup
 
                 # contact 1
@@ -352,7 +352,7 @@ def set_intrusion_steps_parameters(self):
                 contact_1_mean = np.mean(contact_1_vals)
                 contact_1_std = np.std(contact_1_vals)
 
-                if contact_1_std == 0:
+                if contact_1_std == 0 or np.isnan(contact_1_std)==True:
                     contact_1_std = std_backup
 
                 if contact_0_mean <= contact_1_mean:
@@ -418,6 +418,14 @@ def set_intrusion_steps_parameters(self):
                         series_values_mod = series_values
                     step["unit_to_mean"] = np.nanmean(series_values_mod)
                     step["unit_to_std"] = np.nanstd(series_values_mod)
+                    check_mean = step["unit_to_mean"]
+                    check_std = step["unit_to_std"]
+                
+                    if np.isnan(check_mean) == True:
+                        step["unit_to_mean"] = 40
+
+                    if np.isnan(check_std) == True:
+                        step["unit_to_std"] = std_backup
 
                 if step["unit_to_std"] == 0:
                     step["unit_to_std"] = std_backup