LoopStructural 1.0.3__zip → 1.0.71.dev0__zip

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

@@ -1,8 +1,10 @@
+"""
+Main entry point for creating a geological model
+"""
 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
@@ -11,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,
@@ -62,12 +55,30 @@ def _calculate_average_intersection(series_builder, fold_frame, fold,
 
 class GeologicalModel:
     """
-    A geological model is the recipe for building a 3D model and includes
-    the rescaling
-    of the model between 0 and 1.
+    A geological model is the recipe for building a 3D model and  can include
+    the rescaling of the model between 0 and 1.
+
+    Attributes
+    ----------
+    features : list
+        Contains all features youngest to oldest
+    feature_name_index : dict
+        maps feature name to the list index of the features
+    data : pandas dataframe
+        the dataframe used for building the geological model
+    nsteps : tuple/np.array(3,dtype=int)
+        the number of steps x,y,z to evaluate the model
+    origin : tuple/np.array(3,dtype=doubles)
+        the origin of the model box
+    parameters : dict
+        a dictionary tracking the parameters used to build the model
+    scale_factor : double
+        the scale factor used to rescale the model
+
+
     """
     def __init__(self, origin, maximum, rescale=True, nsteps=(40, 40, 40),
-                 reuse_supports=False):
+                 reuse_supports=False, logfile=None, loglevel='info'):
         """
         Parameters
         ----------
@@ -78,41 +89,91 @@ class GeologicalModel:
         rescale : bool
             whether to rescale the model to between 0/1
 
+        Examples
+        --------
+        Demo data
+        
+        >>> from LoopStructural.datasets import load_claudius
+        >>> from LoopStructural import GeologicalModel
+        
+        >>> data, bb = load_claudius()
+        
+        >>> model = GeologicalModel(bb[:,0],bb[:,1] 
+        >>> model.set_model_data(data)
+        >>> model.create_and_add_foliation('strati')
+        
+        >>> y = np.linspace(model.bounding_box[0, 1], model.bounding_box[1, 1],
+                        nsteps[1])
+        >>> z = np.linspace(model.bounding_box[1, 2], model.bounding_box[0, 2],
+                        nsteps[2])
+        >>> xx, yy, zz = np.meshgrid(x, y, z, indexing='ij')
+        >>> xyz = np.array([xx.flatten(), yy.flatten(), zz.flatten()]).T
+        >>> model.evaluate_feature_value('strati',xyz,scale=False)
+
+
         """
+        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
         ----------
@@ -124,12 +185,26 @@ class GeologicalModel:
         (GeologicalModel, dict)
             the created geological model and a dictionary of the map2loop data
         """
-        from LoopStructural.utils import process_map2loop, build_model
-        m2l_data = process_map2loop(m2l_directory)
+        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
 
     @classmethod
     def from_file(cls, file):
+        """Load a geological model from file
+
+        Parameters
+        ----------
+        file : string
+            path to the file
+
+        Returns
+        -------
+        GeologicalModel
+            the geological model object
+        """        
         try:
             import dill as pickle
         except ImportError:
@@ -137,18 +212,49 @@ 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
+
+        Parameters
+        ----------
+        file : string
+            path to file location
+        """        
         try:
             import dill as pickle
         except ImportError:
-            logger.error("Cannot write to file, dill not installed")
+            logger.error("Cannot write to file, dill not installed \n"
+                        "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')
@@ -169,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" % (
@@ -176,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
@@ -204,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]
@@ -213,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:
@@ -224,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(
@@ -255,14 +366,14 @@ class GeologicalModel:
         data_temp['Z'] /= self.scale_factor
         self.data.concat([self.data, data_temp], sort=True)
 
-    def set_stratigraphic_column(self, stratigraphic_column):
+    def set_stratigraphic_column(self, stratigraphic_column,cmap='tab20'):
         """
         Adds a stratigraphic column to the model
 
         Parameters
         ----------
         stratigraphic_column : dictionary
-
+        cmap : matplotlib.cmap
         Returns
         -------
 
@@ -271,14 +382,46 @@ class GeologicalModel:
         stratigraphic_column is a nested dictionary with the format
         {'group':
                 {'series1':
-                            {'min':0., 'max':10.,'id':0}
+                            {'min':0., 'max':10.,'id':0,'colour':}
                 }
         }
 
         """
+        # 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():
+            for u in stratigraphic_column[g].keys():
+                if 'colour' in stratigraphic_column[g][u]:
+                    random_colour = False
+                    break
+                n_units+=1
+        if random_colour:
+            import matplotlib.cm as cm
+            cmap = cm.get_cmap(cmap,n_units)
+            cmap_colours = cmap.colors
+            ci = 0
+            for g in stratigraphic_column.keys():
+                for u in stratigraphic_column[g].keys():
+                    stratigraphic_column[g][u]['colour'] = cmap_colours[ci,:]
+        
         self.stratigraphic_column = stratigraphic_column
 
     def create_from_feature_list(self, features):
+        """Initialises a model from a dictionary containing the features
+
+        Parameters
+        ----------
+        features : [type]
+            [description]
+
+        Raises
+        ------
+        LoopBaseException
+            [description]
+        """        
         for f in features:
             featuretype = f.pop('featuretype', None)
             if featuretype is None:
@@ -291,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
@@ -323,51 +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
@@ -376,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)
@@ -397,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,
@@ -411,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
@@ -432,8 +641,9 @@ 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})
-        result = {}
         # create fault frame
         interpolator = self.get_interpolator(**kwargs)
         #
@@ -455,16 +665,18 @@ 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
 
         Parameters
         ----------
-        foliation_data : string
+        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
 
@@ -473,13 +685,15 @@ 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:
             logger.info("Using last feature as fold frame")
             fold_frame = self.features[-1]
         assert type(fold_frame) == FoldFrame, "Please specify a FoldFrame"
-        fold = FoldEvent(fold_frame)
+        fold = FoldEvent(fold_frame,name='Fold_{}'.format(foliation_data))
         fold_interpolator = self.get_interpolator("DFI", fold=fold, **kwargs)
         series_builder = GeologicalFeatureInterpolator(
             interpolator=fold_interpolator,
@@ -488,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
@@ -508,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)
@@ -541,8 +760,10 @@ class GeologicalModel:
         Parameters
         ----------
         fold_frame_data : string
+            name of the feature to be added
 
-        fold_frame : StructuralFrame
+        fold_frame : StructuralFrame, optional
+            the fold frame for the fold if not specified uses last feature added
 
         kwargs
 
@@ -551,16 +772,20 @@ 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:
             logger.info("Using last feature as fold frame")
             fold_frame = self.features[-1]
         assert type(fold_frame) == FoldFrame, "Please specify a FoldFrame"
-        fold = FoldEvent(fold_frame)
+        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)
@@ -569,13 +794,18 @@ 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']
         if "av_fold_axis" in kwargs:
+            logger.info("Using average intersection lineation for \n"
+            "fold axis")
             _calculate_average_intersection(fold_frame_builder[0], fold_frame,
                                             fold)
 
         if fold.fold_axis is None:
+            logger.info("Fitting fold axis rotation angle")
             far, fad = fold_frame.calculate_fold_axis_rotation(
                 fold_frame_builder[0])
             fold_axis_rotation = FoldRotationAngle(far, fad)
@@ -600,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])
@@ -622,12 +851,14 @@ class GeologicalModel:
         return fold_frame
 
     def _add_faults(self, feature_builder, features=None):
-        """
-
+        """Adds all existing faults to a geological feature builder 
+        
         Parameters
         ----------
-        feature_builder
-
+        feature_builder : GeologicalFeatureInterpolator/StructuralFrameBuilder
+            The feature buider to add the faults to
+        features : list, optional
+            A specific list of features rather than all features in the model
         Returns
         -------
 
@@ -736,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(
@@ -752,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
@@ -852,24 +1087,41 @@ 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)
 
-        # uc_feature = UnconformityFeature(uc_feature_base,0)
+        domain_fault_uc = UnconformityFeature(domain_fault,0)
         # iterate over existing features and add the unconformity as a
         # region so the feature is only
         # evaluated where the unconformity is positive
-        return domain_fault
-
-    def create_and_add_fault(self, fault_surface_data, displacement, **kwargs):
+        return domain_fault_uc
+
+    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
@@ -879,98 +1131,65 @@ 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:
-            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['nx'])
-            vectors = fault_frame_data[mask][['nx', 'ny', 'nz']].to_numpy()
-            lengths = np.linalg.norm(vectors, axis=1)
-            vectors /= lengths[:, None]
-            fault_frame_data.loc[mask, ['nx', 'ny', 'nz']] = 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]
-            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', [])
-        self._add_faults(fault_frame_builder[0],overprinted)
-        self._add_faults(fault_frame_builder[1],overprinted)
-        self._add_faults(fault_frame_builder[2],overprinted)
+        overprinted_faults = []
+        for o in overprinted:
+            overprinted_faults.append(self.features[self.feature_name_index[o]])
+        self._add_faults(fault_frame_builder[0],overprinted_faults)
+        self._add_faults(fault_frame_builder[1],overprinted_faults)
+        self._add_faults(fault_frame_builder[2],overprinted_faults)
 
         fault_frame = fault_frame_builder.build(**kwargs)
         if 'abut' in kwargs:
             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)
@@ -982,50 +1201,54 @@ class GeologicalModel:
 
         return fault
 
-    def rescale(self, points):
+    def rescale(self, points, inplace=True):
         """
         Convert from model scale to real world scale - in the future this
         should also do transformations?
 
         Parameters
         ----------
-        points
+        points : np.array((N,3),dtype=double)
+        inplace : boolean
+            whether to return a modified copy or modify the original array
 
         Returns
         -------
+        points : np.array((N,3),dtype=double)
+
         """
+        if inplace == False:
+            points = points.copy()
         points *= self.scale_factor
         points += self.origin
         return points
 
-    def scale(self, points):
-        """
+    def scale(self, points, inplace=True):
+        """ Take points in UTM coordinates and reproject
+        into scaled model space
+
         Parameters
         ----------
         points : np.array((N,3),dtype=float)
             points to 
-
+        inplace : bool, optional default = True
+            whether to copy the points array or update the passed array
         Returns
         -------
+        points : np.array((N,3),dtype=double)
+
         """
-        points = points.copy()
-        points[:, :] -= self.origin
+        points = np.array(points).astype(float)
+        if inplace==False:
+            points = points.copy()
+        # 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
 
-    def voxet(self, nsteps=(50, 50, 25)):
-        """
-        Returns a voxet dict with the nsteps specified
-
-        Parameters
-        ----------
-        nsteps : tuple
-            number of cells in
-
-        Returns
-        -------
-        """
-        return {'bounding_box': self.bounding_box, 'nsteps': nsteps}
 
     def regular_grid(self, nsteps=(50, 50, 25), shuffle = True, rescale=False):
         """
@@ -1050,12 +1273,13 @@ class GeologicalModel:
         xx, yy, zz = np.meshgrid(x, y, z, indexing='ij')
         locs = np.array([xx.flatten(), yy.flatten(), zz.flatten()]).T
         if shuffle:
+            logger.info("Shuffling points")
             np.random.shuffle(locs)
         if rescale:
             locs = self.rescale(locs)
         return locs
 
-    def evaluate_model(self, xyz, rescale=True):
+    def evaluate_model(self, xyz, scale=True):
         """Evaluate the stratigraphic id at each location
         
 
@@ -1063,8 +1287,8 @@ class GeologicalModel:
         ----------
         xyz : np.array((N,3),dtype=float)
             locations
-        rescale : bool
-            whether to rescale the model
+        scale : bool
+            whether to rescale the xyz before evaluating model
 
         Returns
         -------
@@ -1075,11 +1299,11 @@ class GeologicalModel:
         --------
         Evaluate on a voxet
 
-        >>> x = np.linspace(self.bounding_box[0, 0], self.bounding_box[1, 0],
+        >>> x = np.linspace(model.bounding_box[0, 0], model.bounding_box[1, 0],
                         nsteps[0])
-        >>> y = np.linspace(self.bounding_box[0, 1], self.bounding_box[1, 1],
+        >>> y = np.linspace(model.bounding_box[0, 1], model.bounding_box[1, 1],
                         nsteps[1])
-        >>> z = np.linspace(self.bounding_box[1, 2], self.bounding_box[0, 2],
+        >>> z = np.linspace(model.bounding_box[1, 2], model.bounding_box[0, 2],
                         nsteps[2])
         >>> xx, yy, zz = np.meshgrid(x, y, z, indexing='ij')
         >>> xyz = np.array([xx.flatten(), yy.flatten(), zz.flatten()]).T
@@ -1102,8 +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]
@@ -1114,6 +1343,31 @@ class GeologicalModel:
                 logger.error('Model does not contain {}'.format(group))
         return strat_id
 
+    def evaluate_fault_displacements(self,points,scale=True):
+        """Evaluate the fault displacement magnitude at each location
+        
+
+        Parameters
+        ----------
+        xyz : np.array((N,3),dtype=float)
+            locations
+        scale : bool
+            whether to rescale the xyz before evaluating model
+
+        Returns
+        -------
+        fault_displacement : np.array(N,dtype=float)
+            the fault displacement magnitude
+        """
+        if scale:
+            points = self.scale(points,inplace=False)
+        vals = np.zeros(points.shape[0])
+        for f in self.features:
+            if f.type == 'fault':
+                disp = f.displacementfeature.evaluate_value(points)
+                vals[~np.isnan(disp)] += disp[~np.isnan(disp)]
+        return vals*-self.scale_factor # convert from restoration magnutude to displacement
+
     def get_feature_by_name(self, feature_name):
         """Returns a feature from the mode given a name
 
@@ -1127,11 +1381,15 @@ class GeologicalModel:
         -------
         feature : GeologicalFeature
             the geological feature with the specified name, or none if no feature
+
+        
+
         """
         feature_index = self.feature_name_index.get(feature_name,-1)
-        if feature_index >0:
+        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):
@@ -1151,11 +1409,31 @@ class GeologicalModel:
         -------
         np.array((N))
             vector of scalar values
+
+        Examples
+        --------
+        Evaluate on a voxet using model boundaries
+
+        >>> x = np.linspace(model.bounding_box[0, 0], model.bounding_box[1, 0],
+                        nsteps[0])
+        >>> y = np.linspace(model.bounding_box[0, 1], model.bounding_box[1, 1],
+                        nsteps[1])
+        >>> z = np.linspace(model.bounding_box[1, 2], model.bounding_box[0, 2],
+                        nsteps[2])
+        >>> xx, yy, zz = np.meshgrid(x, y, z, indexing='ij')
+        >>> xyz = np.array([xx.flatten(), yy.flatten(), zz.flatten()]).T
+        >>> model.evaluate_feature_vaue('feature',xyz,scale=False)
+
+        Evaluate on points in UTM coordinates 
+    
+        >>> model.evaluate_feature_vaue('feature',utm_xyz)
+        
         """
         feature  = self.get_feature_by_name(feature_name)
         if feature:
+            scaled_xyz = xyz
             if scale:
-                scaled_xyz = self.scale(xyz)
+                scaled_xyz = self.scale(xyz,inplace=False)
             return feature.evaluate_value(scaled_xyz)
         else:
             return np.zeros(xyz.shape[0])
@@ -1179,8 +1457,48 @@ class GeologicalModel:
         """
         feature  = self.get_feature_by_name(feature_name)
         if feature:
+            scaled_xyz = xyz
             if scale:
-                scaled_xyz = self.scale(xyz)
+                scaled_xyz = self.scale(xyz, inplace = False)
             return feature.evaluate_gradient(scaled_xyz)
         else:
-            return np.zeros(xyz.shape[0])    
+            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))
+