LoopStructural 1.0.4__zip → 1.0.71.dev0__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/bounding_box.py

@@ -0,0 +1,21 @@
+# class BoundingBox:
+#     def __init__(self,origin,maximum):
+#         self.bb = np.array([origin,maximum])
+#         self.maximum = maximum
+#         self.name_map = {'xmin':(0,0),'ymin':(0,1),'zmin':(0,2),'xmax':(1,0),'ymax':(1,1),'zmax':(1,2)
+#                          'lower':(0,2),'upper':(1,2),
+#                          'minx':(0,0),'miny':(0,1),'minz':(0,2),'maxx':(1,0),'maxy':(1,1),'maxz':(1,2)}
+#     def get_value(self,name):
+#         ix,iy = self.name_map.get(name,(-1,-1))
+
+#         return self.bb[ix,]
+
+#     def is_inside(self,xyz):
+#         inside = np.zeros(xy.shape[0],dtype=bool)
+#         inside = np.logical_and(inside,xyz[:,0]>self.bb[0,0])
+#         inside = np.logical_and(inside,xyz[:,0]<self.bb[1,0])
+#         inside = np.logical_and(inside,xyz[:,1]>self.bb[0,1])
+#         inside = np.logical_and(inside,xyz[:,1]<self.bb[1,1])
+#         inside = np.logical_and(inside,xyz[:,2]>self.bb[0,2])
+#         inside = np.logical_and(inside,xyz[:,2]<self.bb[1,2])
+#         return inside

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/exceptions.py

@@ -1,6 +1,7 @@
 import logging
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 class LoopBaseException(Exception):
     """

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/helper.py

@@ -1,9 +1,11 @@
 import logging
 
 import numpy as np
+import pandas as pd
 from sklearn.decomposition import PCA
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 def get_data_axis_aligned_bounding_box(xyz, buffer):
@@ -376,3 +378,5 @@ def feature_name():
 def all_heading():
     return xyz_names() + normal_vec_names() + tangent_vec_names() + \
            gradient_vec_names() + weight_name() + val_name() + coord_name() + feature_name() + interface_name()
+def empty_dataframe():
+    empty_data_frame =pd.DataFrame(columns=[all_heading()])

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/logging.py

@@ -0,0 +1,60 @@
+import logging
+import LoopStructural
+
+def get_levels():
+    """dict for converting to logger levels from string
+
+
+    Returns
+    -------
+    dict
+        contains all strings with corresponding logging levels.
+    """
+    return {'info':logging.INFO,'warning':logging.WARNING,'error':logging.ERROR,'debug':logging.DEBUG}
+
+def getLogger(name):
+    logger = logging.getLogger(name)
+    logger.addHandler(LoopStructural.ch)
+    LoopStructural.loggers[name] = logger
+    return logger
+
+def log_to_file(filename,level='info'):
+    """Set the logging parameters for log file
+
+
+    Parameters
+    ----------
+    filename : string
+        name of file or path to file
+    level : str, optional
+        'info', 'warning', 'error', 'debug' mapped to logging levels, by default 'info'
+    """
+    levels = get_levels()
+    level = levels.get(level,logging.WARNING)
+    fh = logging.FileHandler(filename)
+    fh.setFormatter(LoopStructural.formatter)
+    fh.setLevel(level)
+    for logger in LoopStructural.loggers.values():
+        for hdlr in logger.handlers[:]:  # remove the existing file handlers
+            if isinstance(hdlr,logging.FileHandler): #fixed two typos here
+                logger.removeHandler(hdlr)
+        logger.addHandler(fh) 
+        logger.setLevel(level)
+    
+
+def log_to_console(level='warning'):
+    """Set the level of logging to the console
+
+
+    Parameters
+    ----------
+    level : str, optional
+        'info', 'warning', 'error', 'debug' mapped to logging levels, by default 'info'
+    """
+    levels = get_levels()
+    level = levels.get(level,logging.WARNING)
+    for logger in LoopStructural.loggers.values():
+        for hdlr in logger.handlers:
+            # both stream and file are base stream, so check if not a filehandler
+            if not isinstance(hdlr,logging.FileHandler):
+                hdlr.setLevel(level)

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/map2loop.py

@@ -3,7 +3,8 @@ import numpy as np
 import os
 import logging
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 def process_map2loop(m2l_directory, flags={}):
     """
@@ -92,7 +93,10 @@ def process_map2loop(m2l_directory, flags={}):
         contact_orientations['gy'] = np.nan
         contact_orientations['gz'] = np.nan
         contact_orientations[['gx', 'gy', 'gz']] = strike_dip_vector(contact_orientations['strike'],
-                                                                    contact_orientations['dip'])*max_thickness 
+                                                                    contact_orientations['dip'])*max_thickness   
+    if np.sum(contact_orientations['polarity']==0) >0 and np.sum(contact_orientations['polarity']==-1)==0:
+        # contact_orientations['polarity']+=1
+        contact_orientations.loc[contact_orientations['polarity']==0]=-1
     if not gradient:
         from LoopStructural.utils.helper import strike_dip_vector
         contact_orientations['strike'] = contact_orientations['azimuth'] - 90
@@ -142,10 +146,18 @@ def process_map2loop(m2l_directory, flags={}):
                 group_name = None
             except:
                 print('Couldnt process {}'.format(g))
-    contacts['val'] = np.nan
-    for o in strat_val:
-        contacts.loc[contacts['formation'] == o, 'val'] = strat_val[o]
-
+    #whether to use thickness or interface
+    use_thickness = flags.get('use_thickness',True)
+    if use_thickness:
+        contacts['val'] = np.nan
+        for o in strat_val:
+            contacts.loc[contacts['formation'] == o, 'val'] = strat_val[o]
+    if use_thickness == False:
+        contacts['interface'] = np.nan
+        interface_val = 0
+        for u in contacts['formation'].unique():
+            contacts.loc[contacts['formation'] == u,'interface'] = interface_val
+            interface_val+=1
     tangents['feature_name'] = tangents['group']
     contact_orientations['feature_name'] = None
     contacts['feature_name'] = None
@@ -167,7 +179,7 @@ def process_map2loop(m2l_directory, flags={}):
     fault_orientations['gy'] = np.nan
     fault_orientations['gz'] = np.nan
 
-
+    stratigraphic_column['faults'] = {}
     for f in displacements['fname'].unique():
         fault_centers = np.zeros(6)
         normal_vector = np.zeros(3)
@@ -194,6 +206,13 @@ def process_map2loop(m2l_directory, flags={}):
         fault_centers[3] = np.mean(fault_orientations.loc[fault_orientations['formation']==f,['DipDirection']])
         fault_centers[4] = fault_dimensions.loc[fault_dimensions['Fault']==f,'InfluenceDistance']
         fault_centers[5] = fault_dimensions.loc[fault_dimensions['Fault']==f,'HorizontalRadius']
+        stratigraphic_column['faults'][f] = {'FaultCenter':fault_centers[:3],
+                                            'FaultDipDirection':fault_centers[3],
+                                            'InfluenceDistance':fault_dimensions.loc[fault_dimensions['Fault']==f,'InfluenceDistance'].to_numpy(),
+                                            'HorizontalRadius':fault_dimensions.loc[fault_dimensions['Fault']==f,'HorizontalRadius'].to_numpy(),
+                                            'VerticalRadius':fault_dimensions.loc[fault_dimensions['Fault']==f,'VerticalRadius'].to_numpy()}
+        if 'colour' in fault_dimensions.columns:
+            stratigraphic_column['faults'][f]['colour'] = fault_dimensions.loc[fault_dimensions['Fault']==f,'colour'].to_numpy()
         normal_vector[0] = np.sin(np.deg2rad(fault_centers[3]))
         normal_vector[1] = np.cos(np.deg2rad(fault_centers[3]))
         strike_vector[0] = normal_vector[1]
@@ -205,19 +224,18 @@ def process_map2loop(m2l_directory, flags={}):
         fault_tips[1,:] = fault_centers[:3]-strike_vector*fault_centers[5]
         # fault_depth[0,:] = fault_centers[:3]+slip_vector*fault_centers[5]
         # fault_depth[1,:] = fault_centers[:3]-slip_vector*fault_centers[5]
-        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_edges[0,0],fault_edges[0,1],fault_edges[0,2],f,1,0]
-        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_edges[1,0],fault_edges[1,1],fault_edges[1,2],f,-1,0]
-        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_tips[0,0],fault_tips[0,1],fault_tips[0,2],f,1,2]
-        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_tips[1,0],fault_tips[1,1],fault_tips[1,2],f,-1,2]
-        # add strike vector to constraint fault extent
-        fault_orientations.loc[len(fault_orientations),['X','Y','Z','formation','DipDirection','coord']] = [fault_centers[0],fault_centers[1],fault_centers[2],f, fault_centers[3]-90,2]
-        fault_orientations.loc[len(fault_orientations),['X','Y','Z','formation','dip','coord']] = [fault_centers[0],fault_centers[1],fault_centers[2],f, 0,2]
+        # fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_edges[0,0],fault_edges[0,1],fault_edges[0,2],f,1,0]
+        # fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_edges[1,0],fault_edges[1,1],fault_edges[1,2],f,-1,0]
+        # fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_tips[0,0],fault_tips[0,1],fault_tips[0,2],f,1,2]
+        # fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_tips[1,0],fault_tips[1,1],fault_tips[1,2],f,-1,2]
+        # # add strike vector to constraint fault extent
+        # fault_orientations.loc[len(fault_orientations),['X','Y','Z','formation','DipDirection','coord']] = [fault_centers[0],fault_centers[1],fault_centers[2],f, fault_centers[3]-90,2]
+        # fault_orientations.loc[len(fault_orientations),['X','Y','Z','formation','dip','coord']] = [fault_centers[0],fault_centers[1],fault_centers[2],f, 0,2]
 
         # print('downthro',displacements_numpy[index, 1])
         
     fault_orientations['strike'] = fault_orientations['DipDirection'] - 90
     fault_orientations[['gx', 'gy', 'gz']] = strike_dip_vector(fault_orientations['strike'], fault_orientations['dip'])
-
     for g in groups['group'].unique():
         groups.loc[groups['group']==g,'group'] = supergroups[g]
     # fault_orientations['strike'] = fault_orientations['DipDirection'] - 90
@@ -229,10 +247,8 @@ def process_map2loop(m2l_directory, flags={}):
     fault_orientations['feature_name'] = fault_orientations['formation']
     fault_locations['feature_name'] = fault_locations['formation']
 
-    
-
     data = pd.concat([tangents, contact_orientations, contacts, fault_orientations, fault_locations])
-    data.reset_index()
+    data.reset_index(inplace=True)
 
     return {'data': data,
             'groups': groups,
@@ -243,7 +259,7 @@ def process_map2loop(m2l_directory, flags={}):
             'strat_va':strat_val,
             'downthrow_dir':downthrow_dir}
 
-def build_model(m2l_data, skip_faults = False, unconformities=False, fault_params = None, foliation_params=None, rescale = True,**kwargs):
+def build_model(m2l_data, evaluate=True, skip_faults = False, unconformities=False, fault_params = None, foliation_params=None, rescale = True,**kwargs):
     """[summary]
 
     [extended_summary]
@@ -293,9 +309,19 @@ def build_model(m2l_data, skip_faults = False, unconformities=False, fault_param
             except:
                 logger.info('No entry for %s in fault_fault_relations' % f)
         #     continue
+
+            fault_center = m2l_data['stratigraphic_column']['faults'][f]['FaultCenter']
+            fault_influence = m2l_data['stratigraphic_column']['faults'][f]['InfluenceDistance']
+            fault_extent = m2l_data['stratigraphic_column']['faults'][f]['HorizontalRadius']
+            fault_vertical_radius = m2l_data['stratigraphic_column']['faults'][f]['VerticalRadius']
             faults.append(model.create_and_add_fault(f,
                                                     -m2l_data['max_displacement'][f],
                                                     faultfunction='BaseFault',
+                                                    fault_slip_vector=np.array([0.,0.,-1.]),
+                                                    fault_center=fault_center,
+                                                    fault_extent=fault_extent,
+                                                    fault_influence=fault_influence,
+                                                    fault_vectical_radius=fault_vertical_radius,
                                                     overprints=overprints,
                                                     **fault_params,
                                                     )
@@ -311,4 +337,6 @@ def build_model(m2l_data, skip_faults = False, unconformities=False, fault_param
         if group_features[-1] and unconformities:
             model.add_unconformity(group_features[-1], 0)
     model.set_stratigraphic_column(m2l_data['stratigraphic_column'])
+    if evaluate:
+        model.update(verbose=True)
     return model

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/regions.py

@@ -0,0 +1,11 @@
+import numpy as np
+
+class RegionEverywhere:
+    def __call__(self,xyz):
+        return np.ones(xyz.shape[0],dtype='bool')
+
+class RegionFunction:
+    def __init__(self,function):
+        self.function = function
+    def __call__(self,xyz):
+        return self.function(xyz)

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/utils.py

@@ -2,8 +2,8 @@ import logging
 
 import numpy as np
 import re
-
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 def strike_symbol(strike):
@@ -23,58 +23,7 @@ def strike_symbol(strike):
     vec2 = np.array([-0.5, 0])
     r2 = R @ vec2
     return rotated, r2
-def get_levels():
-    """dict for converting to logger levels from string
-
-
-    Returns
-    -------
-    dict
-        contains all strings with corresponding logging levels.
-    """
-    return {'info':logging.INFO,'warning':logging.WARNING,'error':logging.ERROR,'debug':logging.DEBUG}
-
-def log_to_file(filename,level='info'):
-    """Set the logging parameters for log file
-
-
-    Parameters
-    ----------
-    filename : string
-        name of file or path to file
-    level : str, optional
-        'info', 'warning', 'error', 'debug' mapped to logging levels, by default 'info'
-    """
-    levels = get_levels()
-    level = levels.get(level,logging.WARNING)
-    logging.basicConfig(level=level,
-                    format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
-                    datefmt='%m-%d %H:%M',
-                    filename=filename,
-                    filemode='w')
-
-def log_to_console(level='warning'):
-    """Set the level of logging to the console
-
-
-    Parameters
-    ----------
-    level : str, optional
-        'info', 'warning', 'error', 'debug' mapped to logging levels, by default 'info'
-    """
-    levels = get_levels()
-    level = levels.get(level,logging.WARNING)
 
-    changed_level = False
-    for h in logging.getLogger().handlers:
-        if type(h) is logging.StreamHandler:
-            h.setLevel(level)
-            changed_level = True
-    if not changed_level:
-        console = logging.StreamHandler()
-        console.setLevel(level)
-        # add the handler to the root logger
-        logging.getLogger().addHandler(console)
 
 def read_voxet(voxetname,propertyfile):
     """

Miniconda/envs/loop/Lib/site-packages/LoopStructural/visualisation/map_viewer.py

@@ -3,7 +3,8 @@ import logging
 import matplotlib.pyplot as plt
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class MapView:
@@ -198,6 +199,18 @@ class MapView:
                 dip_v = np.rad2deg(np.arccos(gradient_data[:,5])).astype(int)
                 for d, xy, v in zip(dip_v,gradient_data[:,:2],gradient_data[:,3:6]):
                     self.ax.annotate(d,xy,xytext=xy+v[:2]*.03,fontsize='small')
+                    
+    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_scalar_field(self, feature, z=0, **kwargs):
         """
@@ -265,6 +278,8 @@ class MapView:
             boundaries = []
             data = []
             for g in self.model.stratigraphic_column.keys():
+                if g == 'faults':
+                    continue
                 for u, v  in self.model.stratigraphic_column[g].items():
                     data.append((v['id'],v['colour']))
                     colours.append(v['colour'])
@@ -304,4 +319,4 @@ class MapView:
                     maskv[np.abs(val) > 0.001] = 1
                     return maskv
                 
-                self.add_contour(f,0,mask=mask)
+                self.add_contour(f,0,mask=mask,**kwargs)

Miniconda/envs/loop/Lib/site-packages/LoopStructural/visualisation/model_plotter.py

@@ -1,7 +1,8 @@
 # import logging
 #
 #
-# logger = logging.getLogger(__name__)
+# from LoopStructural.utils import getLogger
+# logger = getLogger(__name__)
 #
 # class BaseModelPlotter:
 #     def __init__(self, model):