LoopStructural 1.0.3__zip → 1.0.71.dev0__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/fold_rotation_angle.py

@@ -7,7 +7,8 @@ from LoopStructural.modelling.fold.fold_rotation_angle_feature import \
     fourier_series
 from LoopStructural.modelling.fold import SVariogram
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FoldRotationAngle:
@@ -31,7 +32,7 @@ class FoldRotationAngle:
             self.svario = SVariogram(self.fold_frame_coordinate, self.rotation_angle)
         self.fitted_params = None
 
-    def fit_fourier_series(self, wl = None, lags = None, nlag = None, lag = None):
+    def fit_fourier_series(self, wl = None, lags = None, nlag = None, lag = None, skip_variogram=False,**kwargs):
         """
 
         Parameters
@@ -48,8 +49,8 @@ class FoldRotationAngle:
         if self.svario is None:
             self.svario = SVariogram(self.fold_frame_coordinate,
                                      self.rotation_angle)
-
-        self.svario.calc_semivariogram(lags=lags, nlag=nlag, lag=lag)
+        if skip_variogram == False:
+            self.svario.calc_semivariogram(lags=lags, nlag=nlag, lag=lag)
         if wl is None:
             wl = self.svario.find_wavelengths(lags=lags, nlag=nlag, lag=lag)
             # for now only consider single fold wavelength

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/fold_rotation_angle_feature.py

@@ -2,7 +2,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FoldRotationAngleFeature:

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/foldframe.py

@@ -4,7 +4,8 @@ import numpy as np
 
 from LoopStructural.modelling.features.structural_frame import StructuralFrame
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FoldFrame(StructuralFrame):
@@ -21,10 +22,7 @@ class FoldFrame(StructuralFrame):
         super().__init__(name, features, fold)
         self.model = None
 
-    def set_model(self, model):
-        self.model = model
-
-    def calculate_fold_axis_rotation(self, feature_builder):
+    def calculate_fold_axis_rotation(self, feature_builder,fold_axis=None):
         """
         Calculate the fold axis rotation angle by finding the angle between the
         intersection lineation and the gradient to the 1st coordinate of the
@@ -45,6 +43,9 @@ class FoldFrame(StructuralFrame):
             points.append(gpoints)
         if npoints.shape[0] > 0:
             points.append(npoints)
+        if fold_axis is not None:
+            if fold_axis.shape[0] > 0 and fold_axis.shape[1] == 6:
+                points.append(fold_axis)
         if len(points) == 0:
             return 0, 0
         points = np.vstack(points)
@@ -119,6 +120,7 @@ class FoldFrame(StructuralFrame):
         # get the normals from the points array
         s0g = points[:, 3:]
 
+        s0g/=np.linalg.norm(s0g,axis=1)[:,None]
         # calculate the gradient and value of the first coordinate of the
         # fold frame
         # for the locations and normalise

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/svariogram.py

@@ -2,7 +2,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 def find_peaks_and_troughs(x, y):

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

@@ -11,4 +11,8 @@ Submodules
     utils
 
 """
-from .map2loop import process_map2loop, build_model
+from .logging import getLogger, log_to_file, log_to_console
+from .map2loop import process_map2loop, build_model
+from .helper import get_data_axis_aligned_bounding_box, get_data_bounding_box, get_data_bounding_box_map
+from .helper import get_dip_vector,get_strike_vector, get_vectors
+from .regions import RegionEverywhere

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):
@@ -366,9 +368,15 @@ def val_name():
 def coord_name():
     return ['coord']
 
+def interface_name():
+    return ['interface']
+
+
 def feature_name():
     return ['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()
+           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

@@ -1,8 +1,10 @@
 import pandas as pd
 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={}):
     """
@@ -17,16 +19,20 @@ def process_map2loop(m2l_directory, flags={}):
     m2l_data : dict
         a dictionary containing the extracted and collated data
     """
+    gradient = flags.get('gradient',False)
+    vector_scale = flags.get('vector_scale',None)
     tangents = pd.read_csv(m2l_directory + '/tmp/raw_contacts.csv')
-    groups = pd.read_csv(m2l_directory + '/tmp/all_sorts.csv', index_col=0)
-    contact_orientations = pd.read_csv(m2l_directory + '/output/orientations.csv')
+    groups = pd.read_csv(m2l_directory + '/tmp/all_sorts_clean.csv', index_col=0)
+    contact_orientations = pd.read_csv(m2l_directory + '/output/orientations_clean.csv')
     # formation_thickness = pd.read_csv)
-    contacts = pd.read_csv(m2l_directory + '/output/contacts4.csv')
+    contacts = pd.read_csv(m2l_directory + '/output/contacts_clean.csv')
     displacements = pd.read_csv(m2l_directory + '/output/fault_displacements3.csv')
     fault_orientations = pd.read_csv(m2l_directory + '/output/fault_orientations.csv')
     fault_locations = pd.read_csv(m2l_directory + '/output/faults.csv')
     fault_fault_relations = pd.read_csv(m2l_directory + '/output/fault-fault-relationships.csv')
     fault_strat_relations = pd.read_csv(m2l_directory + '/output/group-fault-relationships.csv')
+    fault_dimensions = pd.read_csv(m2l_directory + '/output/fault_dimensions.csv')
+
     supergroups = {}
     sgi = 0
     try:
@@ -64,9 +70,10 @@ def process_map2loop(m2l_directory, flags={}):
     i = 0
     thickness = {}
     max_thickness = 0
-    with open(m2l_directory + '/output/formation_summary_thicknesses.csv') as file:
+    thickness_file = flags.get('thickness',m2l_directory + '/output/formation_summary_thicknesses.csv')
+    with open(thickness_file) as file:
         for l in file:
-            if i>1:
+            if i>=1:
                 linesplit = l.split(',')
                 thickness[linesplit[0]] = float(linesplit[1])
                 # normalise the thicknesses
@@ -76,14 +83,28 @@ def process_map2loop(m2l_directory, flags={}):
             i+=1
     # for k in thickness.keys():
     #     thickness[k] /= max_thickness
+    if vector_scale is None:
+        vector_scale = max_thickness
 
-    from LoopStructural.utils.helper import strike_dip_vector
-    contact_orientations['strike'] = contact_orientations['azimuth'] - 90
-    contact_orientations['nx'] = np.nan
-    contact_orientations['ny'] = np.nan
-    contact_orientations['nz'] = np.nan
-    contact_orientations[['nx', 'ny', 'nz']] = strike_dip_vector(contact_orientations['strike'],
-                                                                 contact_orientations['dip'])*max_thickness 
+    if gradient:
+        from LoopStructural.utils.helper import strike_dip_vector
+        contact_orientations['strike'] = contact_orientations['azimuth'] - 90
+        contact_orientations['gx'] = np.nan
+        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   
+    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
+        contact_orientations['nx'] = np.nan
+        contact_orientations['ny'] = np.nan
+        contact_orientations['nz'] = np.nan
+        contact_orientations[['nx', 'ny', 'nz']] = strike_dip_vector(contact_orientations['strike'],
+                                                                    contact_orientations['dip'])*vector_scale *contact_orientations['polarity'].to_numpy()[:,None]
     contact_orientations.drop(['strike', 'dip', 'azimuth'], inplace=True, axis=1)
     # with open(m2l_directory + '/output/formation_summary_thicknesses.csv') as file:
 
@@ -101,12 +122,12 @@ def process_map2loop(m2l_directory, flags={}):
             stratigraphic_column[g] = {}
             val[g] = 0
 
-        for c in groups.loc[groups['group number'] == i, 'code']:
+        for c, colour in zip(groups.loc[groups['group number'] == i, 'code'],groups.loc[groups['group number'] == i, 'colour']):
             strat_val[c] = np.nan
             if c in thickness:
-                stratigraphic_column[g][c] = {'max': val[g], 'min': val[g] - thickness[c], 'id': unit_id}
+                stratigraphic_column[g][c] = {'max': val[g], 'min': val[g] - thickness[c], 'id': unit_id, 'colour':colour}
                 unit_id += 1
-                strat_val[c] = val[g]
+                strat_val[c] = val[g] - thickness[c]
                 val[g] -= thickness[c]
     group_name = None
     for g, i in stratigraphic_column.items():
@@ -125,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
@@ -142,35 +171,84 @@ def process_map2loop(m2l_directory, flags={}):
         displacements.loc[displacements['fname'] == fname, 'dip_dir'] = np.mean(
             fault_orientations.loc[fault_orientations['formation'] == fname, 'DipDirection'])
     max_displacement = {}
+    downthrow_dir = {}
+    fault_locations['val'] = 0
+    fault_locations['coord'] = 0
+    fault_orientations['coord'] = 0
+    fault_orientations['gx'] = np.nan
+    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)
+        strike_vector = np.zeros(3)
+        slip_vector = np.zeros(3)
+
+        fault_edges = np.zeros((2,3))
+        fault_tips = np.zeros((2,3))
+        fault_depth = np.zeros((2,3))
         displacements_numpy = displacements.loc[
-            displacements['fname'] == f, ['vertical_displacement', 'downthrow_dir', 'dip_dir']].to_numpy()
+            displacements['fname'] == f, ['vertical_displacement', 'downthrow_dir', 'dip_dir','X','Y']].to_numpy()
         # index = np.argmax(np.abs(displacements_numpy[:, 0]), )
         index = np.argsort(np.abs(displacements_numpy[:, 0]))[len(np.abs(displacements_numpy[:, 0]))//2]
-
+        
         max_displacement[f] = displacements_numpy[
             index, 0]
-        if displacements_numpy[index, 1] - displacements_numpy[index, 2] > 90:
-            fault_orientations.loc[fault_orientations['formation'] == fname, 'DipDirection'] = displacements_numpy[
-                index, 1]
-        # .loc[displacements['fname'] == f,'vertical_displacement'].max()
+        downthrow_dir[f] = displacements_numpy[index,[1,3,4]]
+        if np.abs(displacements_numpy[index, 1] - displacements_numpy[index, 2]) > 90:
+            # fault_orientations.loc[fault_orientations['formation'] == f, ['gx','gy','gy']]=-fault_orientations.loc[fault_orientations['formation'] == f, ['gx','gy','gy']]
+            fault_orientations.loc[fault_orientations['formation'] == f, 'DipDirection'] -= 180#displacements_numpy[
+                # index, 1]
+        # find the middle of the fault as the mean of the line, average dip direction and the influence distance
+        fault_centers[:3] = np.mean(fault_locations.loc[fault_locations['formation']==f,['X','Y','Z']],axis=0)
+        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]
+        strike_vector[1] = -normal_vector[0]
+        slip_vector[2]=1
+        fault_edges[0,:] = fault_centers[:3]+normal_vector*fault_centers[4]
+        fault_edges[1,:] = fault_centers[:3]-normal_vector*fault_centers[4]
+        fault_tips[0,:] = fault_centers[:3]+strike_vector*fault_centers[5]
+        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]
+
+        # 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
-    fault_orientations['gx'] = np.nan
-    fault_orientations['gy'] = np.nan
-    fault_orientations['gz'] = np.nan
+    # fault_orientations['strike'] = fault_orientations['DipDirection'] - 90
+    # fault_orientations['gx'] = np.nan
+    # fault_orientations['gy'] = np.nan
+    # fault_orientations['gz'] = np.nan
 
-    fault_orientations[['gx', 'gy', 'gz']] = strike_dip_vector(fault_orientations['strike'], fault_orientations['dip'])
     fault_orientations.drop(['strike', 'DipDirection', 'dip', 'DipPolarity'], inplace=True, axis=1)
     fault_orientations['feature_name'] = fault_orientations['formation']
-
-    fault_locations['val'] = 0
     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,
@@ -178,9 +256,10 @@ def process_map2loop(m2l_directory, flags={}):
             'fault_fault': fault_fault_relations,
             'stratigraphic_column': stratigraphic_column,
             'bounding_box':bb,
-            'strat_va':strat_val}
+            '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):
+def build_model(m2l_data, evaluate=True, skip_faults = False, unconformities=False, fault_params = None, foliation_params=None, rescale = True,**kwargs):
     """[summary]
 
     [extended_summary]
@@ -230,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,
                                                     )
@@ -248,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

@@ -1,8 +1,9 @@
 import logging
 
 import numpy as np
-
-logger = logging.getLogger(__name__)
+import re
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 def strike_symbol(strike):
@@ -22,55 +23,47 @@ 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
 
 
+def read_voxet(voxetname,propertyfile):
+    """
+    Read a gocad property file and the geometry information from the .vo file
+    voxetname - is the path to the voxet file
+    propertyfile is the path to the binary file
     Returns
-    -------
-    dict
-        contains all strings with corresponding logging levels.
+    origin numpy array
+    voxet_extent - is the length of each axis of the voxet
+    N is the number of steps in the voxet
+    array is the property values
+    steps is the size of the step vector for the voxet 
     """
-    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
-
+    array = np.fromfile(propertyfile,dtype='float32')
+    array = array.astype('<f4') # little endian
+    with open(voxetname,'r') as file:
+        for l in file:
+            if 'AXIS_O ' in l:
+                origin = np.array(re.findall(r"[-+]?\d*\.?\d+|[-+]?\d+",l)).astype(float)
+            if 'AXIS_U ' in l:
+                U = float(re.findall(r'[\d\.\d]+',l)[0])
+            if 'AXIS_V ' in l:
+                V = float(re.findall(r'[\d\.\d]+',l)[1])
+            if 'AXIS_W ' in l:
+                W = float(re.findall(r'[\d\.\d]+',l)[2])
+            if 'AXIS_N ' in l:
+                N = np.array(re.findall(r'[\d\.\d]+',l)).astype(int) 
+    voxet_extent = np.array([U,V,W])
+    steps = (voxet_extent ) / (N-1)
+    return origin, voxet_extent, N, array, steps
 
-    Parameters
-    ----------
-    filename : string
-        name of file or path to file
-    level : str, optional
-        'info', 'warning', 'error', 'debug' mapped to logging levels, by default 'info'
+def write_property_to_gocad_voxet(propertyfilename, propertyvalues):
     """
-    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'
+    This function writes a numpy array into the right format for a gocad
+    voxet property file. This assumet there is a property already added to the .vo file,
+    and is just updating the file.
+    propertyfile - string giving the path to the file to write
+    propertyvalues - numpy array nz,ny,nx ordering and in float format
     """
-    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)
+    propertyvalues = propertyvalues.astype('>f4') #big endian
+#     array = propertyvalues.newbyteorder()
+    propertyvalues.tofile(propertyfilename)
+