LoopStructural 1.0.4__zip → 1.0.71.dev0__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/core/geological_model.py

@@ -5,7 +5,6 @@ import logging
 
 import numpy as np
 import pandas as pd
-
 from LoopStructural.datasets import normal_vector_headers
 from LoopStructural.interpolators.discrete_fold_interpolator import \
     DiscreteFoldInterpolator as DFI
@@ -14,34 +13,25 @@ from LoopStructural.interpolators.finite_difference_interpolator import \
 from LoopStructural.interpolators.piecewiselinear_interpolator import \
     PiecewiseLinearInterpolator as PLI
 
-try:
-    from LoopStructural.interpolators.surfe_wrapper import \
-        SurfeRBFInterpolator as Surfe
-
-    surfe = True
-
-except ImportError:
-    surfe = False
 
-from LoopStructural.utils.helper import all_heading, gradient_vec_names, \
-    strike_dip_vector
+from LoopStructural.interpolators.structured_grid import StructuredGrid
+from LoopStructural.interpolators.structured_tetra import TetMesh
 from LoopStructural.modelling.fault.fault_segment import FaultSegment
-from LoopStructural.modelling.features import \
-    GeologicalFeatureInterpolator
-from LoopStructural.modelling.features import RegionFeature
-from LoopStructural.modelling.features import \
-    StructuralFrameBuilder
-from LoopStructural.modelling.features import UnconformityFeature
-from LoopStructural.modelling.fold.fold import FoldEvent
+from LoopStructural.modelling.fault import FaultBuilder
+from LoopStructural.modelling.features import (GeologicalFeatureInterpolator,
+                                               RegionFeature,
+                                               StructuralFrameBuilder,
+                                               UnconformityFeature)
 from LoopStructural.modelling.fold import FoldRotationAngle
+from LoopStructural.modelling.fold.fold import FoldEvent
 from LoopStructural.modelling.fold.foldframe import FoldFrame
-from LoopStructural.interpolators.structured_grid import StructuredGrid
-from LoopStructural.interpolators.structured_tetra import TetMesh
 from LoopStructural.utils.exceptions import LoopBaseException
+from LoopStructural.utils.helper import (all_heading, gradient_vec_names,
+                                         strike_dip_vector)
+
+from LoopStructural.utils import getLogger, log_to_file
+logger = getLogger(__name__)
 
-logger = logging.getLogger(__name__)
-if not surfe:
-    logger.warning("Cannot import Surfe")
 
 
 def _calculate_average_intersection(series_builder, fold_frame, fold,
@@ -88,7 +78,7 @@ class GeologicalModel:
 
     """
     def __init__(self, origin, maximum, rescale=True, nsteps=(40, 40, 40),
-                 reuse_supports=False):
+                 reuse_supports=False, logfile=None, loglevel='info'):
         """
         Parameters
         ----------
@@ -122,41 +112,68 @@ class GeologicalModel:
 
 
         """
+        if logfile:
+            self.logfile = logfile
+            log_to_file(logfile,loglevel)
+        
+        logger.info('Initialising geological model')
         self.features = []
         self.feature_name_index = {}
         self.data = None
         self.nsteps = nsteps
-
+        self._str = 'Instance of LoopStructural.GeologicalModel \n'
+        self._str += '------------------------------------------ \n'
         # we want to rescale the model area so that the maximum length is
         # 1
         self.origin = np.array(origin).astype(float)
-
+        originstr = 'Model origin: {} {} {}'.format(self.origin[0],self.origin[1],self.origin[2])
+        logger.info(originstr)
+        self._str+=originstr+'\n'
         self.maximum = np.array(maximum).astype(float)
+        maximumstr = 'Model maximum: {} {} {}'.format(self.maximum[0],self.maximum[1],self.maximum[2])
+        logger.info(maximumstr)
+        self._str+=maximumstr+'\n'
+
         lengths = self.maximum - self.origin
         self.scale_factor = 1.
         self.bounding_box = np.zeros((2, 3))
         self.bounding_box[1, :] = self.maximum - self.origin
         self.bounding_box[1, :] = self.maximum - self.origin
         if rescale:
-            self.scale_factor = np.max(lengths)
-
+            self.scale_factor = float(np.max(lengths))
+            logger.info('Rescaling model using scale factor {}'.format(self.scale_factor))
+        self._str+='Model rescale factor: {} \n'.format(self.scale_factor)
+        self._str+='The model contains {} GeologicalFeatures \n'.format(len(self.features))
+        self._str+=''
+        self._str += '------------------------------------------ \n'
+        self._str += ''
         self.bounding_box /= self.scale_factor
         self.support = {}
         self.reuse_supports = reuse_supports
+        if self.reuse_supports:
+            logger.warning("Supports are shared between geological features \n"
+                                "this may cause unexpected behaviour and should only\n"
+                                "be use by advanced users")
+        logger.info('Reusing interpolation supports: {}'.format(self.reuse_supports))
         self.stratigraphic_column = None
         self.parameters = {'features': [], 'model': {'bounding_box': self.origin.tolist() + self.maximum.tolist(),
                                                      'rescale': rescale,
                                                      'nsteps': nsteps,
                                                      'reuse_supports': reuse_supports}}
         
+    def __str__(self):
+        return self._str
 
+    def _ipython_key_completions_(self):
+        return self.feature_name_index.keys()
+        
     @classmethod
     def from_map2loop_directory(cls, m2l_directory,**kwargs):
         """Alternate constructor for a geological model using m2l output
 
         Uses the information saved in the map2loop files to build a geological model.
         You can specify kwargs for building foliation using foliation_params and for 
-        faults using fault_params. skip_faults is a flag that allows for the faults to be skipped.
+        faults using fault_params.  faults is a flag that allows for the faults to be skipped.
 
         Parameters
         ----------
@@ -168,7 +185,8 @@ class GeologicalModel:
         (GeologicalModel, dict)
             the created geological model and a dictionary of the map2loop data
         """
-        from LoopStructural.utils import process_map2loop, build_model
+        from LoopStructural.utils import build_model, process_map2loop
+        logger.info('LoopStructural model initialised from m2l directory: {}'.format(m2l_directory))
         m2lflags = kwargs.pop('m2lflags',{})
         m2l_data = process_map2loop(m2l_directory,m2lflags)
         return build_model(m2l_data,**kwargs), m2l_data
@@ -194,11 +212,33 @@ class GeologicalModel:
             return None
         model = pickle.load(open(file,'rb'))
         if type(model) == GeologicalModel:
+            logger.info('GeologicalModel initialised from file')
             return model
         else:
             logger.error('{} does not contain a geological model'.format(file))
             return None
+        
+    def __getitem__(self, feature_name):
+        """Accessor for feature in features using feature_name_index
+
+        Parameters
+        ----------
+        feature_name : string
+            name of the feature to return
+        """
+        return self.get_feature_by_name(feature_name)
+    
+    def feature_names(self):
+        return self.feature_name_index.keys()
+
+    def fault_names(self):
+        pass
 
+    def check_inialisation(self):
+        if self.data is None:
+            logger.error("Data not associated with GeologicalModel. Run set_data")
+            return False
+        
     def to_file(self, file):
         """Save a model to a pickle file requires dill
 
@@ -214,6 +254,7 @@ class GeologicalModel:
                         "pip install dill")
             return
         try:
+            logger.info('Writing GeologicalModel to: {}'.format(file))
             pickle.dump(self,open(file,'wb'))
         except pickle.PicklingError:
             logger.error('Error saving file')
@@ -234,6 +275,7 @@ class GeologicalModel:
                         (feature.name, self.feature_name_index[feature.name]))
             self.features[self.feature_name_index[feature.name]] = feature
         else:
+            self._str += 'GeologicalFeature: {} of type - {} \n'.format(feature.name,feature.type)
             self.features.append(feature)
             self.feature_name_index[feature.name] = len(self.features) - 1
             logger.info("Adding %s to model at location %i" % (
@@ -241,7 +283,10 @@ class GeologicalModel:
         self._add_domain_fault_above(feature)
         self._add_unconformity_above(feature)
         feature.set_model(self)
-
+    
+    def data_for_feature(self,feature_name):
+        return self.data.loc[self.data['feature_name'] == feature_name,:]
+        
     def set_model_data(self, data):
         """
         Set the data array for the model
@@ -269,7 +314,7 @@ class GeologicalModel:
                 data = pd.read_csv(data)
             except:
                 logger.error("Could not load pandas data frame from data")
-
+        logger.info('Adding data to GeologicalModel with {} data points'.format(len(data)))
         self.data = data.copy()
         self.data['X'] -= self.origin[0]
         self.data['Y'] -= self.origin[1]
@@ -278,7 +323,7 @@ class GeologicalModel:
         self.data['Y'] /= self.scale_factor
         self.data['Z'] /= self.scale_factor
         if 'type' in self.data:
-            logger.warning("'type' is being replaced with 'feature_name' \n")
+            logger.warning("'type' is depreciated replace with 'feature_name' \n")
             self.data.rename(columns={'type':'feature_name'},inplace=True)
         for h in all_heading():
             if h not in self.data:
@@ -289,6 +334,7 @@ class GeologicalModel:
                     self.data[h] = 0
         
         if 'strike' in self.data and 'dip' in self.data:
+            logger.info('Converting strike and dip to vectors')
             mask = np.all(~np.isnan(self.data.loc[:, ['strike', 'dip']]),
                           axis=1)
             self.data.loc[mask, gradient_vec_names()] = strike_dip_vector(
@@ -343,6 +389,7 @@ class GeologicalModel:
         """
         # if the colour for a unit hasn't been specified we can just sample from 
         # a colour map e.g. tab20
+        logger.info('Adding stratigraphic column to model')
         random_colour = True
         n_units=0
         for g in stratigraphic_column.keys():
@@ -387,7 +434,7 @@ class GeologicalModel:
                 self.create_and_add_folded_foliation(f)
 
     def get_interpolator(self, interpolatortype='PLI', nelements=1e5,
-                         buffer=0.2, **kwargs):
+                         buffer=0.2, element_volume = None, **kwargs):
         """
         Returns an interpolator given the arguments, also constructs a
         support for a discrete interpolator
@@ -419,54 +466,64 @@ class GeologicalModel:
         bb[1, :] += buffer  # *(bb[1,:]-bb[0,:])
         box_vol = (bb[1, 0]-bb[0, 0]) * (bb[1, 1]-bb[0, 1]) * (bb[1, 2]-bb[0, 2])
         if interpolatortype == "PLI":
-            nelements /= 5
-            ele_vol = box_vol / nelements
+            if element_volume is None:
+                nelements /= 5
+                element_volume = box_vol / nelements
             # calculate the step vector of a regular cube
             step_vector = np.zeros(3)
-            step_vector[:] = ele_vol ** (1. / 3.)
+            step_vector[:] = element_volume ** (1. / 3.)
             # step_vector /= np.array([1,1,2])
             # number of steps is the length of the box / step vector
             nsteps = np.ceil((bb[1, :] - bb[0, :]) / step_vector).astype(int)
             # create a structured grid using the origin and number of steps
-            mesh_id = 'mesh_{}'.format(nelements)
-            mesh = self.support.get(mesh_id,
-                                    TetMesh(origin=bb[0, :], nsteps=nsteps,
-                                            step_vector=step_vector))
-            if mesh_id not in self.support:
-                self.support[mesh_id] = mesh
+            if self.reuse_supports:
+                mesh_id = 'mesh_{}'.format(nelements)
+                mesh = self.support.get(mesh_id,
+                                        TetMesh(origin=bb[0, :], nsteps=nsteps,
+                                                step_vector=step_vector))
+                if mesh_id not in self.support:
+                    self.support[mesh_id] = mesh
+            else:
+                mesh = TetMesh(origin=bb[0, :], nsteps=nsteps, step_vector=step_vector)
             logger.info("Creating regular tetrahedron mesh with %i elements \n"
                         "for modelling using PLI" % (mesh.ntetra))
 
             return PLI(mesh)
 
         if interpolatortype == 'FDI':
+
             # find the volume of one element
-            ele_vol = box_vol / nelements
+            if element_volume is None:
+                element_volume = box_vol / nelements
             # calculate the step vector of a regular cube
             step_vector = np.zeros(3)
-            step_vector[:] = ele_vol ** (1. / 3.)
+            step_vector[:] = element_volume ** (1. / 3.)
             # number of steps is the length of the box / step vector
             nsteps = np.ceil((bb[1, :] - bb[0, :]) / step_vector).astype(int)
             if np.any(np.less(nsteps, 3)):
                 logger.error("Cannot create interpolator: number of steps is too small")
                 return None
             # create a structured grid using the origin and number of steps
-            grid_id = 'grid_{}'.format(nelements)
-            grid = self.support.get(grid_id, StructuredGrid(origin=bb[0, :],
+            if self.reuse_supports:
+                grid_id = 'grid_{}'.format(nelements)
+                grid = self.support.get(grid_id, StructuredGrid(origin=bb[0, :],
                                                             nsteps=nsteps,
                                                             step_vector=step_vector))
-            if grid_id not in self.support:
-                self.support[grid_id] = grid
+                if grid_id not in self.support:
+                    self.support[grid_id] = grid
+            else:
+                grid = StructuredGrid(origin=bb[0, :], nsteps=nsteps,step_vector=step_vector)
             logger.info("Creating regular grid with %i elements \n"
                         "for modelling using FDI" % grid.n_elements)
             return FDI(grid)
 
         if interpolatortype == "DFI":  # "fold" in kwargs:
-            nelements /= 5
-            ele_vol = box_vol / nelements
+            if element_volume is None:
+                nelements /= 5
+                element_volume = box_vol / nelements
             # calculate the step vector of a regular cube
             step_vector = np.zeros(3)
-            step_vector[:] = ele_vol ** (1. / 3.)
+            step_vector[:] = element_volume ** (1. / 3.)
             # number of steps is the length of the box / step vector
             nsteps = np.ceil((bb[1, :] - bb[0, :]) / step_vector).astype(int)
             # create a structured grid using the origin and number of steps
@@ -475,8 +532,19 @@ class GeologicalModel:
             logger.info("Creating regular tetrahedron mesh with %i elements \n"
                         "for modelling using DFI" % mesh.ntetra)
             return DFI(mesh, kwargs['fold'])
-        if interpolatortype == 'Surfe' or interpolatortype == 'surfe' and \
-                surfe:
+        if interpolatortype == 'Surfe' or interpolatortype == 'surfe':
+            # move import of surfe to where we actually try and use it
+            try:
+                from LoopStructural.interpolators.surfe_wrapper import \
+                    SurfeRBFInterpolator as Surfe
+
+                surfe = True
+
+            except ImportError:
+                surfe = False
+            if not surfe:
+                logger.warning("Cannot import Surfe, try another interpolator")
+                raise ImportError
             method = kwargs.get('method', 'single_surface')
             logger.info("Using surfe interpolator")
             return Surfe(method)
@@ -496,6 +564,8 @@ class GeologicalModel:
         feature : GeologicalFeature
             the created geological feature
         """
+        if self.check_inialisation() == False:
+            return False
         self.parameters['features'].append({'feature_type': 'foliation', 'feature_name': series_surface_data, **kwargs})
         interpolator = self.get_interpolator(**kwargs)
         series_builder = GeologicalFeatureInterpolator(interpolator,
@@ -510,13 +580,53 @@ class GeologicalModel:
         self._add_faults(series_builder)
 
         # build feature
-        series_feature = series_builder.build(**kwargs)
+        # series_feature = series_builder.build(**kwargs)
+        series_feature = series_builder.feature
+        series_builder.build_arguments = kwargs
         series_feature.type = 'series'
         # see if any unconformities are above this feature if so add region
         # self._add_unconformity_above(series_feature)self._add_feature(series_feature)
         self._add_feature(series_feature)
         return series_feature
 
+    def create_and_add_dtm(self, series_surface_data, **kwargs):
+        """
+        Parameters
+        ----------
+        series_surface_data : string
+            corresponding to the feature_name in the data
+        kwargs
+
+        Returns
+        -------
+        feature : GeologicalFeature
+            the created geological feature
+        """
+        if self.check_inialisation() == False:
+            return False
+        self.parameters['features'].append({'feature_type': 'foliation', 'feature_name': series_surface_data, **kwargs})
+        interpolator = self.get_interpolator(**kwargs)
+        series_builder = GeologicalFeatureInterpolator(interpolator,
+                                                       name=series_surface_data,
+                                                       **kwargs)
+        # add data
+        series_data = self.data[self.data['feature_name'] == series_surface_data]
+        if series_data.shape[0] == 0:
+            logger.warning("No data for %s, skipping" % series_surface_data)
+            return
+        series_builder.add_data_from_data_frame(series_data)
+        # self._add_faults(series_builder)
+
+        # build feature
+        # series_feature = series_builder.build(**kwargs)
+        series_feature = series_builder.feature
+        series_builder.build_arguments = kwargs
+        series_feature.type = 'dtm'
+        # see if any unconformities are above this feature if so add region
+        # self._add_unconformity_above(series_feature)self._add_feature(series_feature)
+        self._add_feature(series_feature)
+        return series_feature
+        
     def create_and_add_fold_frame(self, foldframe_data, **kwargs):
         """
         Parameters
@@ -531,6 +641,8 @@ class GeologicalModel:
         fold_frame : FoldFrame
             the created fold frame
         """
+        if self.check_inialisation() == False:
+            return False
         self.parameters['features'].append({'feature_type': 'fold_frame', 'feature_name': foldframe_data, **kwargs})
         # create fault frame
         interpolator = self.get_interpolator(**kwargs)
@@ -553,7 +665,7 @@ class GeologicalModel:
         
         return fold_frame
 
-    def create_and_add_folded_foliation(self, foliation_data, fold_frame=None,
+    def create_and_add_folded_foliation(self, foliation_data, fold_frame=None, svario=True,
                                         **kwargs):
         """
         Create a folded foliation field from data and a fold frame
@@ -563,6 +675,8 @@ class GeologicalModel:
         foliation_data : str
             unique string in type column of data frame
         fold_frame :  FoldFrame
+        svario  : Boolean
+            whether to calculate svariograms, saves time if avoided
         kwargs
             additional kwargs to be passed through to other functions
 
@@ -571,6 +685,8 @@ class GeologicalModel:
         feature : GeologicalFeature
             created geological feature
         """
+        if self.check_inialisation() == False:
+            return False
         self.parameters['features'].append(
             {'feature_type': 'fold_foliation', 'feature_name': foliation_data, 'fold_frame': fold_frame, **kwargs})
         if fold_frame is None:
@@ -586,16 +702,19 @@ class GeologicalModel:
         series_builder.add_data_from_data_frame(
             self.data[self.data['feature_name'] == foliation_data])
         self._add_faults(series_builder)
-
         series_builder.add_data_to_interpolator(True)
-        if "fold_axis" in kwargs:
-            fold.fold_axis = kwargs['fold_axis']
+        fold_axis = kwargs.get('fold_axis',None)
+        if fold_axis is not None:
+            fold_axis = np.array(fold_axis)
+            if len(fold_axis.shape) == 1:
+                fold.fold_axis = fold_axis
+        
         if "av_fold_axis" in kwargs:
             _calculate_average_intersection(series_builder, fold_frame, fold)
         if fold.fold_axis is None:
             far, fad = fold_frame.calculate_fold_axis_rotation(
                 series_builder)
-            fold_axis_rotation = FoldRotationAngle(far, fad)
+            fold_axis_rotation = FoldRotationAngle(far, fad,svario=svario)
             a_wl = kwargs.get("axis_wl", None)
             if 'axis_function' in kwargs:
                 # allow predefined function to be used
@@ -606,24 +725,26 @@ class GeologicalModel:
         # give option of passing own fold limb rotation function
         flr, fld = fold_frame.calculate_fold_limb_rotation(
             series_builder)
-        fold_limb_rotation = FoldRotationAngle(flr, fld)
+        fold_limb_rotation = FoldRotationAngle(flr, fld,svario=svario)
         l_wl = kwargs.get("limb_wl", None)
         if 'limb_function' in kwargs:
             # allow for predefined functions to be used
             fold_limb_rotation.set_function(kwargs['limb_function'])
         else:
-            fold_limb_rotation.fit_fourier_series(wl=l_wl)
+            fold_limb_rotation.fit_fourier_series(wl=l_wl,**kwargs)
         fold.fold_limb_rotation = fold_limb_rotation
         # fold_limb_fitter = kwargs.get("fold_limb_function",
         # _interpolate_fold_limb_rotation_angle)
         # fold_limb_fitter(series_builder, fold_frame, fold, result, **kwargs)
-        kwargs['fold_weights'] = kwargs.get('fold_weights', None)
+        kwargs['fold_weights'] = kwargs.get('fold_weights', {})
 
         self._add_faults(series_builder)
         # build feature
         kwargs['cgw'] = 0.
         kwargs['fold'] = fold
-        series_feature = series_builder.build(**kwargs)
+        # series_feature = series_builder.build(**kwargs)
+        series_feature = series_builder.feature
+        series_builder.build_arguments = kwargs
         series_feature.type = 'series'
         # see if any unconformities are above this feature if so add region
         # self._add_unconformity_above(series_feature)self._add_feature(series_feature)
@@ -651,6 +772,8 @@ class GeologicalModel:
         fold_frame : FoldFrame
             created fold frame
         """
+        if self.check_inialisation() == False:
+            return False
         self.parameters['features'].append(
             {'feature_type': 'folded_fold_frame', 'feature_name': fold_frame_data, 'fold_frame': fold_frame, **kwargs})
         if fold_frame is None:
@@ -659,8 +782,10 @@ class GeologicalModel:
         assert type(fold_frame) == FoldFrame, "Please specify a FoldFrame"
         fold = FoldEvent(fold_frame,name='Fold_{}'.format(fold_frame_data))
         fold_interpolator = self.get_interpolator("DFI", fold=fold, **kwargs)
+        gy_fold_interpolator = self.get_interpolator("DFI", fold=fold, **kwargs)
+
         frame_interpolator = self.get_interpolator(**kwargs)
-        interpolators = [fold_interpolator, frame_interpolator,
+        interpolators = [fold_interpolator, gy_fold_interpolator,
                          frame_interpolator.copy()]
         fold_frame_builder = StructuralFrameBuilder(
             interpolators=interpolators, name=fold_frame_data, **kwargs)
@@ -669,6 +794,7 @@ class GeologicalModel:
 
         ## add the data to the interpolator for the main foliation
         fold_frame_builder[0].add_data_to_interpolator(True)
+
         if "fold_axis" in kwargs:
             logger.info("Using cylindrical fold axis")
             fold.fold_axis = kwargs['fold_axis']
@@ -704,12 +830,11 @@ class GeologicalModel:
         # fold_limb_fitter = kwargs.get("fold_limb_function",
         # _interpolate_fold_limb_rotation_angle)
         # fold_limb_fitter(series_builder, fold_frame, fold, result, **kwargs)
-        kwargs['fold_weights'] = kwargs.get('fold_weights', None)
+        kwargs['fold_weights'] = kwargs.get('fold_weights', {})
 
         for i in range(3):
             self._add_faults(fold_frame_builder[i])
         # build feature
-        kwargs['cgw'] = 0.
         kwargs['fold'] = fold
         self._add_faults(fold_frame_builder[0])
         self._add_faults(fold_frame_builder[1])
@@ -842,6 +967,8 @@ class GeologicalModel:
         Returns
         -------
         """
+        if not self.check_initialisation():
+            return False
         # self.parameters['features'].append({'feature_type':'unconformity','feature_name':unconformity_surface_data,**kwargs})
         interpolator = self.get_interpolator(**kwargs)
         unconformity_feature_builder = GeologicalFeatureInterpolator(
@@ -858,7 +985,9 @@ class GeologicalModel:
         self._add_faults(unconformity_feature_builder)
 
         # build feature
-        uc_feature_base = unconformity_feature_builder.build(**kwargs)
+        # uc_feature_base = unconformity_feature_builder.build(**kwargs)
+        uc_feature_base = unconformity_feature_builder.feature
+        unconformity_feature_builder.build_arguments = kwargs
         uc_feature_base.type = 'unconformity_base'
         # uc_feature = UnconformityFeature(uc_feature_base,0)
         # iterate over existing features and add the unconformity as a
@@ -958,7 +1087,9 @@ class GeologicalModel:
         self._add_faults(domain_fault_feature_builder)
 
         # build feature
-        domain_fault = domain_fault_feature_builder.build(**kwargs)
+        # domain_fault = domain_fault_feature_builder.build(**kwargs)
+        domain_fault = domain_fault_feature_builder.feature
+        domain_fault_feature_builder.build_arguments = kwargs
         domain_fault.type = 'domain_fault'
         self._add_feature(domain_fault)
         self._add_domain_fault_below(domain_fault)
@@ -969,13 +1100,28 @@ class GeologicalModel:
         # evaluated where the unconformity is positive
         return domain_fault_uc
 
-    def create_and_add_fault(self, fault_surface_data, displacement, renormalise=True, **kwargs):
+    def create_and_add_fault(self, 
+                            fault_surface_data, 
+                            displacement, 
+                            fault_slip_vector=None,
+                            fault_center = None, 
+                            fault_extent = None, 
+                            fault_influence = None, 
+                            fault_vectical_radius = None,
+                            faultfunction=None, 
+                            **kwargs):
         """
         Parameters
         ----------
         fault_surface_data : string
             name of the fault surface data in the dataframe
         displacement : displacement magnitude
+        fault_extent : [type], optional
+            [description], by default None
+        fault_influence : [type], optional
+            [description], by default None
+        fault_vectical_radius : [type], optional
+            [description], by default None
         kwargs : additional kwargs for Fault and interpolators
 
         Returns
@@ -985,90 +1131,48 @@ class GeologicalModel:
         """
         self.parameters['features'].append(
             {'feature_type': 'fault', 'feature_name': fault_surface_data, 'displacement': displacement, **kwargs})
-
+        if 'data_region' in kwargs:
+            kwargs.pop('data_region')
+            logger.error("kwarg data_region currently not supported, disabling")
         displacement_scaled = displacement / self.scale_factor
         # create fault frame
         interpolator = self.get_interpolator(**kwargs)
-        fault_frame_builder = StructuralFrameBuilder(interpolator,
+        fault_frame_builder = FaultBuilder(interpolator,
                                                      name=fault_surface_data,
                                                      **kwargs)
         # add data
-        fault_frame_data = self.data[
-            self.data['feature_name'] == fault_surface_data].copy()
-        if 'coord' not in fault_frame_data:
-            fault_frame_data['coord'] = 0
-        vals = fault_frame_data['val']
-        if len(np.unique(vals[~np.isnan(vals)])) == 1 and renormalise:
-            logger.info("Setting fault ellipsoid to 1/3 of fault length")
-            xyz = fault_frame_data[['X', 'Y', 'Z']].to_numpy()
-            p1 = xyz[0, :]  # fault_frame_data.loc[0 ,['X','Y']]
-            p2 = xyz[-1, :]  # fault_frame_data.loc[-1 ,['X','Y']]
-            # get a vector that goes from p1-p2 and normalise
-            vector = p1 - p2
-            length = np.linalg.norm(vector)
-            vector /= length
-            # now create the orthogonal vector
-            # newvector = np.zeros(3)
-            length /= 3
-            # length/=2
-            # print(fault_frame_data)
-            mask = ~np.isnan(fault_frame_data['gx'])
-            vectors = fault_frame_data[mask][['gx', 'gy', 'gz']].to_numpy()
-            lengths = np.linalg.norm(vectors, axis=1)
-            vectors /= lengths[:, None]
-            # added 20/08 rescale fault ellipsoid for m2l
-            # vectors*=length
-            fault_frame_data.loc[mask, ['gx', 'gy', 'gz']] = vectors
-            if 'strike' in fault_frame_data.columns and 'dip' in \
-                    fault_frame_data.columns:
-                fault_frame_data = fault_frame_data.drop(['dip', 'strike'],
-                                                         axis=1)
-        #     print(fault_frame_data)
-        # if there is no slip direction data assume vertical
-        if fault_frame_data[fault_frame_data['coord'] == 1].shape[0] == 0:
-            logger.info("Adding fault frame slip")
-            loc = np.mean(fault_frame_data[['X', 'Y', 'Z']], axis=0)
-            coord1 = pd.DataFrame([[loc[0], loc[1], loc[2], 0, 0, -1]],
-                                  columns=normal_vector_headers())
-            coord1['coord'] = 1
-            fault_frame_data = pd.concat([fault_frame_data, coord1],
-                                         sort=False)
- 
-        if fault_frame_data[fault_frame_data['coord'] == 2].shape[0] == 0:
-            logger.info("Adding fault extent data as first and last point")
-            ## first and last point of the line
-            value_data = fault_frame_data[fault_frame_data['val'] == 0]
-            if not value_data.empty:
-                coord2 = value_data.iloc[[0, len(value_data) - 1]]
-                coord2 = coord2.reset_index(drop=True)
-                c2_scale = kwargs.get('length_scale',1.)
-                coord2.loc[0, 'val'] = -1/c2_scale
-                coord2.loc[1, 'val'] = 1/c2_scale
-                coord2['coord'] = 2
-                fault_frame_data = pd.concat([fault_frame_data, coord2],
-                                         sort=False)
-        fault_frame_builder.add_data_from_data_frame(fault_frame_data)
-        # if there is no fault slip data then we could find the strike of
-        # the fault and build
-        # the second coordinate
-        # if we add a region to the fault then the fault operator doesn't
-        # work but for visualisation
-        # we want to add a region!
-
-        if 'splayregion' in kwargs and 'splay' in kwargs:
-            # result['splayregionfeature'] = RegionFeature(kwargs['splayregion'])
-            # apply splay to all parts of fault frame
-            for i in range(3):
-                # work out the values of the nodes where we want hard
-                # constraints
-                idc = np.arange(0, interpolator.support.n_nodes)[
-                    kwargs['splayregion'](interpolator.support.nodes)]
-                val = kwargs['splay'][i].evaluate_value(
-                    interpolator.support.nodes[
-                    kwargs['splayregion'](interpolator.support.nodes), :])
-                mask = ~np.isnan(val)
-                fault_frame_builder[i].interpolator.add_equality_constraints(
-                    idc[mask], val[mask])
+        fault_frame_data = self.data[ self.data['feature_name'] == fault_surface_data].copy()
+        mask = np.logical_and(fault_frame_data['coord']==0,~np.isnan(fault_frame_data['gz']))
+        fault_normal_vector = fault_frame_data.loc[mask,['gx','gy','gz']].mean(axis=0).to_numpy()
+        mask = np.logical_and(fault_frame_data['coord']==1,~np.isnan(fault_frame_data['gz']))
+        if fault_slip_vector is None:
+            fault_slip_vector = fault_frame_data.loc[mask,['gx','gy','gz']].mean(axis=0).to_numpy()
+        if fault_center is not None:
+            fault_center = self.scale(fault_center,inplace=False)
+        if fault_center is None:
+            # if we haven't defined a fault centre take the center of mass for lines assocaited with
+            # the fault trace
+            mask = np.logical_and(fault_frame_data['coord']==0,fault_frame_data['val']==0)
+            fault_center = fault_frame_data.loc[mask,['X','Y','Z']].mean(axis=0).to_numpy()
+        if fault_influence:
+            fault_influence=fault_influence/self.scale_factor
+        if fault_extent:
+            fault_extent=fault_extent/self.scale_factor
+        if fault_vectical_radius:
+            fault_vectical_radius=fault_vectical_radius/self.scale_factor
+        fault_frame_builder.create_data_from_geometry(fault_frame_data,
+                                                      fault_center,
+                                                      fault_normal_vector,
+                                                      fault_slip_vector,
+                                                      influence_distance=fault_influence,
+                                                      horizontal_radius=fault_extent,
+                                                      vertical_radius=fault_vectical_radius
+                                                      )
+        if fault_influence == None or fault_extent == None or fault_vectical_radius == None:
+            fault_frame_builder.origin = self.origin
+            fault_frame_builder.maximum = self.maximum
+        fault_frame_builder.set_mesh_geometry(kwargs.get('fault_buffer',0.1))
+        # fault_frame_builder.add_data_from_data_frame(fault_frame_data)
         # check if this fault overprint any existing faults exist in the stack
         overprinted = kwargs.get('overprinted', [])
         overprinted_faults = []
@@ -1083,7 +1187,9 @@ class GeologicalModel:
             fault_frame[0].add_region(lambda pos: kwargs['abut'].evaluate(pos))
 
         fault = FaultSegment(fault_frame, displacement=displacement_scaled,
+                             faultfunction=faultfunction,
                              **kwargs)
+        fault.builder=fault_frame_builder
         for f in reversed(self.features):
             if f.type == 'unconformity':
                 fault.add_region(lambda pos: f.evaluate_value(pos) <= 0)
@@ -1132,10 +1238,14 @@ class GeologicalModel:
         points : np.array((N,3),dtype=double)
 
         """
+        points = np.array(points).astype(float)
         if inplace==False:
             points = points.copy()
-
-        points[:, :] -= self.origin
+        # if len(points.shape) == 1:
+        #     points = points[None,:]
+        # if len(points.shape) != 2:
+        #     logger.error("cannot scale array of dimensions".format(len(points.shape)))
+        points -= self.origin
         points /= self.scale_factor
         return points
 
@@ -1216,10 +1326,13 @@ class GeologicalModel:
         >>> model.evaluate_model(xyz)
         
         """
+        xyz = np.array(xyz)
         if scale:
             xyz = self.scale(xyz,inplace=False)
         strat_id = np.zeros(xyz.shape[0],dtype=int)
         for group in self.stratigraphic_column.keys():
+            if group == 'faults':
+                continue
             feature_id = self.feature_name_index.get(group, -1)
             if feature_id >= 0:
                 feature = self.features[feature_id]
@@ -1276,6 +1389,7 @@ class GeologicalModel:
         if feature_index > -1:
             return self.features[feature_index]
         else:
+            logger.error("{} does not exist!".format(feature_name))
             return None
 
     def evaluate_feature_value(self, feature_name, xyz, scale=True):
@@ -1349,3 +1463,42 @@ class GeologicalModel:
             return feature.evaluate_gradient(scaled_xyz)
         else:
             return np.zeros(xyz.shape[0])
+
+    def update(self,verbose=False,progressbar=True):
+        total_dof = 0
+        nfeatures = 0
+        for f in self.features:
+            if f.type=='fault':
+                nfeatures+=3
+                total_dof+=f[0].interpolator.nx*3
+            if f.type == 'series':
+                nfeatures+=1
+                total_dof+=f.interpolator.nx
+        if verbose==True:
+            print('Updating geological model. There are: \n'
+            '{} geological features that need to be interpolated\n'.format(nfeatures)
+            )
+        
+        from tqdm.auto import tqdm
+        import time
+        start = time.time()
+        sizecounter = 0
+        
+        # Load tqdm with size counter instead of file counter
+        with tqdm(total=nfeatures) as pbar:
+            buf=0
+            for f in self.features:
+                pbar.set_description('Interpolating {}'.format(f.name))
+                if f.type == 'fault':
+                    for i in range(3):
+                        buf+=1
+                        f[i].builder.update()
+                        pbar.update()
+                if f.type == 'series':
+                    f.builder.update()
+                    pbar.update()
+
+            
+        if verbose:
+            print("Model update took: {} seconds".format(time.time()-start))
+