LoopStructural 1.0.9__cp38-cp38-win32.whl

LoopStructural/__init__.py

@@ -0,0 +1,36 @@
+"""
+
+
+LoopStructural API
+=======================
+
+.. autosummary::
+    :toctree:
+
+
+    interpolators
+    modelling
+    visualisation
+    utils
+
+"""
+
+import logging
+from logging.config import dictConfig
+import tempfile
+from pathlib import Path
+#set up logging
+# temp_file = tempfile.mkdtemp()
+# if temp_file:
+#     # temp_file = tempfile.tempdir+Path('/default-loop-structural-logfile.log')
+#     log_to_file(temp_file)
+ch = logging.StreamHandler()
+formatter = logging.Formatter('%(asctime)s ~ %(name)-12s ~ %(levelname)-10s ~ %(message)s')
+ch.setFormatter(formatter)
+ch.setLevel(logging.WARNING)
+loggers = {}
+__version__ = '1.0.9'
+from .modelling.core.geological_model import GeologicalModel
+from .utils import log_to_console, log_to_file, getLogger
+logger = getLogger(__name__)
+logger.info("Imported LoopStructural")

LoopStructural/analysis/__init__.py

@@ -0,0 +1,2 @@
+from ._fault_displacement import displacement_missfit
+from ._fault_intersection import calculate_fault_intersections

LoopStructural/analysis/_fault_displacement.py

@@ -0,0 +1,67 @@
+import numpy as np
+from ._plane_fit import PlaneFitFeature
+def displacement_missfit(d,
+                            fault_slip,
+                            fault_center, 
+                            fault_influence, 
+                            fault_extent, 
+                            fault_vertical_radius, 
+                            fault_normal,
+                            fname,
+                            model,
+                            fault_params,
+                            view=None):
+    ## create the fault in the model
+    if view:
+        view.clear()
+    model.create_and_add_fault(fname,
+                                d,
+                                faultfunction='BaseFault',
+                                fault_slip_vector=fault_slip,
+                                fault_center=fault_center,
+                                fault_extent=fault_extent,
+                                fault_influence=fault_influence,
+                                fault_vectical_radius=fault_vertical_radius,
+#                                 overprints=overprints,
+                                **fault_params,
+                                )
+    # run interpolator
+    model[fname].builder.update()
+    # determine which points are inside the fault volume
+    mask = model[fname].inside_volume(model.data[['X','Y','Z']].to_numpy())
+    # mask only data associated with the faulted strati
+    mask = np.logical_and(mask,model.data['feature_name']=='supergroup_0')
+    if view:
+        view.add_isosurface(model[fname],value=0)
+    data2 = model.data.copy()
+    value_data = data2.loc[mask,'val'].to_numpy()
+    # gx = model[fname][0].evaluate_value(data2.loc[np.logical_and(~np.isnan(data2['val']),mask),['X','Y','Z']].to_numpy(),inplace=False))
+    if view:
+        view.add_vector_field(model[fname],
+                            locations=model.rescale(data2.loc[mask,['X','Y','Z']].to_numpy(),
+                            inplace=False))
+        view.add_value_data(model.rescale(data2.loc[mask,['X','Y','Z']].to_numpy(),inplace=False),
+                            data2.loc[mask,['val']].to_numpy(),name='pts_before',
+                            vmin=np.nanmin(value_data),
+                            vmax=np.nanmax(value_data),cmap='rainbow')
+    data2.loc[mask,['X','Y','Z']] = model[fname].apply_to_points(data2.loc[mask,['X','Y','Z']].to_numpy())
+    tmp_pts = data2.loc[mask,['X','Y','Z','val','nx','ny','nz']]
+    tmp_pts = tmp_pts.loc[~np.isnan(tmp_pts['val']),:]
+    fault_plane_feature = PlaneFitFeature(tmp_pts,'Plane_Fit_{}'.format(fname),model=model)
+    
+    dv =data2.loc[np.logical_and(~np.isnan(data2['val']),mask),'val'].to_numpy()
+    if view:
+        view.add_value_data(data2.loc[np.logical_and(~np.isnan(data2['val']),mask),
+                            ['X','Y','Z']].to_numpy(),
+                            dv,
+                            vmin=np.nanmin(value_data),
+                            vmax=np.nanmax(value_data),
+                            cmap='rainbow')
+        view.add_isosurface(fault_plane_feature,
+                            values=np.unique(dv),
+                            paint_with=fault_plane_feature,
+                            vmin=np.nanmin(value_data),
+                            vmax=np.nanmax(value_data),
+                            cmap='rainbow')
+    fv = fault_plane_feature.evaluate_value(data2.loc[np.logical_and(~np.isnan(data2['val']),mask),['X','Y','Z']].to_numpy())
+    return fv, dv, fault_plane_feature

LoopStructural/analysis/_fault_intersection.py

@@ -0,0 +1,36 @@
+from skimage.measure import marching_cubes
+import pandas as pd
+import numpy as np
+def calculate_fault_intersections(model):
+    fault_names = []
+    for f in model.features:
+        if f.type == 'fault':
+            fault_names.append(f.name)
+    fault_matrix = pd.DataFrame(columns=fault_names)
+    for f in fault_names:
+        fault_matrix.loc[f,:] = 0
+        
+    for name in fault_names:
+        xyz=model.regular_grid(shuffle=False)
+        vals = model[name].evaluate_value(xyz)
+        model.nsteps = (50,50,25)
+        model.step_vector = (model.bounding_box[1,:]-model.bounding_box[0,:])/model.nsteps
+        verts, faces, normals, values = marching_cubes(
+                        vals.reshape(model.nsteps, order='C'),
+                        0,
+                        spacing=model.step_vector)
+        verts = model.rescale(verts)
+        for name2 in fault_names:
+            if name2  == name:
+                continue
+            val = model[name2].evaluate_value(model.scale(verts,inplace=False))
+
+            if np.all(np.isnan(val)):
+                continue
+            if np.all(val[~np.isnan(val)] > 0):
+                continue#print('all > 0')
+            elif np.all(val[~np.isnan(val)] < 0):
+                continue
+            else:
+                fault_matrix.loc[name,name2] = 1
+    return fault_matrix

LoopStructural/analysis/_plane_fit.py

@@ -0,0 +1,43 @@
+import numpy as np
+def plane_fit(points):
+    
+    soln = []
+#     points = points.loc[~np.isnan(points['val']),['X','Y','Z','val']]
+    A=np.zeros((len(points)*4,4))
+    B=np.zeros((len(points)*4))
+    val_mask = ~np.isnan(points['val'])
+    vec_mask = ~np.isnan(points['nx'])
+    c = 0
+    xyz = points.loc[val_mask,['X','Y','Z']].to_numpy()
+    A[:len(points[val_mask]),:3] = xyz[:,:3]
+    A[:len(points[val_mask]),3]=1.
+    B[:len(points[val_mask])] = points.loc[val_mask,'val'].to_numpy()#v#np.zeros(A.shape[0])
+    c = len(points[val_mask])
+    A[c:len(points[vec_mask])+c,0] = 1
+    B[c:len(points[vec_mask])+c] = points.loc[vec_mask,'nx'].to_numpy()
+    c+=len(points[vec_mask])
+    A[c:len(points[vec_mask])+c,1] = 1
+    B[c:len(points[vec_mask])+c] = points.loc[vec_mask,'ny'].to_numpy()
+    c+=len(points[vec_mask])
+    A[c:len(points[vec_mask])+c,2] = 1
+    B[c:len(points[vec_mask])+c] = points.loc[vec_mask,'nz'].to_numpy()
+    c+=len(points[vec_mask])
+    x = np.linalg.lstsq(A[:c,:],B[:c],rcond=None)[0]
+    soln.append(x)
+#     print(B)
+    return soln
+
+class PlaneFitFeature:
+    def __init__(self,data,name='Plane',model=None):
+        self.soln = np.array(plane_fit(data)).T
+        self.name = name
+        self.model = model
+    def evaluate_value(self,xyz):
+        if self.model:
+            xyz = self.model.rescale(xyz,inplace=False)
+        return xyz[:,0]*self.soln[None,0]+xyz[:,1]*self.soln[None,1]+xyz[:,2]*self.soln[None,2]+self.soln[None,3]
+    def min(self):
+
+        return -np.inf
+    def max(self):
+        return np.inf

LoopStructural/datasets/__init__.py

@@ -0,0 +1,12 @@
+from ._base import load_claudius
+from ._base import load_grose2017
+from ._base import load_grose2018
+from ._base import load_grose2019
+from ._base import load_laurent2016
+from ._base import load_noddy_single_fold
+from ._base import load_intrusion
+from ._base import normal_vector_headers
+from ._base import strike_dip_headers
+from ._base import value_headers
+from ._base import load_unconformity
+from ._base import load_duplex

LoopStructural/datasets/_base.py

@@ -0,0 +1,65 @@
+from os.path import dirname, join
+from pathlib import Path
+import numpy as np
+import pandas as pd
+
+
+def load_claudius():
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path('data/claudius.csv')))
+    bb = np.loadtxt(join(module_path, Path("data/claudiusbb.txt")))
+    return data, bb
+
+
+def load_noddy_single_fold():
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path('data/onefolddata.csv')))
+    bb = np.loadtxt(join(module_path, Path('data/onefoldbb.txt')))
+    return data, bb
+
+
+def load_laurent2016():
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path('data/refolded_fold.csv')))
+    bb = np.loadtxt(join(module_path, Path('data/refolded_bb.txt')))
+    return data, bb
+
+def load_duplex():
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path('data/duplex.csv')))
+    bb = np.loadtxt(join(module_path, Path('data/duplexbb.txt')))
+    return data, bb
+
+def load_grose2017():
+    pass
+
+
+def load_grose2018():
+    pass
+
+
+def load_grose2019():
+    pass
+
+
+def load_intrusion():
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path,Path('data/intrusion.csv')))
+    bb = np.loadtxt(join(module_path,Path('data/intrusionbb.txt')))
+    return data, bb
+def load_unconformity():
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path,Path('data/unconformity.csv')))
+    bb = np.array([[0,0,0],
+                   [4,6,4]]
+                  )
+    return data,bb
+def value_headers():
+    return ['X','Y','Z','val']
+
+def strike_dip_headers():
+    return ['X','Y','Z','strike','dip']
+
+def normal_vector_headers():
+    return ['X','Y','Z','nx','ny','nz']
+