LoopStructural 1.6.7__py3-none-any.whl → 1.6.9__py3-none-any.whl

LoopStructural/interpolators/_interpolator_builder.py

@@ -1,55 +1,134 @@
 from LoopStructural.interpolators import (
-    GeologicalInterpolator,
     InterpolatorFactory,
     InterpolatorType,
 )
 from LoopStructural.datatypes import BoundingBox
-from typing import Optional, Union
+from typing import  Union, Optional
 import numpy as np
 
+from LoopStructural.interpolators._geological_interpolator import GeologicalInterpolator
+
 
 class InterpolatorBuilder:
     def __init__(
         self,
         interpolatortype: Union[str, InterpolatorType],
         bounding_box: BoundingBox,
-        nelements: int = 1000,
-        buffer: float = 0.2,
+        nelements: Optional[int] = None,
+        buffer: Optional[float] = None,
         **kwargs,
     ):
+        """This class helps initialise and setup a geological interpolator.
+
+        Parameters
+        ----------
+        interpolatortype : Union[str, InterpolatorType]
+            type of interpolator
+        bounding_box : BoundingBox
+            bounding box of the area to interpolate
+        nelements : int, optional
+            degrees of freedom of the interpolator, by default 1000
+        buffer : float, optional
+            how much of a buffer around the bounding box should be used, by default 0.2
+        """
         self.interpolatortype = interpolatortype
         self.bounding_box = bounding_box
         self.nelements = nelements
         self.buffer = buffer
         self.kwargs = kwargs
-        self.interpolator : Optional[GeologicalInterpolator]= None
-
-    def create_interpolator(self) -> 'InterpolatorBuilder':
         self.interpolator = InterpolatorFactory.create_interpolator(
-            interpolatortype=self.interpolatortype,
-            boundingbox=self.bounding_box,
-            nelements=self.nelements,
-            buffer=self.buffer,
-            **self.kwargs,
-        )
-        return self
+                    interpolatortype=self.interpolatortype,
+                    boundingbox=self.bounding_box,
+                    nelements=self.nelements,
+                    buffer=self.buffer,
+                    **self.kwargs,
+                )
 
-    def set_value_constraints(self, value_constraints: np.ndarray) -> 'InterpolatorBuilder':
+    def add_value_constraints(self, value_constraints: np.ndarray) -> 'InterpolatorBuilder':
+        """Add value constraints to the interpolator
+
+        Parameters
+        ----------
+        value_constraints : np.ndarray
+            x,y,z,value of the constraints
+
+        Returns
+        -------
+        InterpolatorBuilder
+            reference to the builder 
+        """
         if self.interpolator:
             self.interpolator.set_value_constraints(value_constraints)
         return self
 
-    def set_gradient_constraints(self, gradient_constraints: np.ndarray) -> 'InterpolatorBuilder':
+    def add_gradient_constraints(self, gradient_constraints: np.ndarray) -> 'InterpolatorBuilder':
+        """Add gradient constraints to the interpolator
+        Where g1 and g2 are two vectors that are orthogonal to the gradient
+        $'(X)\cdot g1 = 0$ and $'(X)\cdot g2 = 0$
+
+        Parameters
+        ----------
+        gradient_constraints : np.ndarray
+            x,y,z,gradient_x,gradient_y,gradient_z of the constraints
+
+        Returns
+        -------
+        InterpolatorBuilder
+            reference to the builder
+        """
+
         if self.interpolator:
             self.interpolator.set_gradient_constraints(gradient_constraints)
         return self
 
-    def set_normal_constraints(self, normal_constraints: np.ndarray) -> 'InterpolatorBuilder':
+    def add_normal_constraints(self, normal_constraints: np.ndarray) -> 'InterpolatorBuilder':
+        """Add normal constraints to the interpolator
+        Where n is the normal vector to the surface
+        $f'(X).dx = nx$
+        $f'(X).dy = ny$
+        $f'(X).dz = nz$
+        Parameters
+        ----------
+        normal_constraints : np.ndarray
+            x,y,z,nx,ny,nz of the constraints
+
+        Returns
+        -------
+        InterpolatorBuilder
+            reference to the builder
+        """
         if self.interpolator:
             self.interpolator.set_normal_constraints(normal_constraints)
         return self
+    #TODO implement/check inequalities
+    # def add_inequality_constraints(self, inequality_constraints: np.ndarray) -> 'InterpolatorBuilder':
+    #     if self.interpolator:
+    #         self.interpolator.set_value_inequality_constraints(inequality_constraints)
+    #     return self
+    # def add_inequality_pair_constraints(self, inequality_pair_constraints: np.ndarray) -> 'InterpolatorBuilder':
+    #     if self.interpolator:
+    #         self.interpolator.set_inequality_pairs_constraints(inequality_pair_constraints)
+    #     return self
+
+    def setup_interpolator(self, **kwargs) -> 'InterpolatorBuilder':
+        """This adds all of the constraints to the interpolator and
+        sets the regularisation constraints
 
-    def setup_interpolator(self, **kwargs) -> Optional[GeologicalInterpolator]:
+        Returns
+        -------
+        InterpolatorBuilder
+            reference to the builder
+        """
         if self.interpolator:
             self.interpolator.setup(**kwargs)
-            return self.interpolator
+        return self
+
+    def build(self)->GeologicalInterpolator:
+        """Builds the interpolator and returns it
+
+        Returns
+        -------
+        GeologicalInterpolator
+            The interpolator fitting all of the constraints provided
+        """
+        return self.interpolator

LoopStructural/interpolators/_interpolator_factory.py

@@ -18,14 +18,13 @@ class InterpolatorFactory:
         nelements: Optional[int] = None,
         element_volume: Optional[float] = None,
         support=None,
-        buffer: float = 0.2,
+        buffer: Optional[float] = None,
     ):
         if interpolatortype is None:
             raise ValueError("No interpolator type specified")
         if boundingbox is None:
             raise ValueError("No bounding box specified")
-        if nelements is None:
-            raise ValueError("No number of elements specified")
+
         if isinstance(interpolatortype, str):
             interpolatortype = interpolator_string_map[interpolatortype]
         if support is None:

LoopStructural/interpolators/_surfe_wrapper.py

@@ -35,6 +35,9 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
     def set_region(self, **kwargs):
         pass
 
+    def set_nelements(self, nelements) -> int:
+        return 0
+
     def add_gradient_constraints(self, w=1):
         points = self.get_gradient_constraints()
         if points.shape[0] > 0:

LoopStructural/interpolators/supports/_2d_base_unstructured.py

@@ -68,6 +68,9 @@ class BaseUnstructured2d(BaseSupport):
             _initialise_aabb(self)
         return self._aabb_table
 
+    def set_nelements(self, nelements) -> int:
+        raise NotImplementedError
+
     @property
     def shared_elements(self):
         if np.sum(self._shared_elements) == 0:

LoopStructural/interpolators/supports/_2d_structured_grid.py

@@ -66,6 +66,9 @@ class StructuredGrid2D(BaseSupport):
     def n_nodes(self):
         return self.nsteps[0] * self.nsteps[1]
 
+    def set_nelements(self, nelements) -> int:
+        raise NotImplementedError("Cannot set number of elements for 2D structured grid")
+
     @property
     def n_elements(self):
         return self.nsteps_cells[0] * self.nsteps_cells[1]

LoopStructural/interpolators/supports/_3d_base_structured.py

@@ -3,6 +3,7 @@ from abc import abstractmethod
 import numpy as np
 from LoopStructural.utils import getLogger
 from . import SupportType
+from typing import Tuple
 
 logger = getLogger(__name__)
 
@@ -34,6 +35,11 @@ class BaseStructuredSupport(BaseSupport):
         # we use property decorators to update these when different parts of
         # the geometry need to change
         # inisialise the private attributes
+        # cast to numpy array, to allow list like input
+        origin = np.array(origin)
+        nsteps = np.array(nsteps)
+        step_vector = np.array(step_vector)
+
         self.type = SupportType.BaseStructured
         if np.any(step_vector == 0):
             logger.warning(f"Step vector {step_vector} has zero values")
@@ -41,10 +47,10 @@ class BaseStructuredSupport(BaseSupport):
             raise LoopException("nsteps cannot be zero")
         if np.any(nsteps < 0):
             raise LoopException("nsteps cannot be negative")
-        if np.any(nsteps < 3):
-            raise LoopException(
-                "step vector cannot be less than 3. Try increasing the resolution of the interpolator"
-            )
+        # if np.any(nsteps < 3):
+        #     raise LoopException(
+        #         "step vector cannot be less than 3. Try increasing the resolution of the interpolator"
+        #     )
         self._nsteps = np.array(nsteps, dtype=int) + 1
         self._step_vector = np.array(step_vector)
         self._origin = np.array(origin)
@@ -56,6 +62,23 @@ class BaseStructuredSupport(BaseSupport):
         self.rotation_xy = rotation_xy
         self.interpolator = None
 
+    @property
+    def volume(self):
+        return np.prod(self.maximum - self.origin)
+
+    def set_nelements(self, nelements) -> int:
+        box_vol = self.volume
+        ele_vol = box_vol / nelements
+        # calculate the step vector of a regular cube
+        step_vector = np.zeros(3)
+
+        step_vector[:] = ele_vol ** (1.0 / 3.0)
+
+        # number of steps is the length of the box / step vector
+        nsteps = np.ceil((self.maximum - self.origin) / step_vector).astype(int)
+        self.nsteps = nsteps
+        return self.n_elements
+
     def to_dict(self):
         return {
             "origin": self.origin,
@@ -229,7 +252,7 @@ class BaseStructuredSupport(BaseSupport):
         """ """
         return np.einsum("ijk,ik->ij", self.rotation_xy[None, :, :], pos)
 
-    def position_to_cell_index(self, pos: np.ndarray) -> np.ndarray:
+    def position_to_cell_index(self, pos: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
         """Get the indexes (i,j,k) of a cell
         that a point is inside
 

LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -40,6 +40,8 @@ class StructuredGrid(BaseStructuredSupport):
         self.regions["everywhere"] = np.ones(self.n_nodes).astype(bool)
 
     def onGeometryChange(self):
+        if self.interpolator is not None:
+            self.interpolator.reset()
         pass
 
     @property

LoopStructural/interpolators/supports/_3d_unstructured_tetra.py

@@ -61,19 +61,24 @@ class UnStructuredTetMesh(BaseSupport):
         length = self.maximum - self.minimum
         self.minimum -= length * 0.1
         self.maximum += length * 0.1
-        if aabb_nsteps is None:
-            box_vol = np.prod(self.maximum - self.minimum)
-            element_volume = box_vol / (len(self.elements) / 20)
-            # calculate the step vector of a regular cube
-            step_vector = np.zeros(3)
-            step_vector[:] = element_volume ** (1.0 / 3.0)
-            # number of steps is the length of the box / step vector
-            aabb_nsteps = np.ceil((self.maximum - self.minimum) / step_vector).astype(int)
-            # make sure there is at least one cell in every dimension
-            aabb_nsteps[aabb_nsteps < 2] = 2
-        aabb_nsteps = np.array(aabb_nsteps, dtype=int)
-        step_vector = (self.maximum - self.minimum) / (aabb_nsteps - 1)
-        self.aabb_grid = StructuredGrid(self.minimum, nsteps=aabb_nsteps, step_vector=step_vector)
+        if self.elements.shape[0] < 2000:
+            self.aabb_grid = StructuredGrid(self.minimum, nsteps=[2, 2, 2], step_vector=[1, 1, 1])
+        else:
+            if aabb_nsteps is None:
+                box_vol = np.prod(self.maximum - self.minimum)
+                element_volume = box_vol / (len(self.elements) / 20)
+                # calculate the step vector of a regular cube
+                step_vector = np.zeros(3)
+                step_vector[:] = element_volume ** (1.0 / 3.0)
+                # number of steps is the length of the box / step vector
+                aabb_nsteps = np.ceil((self.maximum - self.minimum) / step_vector).astype(int)
+                # make sure there is at least one cell in every dimension
+                aabb_nsteps[aabb_nsteps < 2] = 2
+            aabb_nsteps = np.array(aabb_nsteps, dtype=int)
+            step_vector = (self.maximum - self.minimum) / (aabb_nsteps - 1)
+            self.aabb_grid = StructuredGrid(
+                self.minimum, nsteps=aabb_nsteps, step_vector=step_vector
+            )
         # make a big table to store which tetra are in which element.
         # if this takes up too much memory it could be simplified by using sparse matrices or dict but
         # at the expense of speed
@@ -87,6 +92,9 @@ class UnStructuredTetMesh(BaseSupport):
         self._init_face_table()
         self._initialise_aabb()
 
+    def set_nelements(self, nelements):
+        raise NotImplementedError("Cannot set number of elements for unstructured mesh")
+
     @property
     def nodes(self):
         return self._nodes

LoopStructural/interpolators/supports/_base_support.py

@@ -119,3 +119,7 @@ class BaseSupport(metaclass=ABCMeta):
         Return a vtk object
         """
         pass
+
+    @abstractmethod
+    def set_nelements(self, nelements) -> int:
+        pass

LoopStructural/interpolators/supports/_support_factory.py

@@ -1,4 +1,6 @@
 from LoopStructural.interpolators.supports import support_map, SupportType
+import numpy as np
+from typing import Optional
 
 
 class SupportFactory:
@@ -20,13 +22,19 @@ class SupportFactory:
 
     @staticmethod
     def create_support_from_bbox(
-        support_type, bounding_box, nelements, element_volume=None, buffer: float = 0.2
+        support_type, bounding_box, nelements, element_volume=None, buffer: Optional[float] = None
     ):
         if isinstance(support_type, str):
             support_type = SupportType._member_map_[support_type].numerator
-        bbox = bounding_box.with_buffer(buffer=buffer)
-        bbox.nelements = nelements
+        if buffer is not None:
+            bounding_box = bounding_box.with_buffer(buffer=buffer)
+        if element_volume is not None:
+            nelements = int(np.prod(bounding_box.length) / element_volume)
+        if nelements is not None:
+            bounding_box.nelements = nelements
 
         return support_map[support_type](
-            origin=bbox.origin, step_vector=bbox.step_vector, nsteps=bbox.nsteps
+            origin=bounding_box.origin,
+            step_vector=bounding_box.step_vector,
+            nsteps=bounding_box.nsteps,
         )

LoopStructural/modelling/core/geological_model.py

@@ -711,11 +711,10 @@ class GeologicalModel:
         # build feature
         # series_feature = series_builder.build(**kwargs)
         series_feature = series_builder.feature
-        series_builder.build_arguments = kwargs
+        series_builder.update_build_arguments(kwargs | {"domain": True, 'tol': tol})
         # this support is built for the entire model domain? Possibly would
         # could just pass a regular grid of points - mask by any above unconformities??
-        series_builder.build_arguments['domain'] = True
-        series_builder.build_arguments["tol"] = tol
+
         series_feature.type = FeatureType.INTERPOLATED
         self._add_feature(series_feature)
         return series_feature
@@ -850,7 +849,7 @@ class GeologicalModel:
 
         # series_feature = series_builder.build(**kwargs)
         series_feature = series_builder.feature
-        series_builder.build_arguments = kwargs
+        series_builder.update_build_arguments(kwargs)
         series_feature.type = FeatureType.INTERPOLATED
         series_feature.fold = fold
 
@@ -1264,7 +1263,7 @@ class GeologicalModel:
         # build feature
         # domain_fault = domain_fault_feature_builder.build(**kwargs)
         domain_fault = domain_fault_feature_builder.feature
-        domain_fault_feature_builder.build_arguments = kwargs
+        domain_fault_feature_builder.update_build_arguments(kwargs)
         domain_fault.type = FeatureType.DOMAINFAULT
         self._add_feature(domain_fault)
         self._add_domain_fault_below(domain_fault)
@@ -1809,7 +1808,7 @@ class GeologicalModel:
         grid = self.bounding_box.structured_grid(name=name)
 
         grid.cell_properties['stratigraphy'] = self.evaluate_model(
-            self.rescale(self.bounding_box.cell_centers())
+            self.rescale(self.bounding_box.cell_centres())
         )
         return grid, self.stratigraphic_ids()
 

LoopStructural/modelling/features/_base_geological_feature.py

@@ -334,11 +334,17 @@ class BaseFeature(metaclass=ABCMeta):
             bounding_box = self.model.bounding_box
         grid = bounding_box.structured_grid(name=self.name)
         value = self.evaluate_value(
-            self.model.scale(bounding_box.regular_grid(local=False, order='F'))
+            bounding_box.regular_grid(local=False, order='F')
         )
+        if self.model is not None:
+
+            value = self.evaluate_value(
+                self.model.scale(bounding_box.regular_grid(local=False, order='F'))
+            )
+
         grid.properties[self.name] = value
 
-        value = self.evaluate_value(bounding_box.cell_centers(order='F'))
+        value = self.evaluate_value(bounding_box.cell_centres(order='F'))
         grid.cell_properties[self.name] = value
         return grid
 
@@ -359,7 +365,7 @@ class BaseFeature(metaclass=ABCMeta):
             if self.model is None:
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
-        points = bounding_box.cell_centers()
+        points = bounding_box.cell_centres()
         value = self.evaluate_gradient(points)
         if self.model is not None:
             points = self.model.rescale(points)

LoopStructural/modelling/features/_cross_product_geological_feature.py

@@ -1,5 +1,4 @@
-"""
-"""
+""" """
 
 import numpy as np
 from typing import Optional

LoopStructural/modelling/features/_geological_feature.py

@@ -6,7 +6,6 @@ from LoopStructural.utils.maths import regular_tetraherdron_for_points, gradient
 from ...modelling.features import BaseFeature
 from ...utils import getLogger
 from ...modelling.features import FeatureType
-from ...interpolators import GeologicalInterpolator
 import numpy as np
 from typing import Optional, List, Union
 from ...datatypes import ValuePoints, VectorPoints
@@ -40,10 +39,10 @@ class GeologicalFeature(BaseFeature):
     def __init__(
         self,
         name: str,
-        interpolator: GeologicalInterpolator,
-        builder=None,
+        builder,
         regions: list = [],
         faults: list = [],
+        interpolator=None,
         model=None,
     ):
         """Default constructor for geological feature
@@ -61,8 +60,8 @@ class GeologicalFeature(BaseFeature):
         """
         BaseFeature.__init__(self, name, model, faults, regions, builder)
         self.name = name
-        self.interpolator = interpolator
         self.builder = builder
+        self.interpolator = self.builder.interpolator if self.builder is not None else interpolator
         self.type = FeatureType.INTERPOLATED
 
     def to_json(self):
@@ -262,7 +261,6 @@ class GeologicalFeature(BaseFeature):
             regions=[],  # feature.regions.copy(),  # don't want to share regionsbetween unconformity and # feature.regions,
             builder=self.builder,
             model=self.model,
-            interpolator=self.interpolator,
         )
         return feature
 

LoopStructural/modelling/features/_lambda_geological_feature.py

@@ -12,7 +12,6 @@ logger = getLogger(__name__)
 
 
 class LambdaGeologicalFeature(BaseFeature):
-
     def __init__(
         self,
         function: Optional[Callable[[np.ndarray], np.ndarray]] = None,
@@ -91,3 +90,14 @@ class LambdaGeologicalFeature(BaseFeature):
 
     def get_data(self, value_map: Optional[dict] = None):
         return
+
+    def copy(self, name: Optional[str] = None):
+        return LambdaGeologicalFeature(
+            self.function,
+            name if name is not None else f'{self.name}_copy',
+            self.gradient_function,
+            self.model,
+            self.regions,
+            self.faults,
+            self.builder,
+        )

LoopStructural/modelling/features/_projected_vector_feature.py

@@ -1,5 +1,4 @@
-"""
-"""
+""" """
 
 import numpy as np
 from typing import Optional

LoopStructural/modelling/features/_unconformity_feature.py

@@ -24,7 +24,6 @@ class UnconformityFeature(GeologicalFeature):
             regions=[],  # feature.regions.copy(),  # don't want to share regionsbetween unconformity and # feature.regions,
             builder=feature.builder,
             model=feature.model,
-            interpolator=feature.interpolator,
         )
         self.value = value
         self.type = FeatureType.UNCONFORMITY if onlap is False else FeatureType.ONLAPUNCONFORMITY

LoopStructural/modelling/features/builders/_base_builder.py

@@ -47,10 +47,12 @@ class BaseBuilder:
     def build_arguments(self):
         return self._build_arguments
 
-    @build_arguments.setter
-    def build_arguments(self, build_arguments):
+    def update_build_arguments(self, build_arguments):
         # self._build_arguments = {}
+        logger.info(f"Setting build arguments for {self.name}")
         for k, i in build_arguments.items():
+            logger.info(f"Setting {k} to {i} for {self.name}")
+            logger.info(f"{k} is currrently {self._build_arguments.get(k, None)}")
             if i != self._build_arguments.get(k, None):
                 logger.info(f"Setting {k} to {i} for {self.name}")
                 self._build_arguments[k] = i

LoopStructural/modelling/features/builders/_geological_feature_builder.py

@@ -25,7 +25,6 @@ from ....modelling.features.builders import BaseBuilder
 from ....utils.helper import (
     get_data_bounding_box_map as get_data_bounding_box,
 )
-from ....utils import RegionEverywhere
 from ....interpolators import DiscreteInterpolator
 from ....interpolators import InterpolatorFactory
 
@@ -39,7 +38,6 @@ class GeologicalFeatureBuilder(BaseBuilder):
         bounding_box,
         nelements: int = 1000,
         name="Feature",
-        interpolation_region=None,
         model=None,
         **kwargs,
     ):
@@ -61,7 +59,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
             nelements=nelements,
             buffer=kwargs.get("buffer", 0.2),
         )
-
+        
         if not issubclass(type(interpolator), GeologicalInterpolator):
             raise TypeError(
                 "interpolator is {} and must be a GeologicalInterpolator".format(type(interpolator))
@@ -78,21 +76,17 @@ class GeologicalFeatureBuilder(BaseBuilder):
         )
         self.data = pd.DataFrame(columns=header)
         self.data_added = False
-        self._interpolation_region = None
-        self.interpolation_region = interpolation_region
-        if self.interpolation_region is not None:
-            self._interpolator.set_region(region=self.interpolation_region)
 
         self._feature = GeologicalFeature(
             self._name,
-            self._interpolator,
             builder=self,
             regions=[],
             faults=self.faults,
         )
         self._orthogonal_features = {}
         self._equality_constraints = {}
-
+        # add default parameters
+        self.update_build_arguments({'cpw':1.0,'npw':1.0,'regularisation':1.0,'nelements':self.interpolator.n_elements})
     def set_not_up_to_date(self, caller):
         logger.info(
             f"Setting {self.name} to not up to date from an instance of {caller.__class__.__name__}"
@@ -104,20 +98,12 @@ class GeologicalFeatureBuilder(BaseBuilder):
     def interpolator(self):
         return self._interpolator
 
-    @property
-    def interpolation_region(self):
-        return self._interpolation_region
-
-    @interpolation_region.setter
-    def interpolation_region(self, interpolation_region):
-        if interpolation_region is not None:
-            self._interpolation_region = interpolation_region
-            self._interpolator.set_region(region=self._interpolation_region)
-        else:
-            self._interpolation_region = RegionEverywhere()
-            self._interpolator.set_region(region=self._interpolation_region)
-        logger.info(f'Setting interpolation region {self.name}')
-        self._up_to_date = False
+    @interpolator.setter
+    def interpolator(self, interpolator):
+        if not issubclass(type(interpolator), GeologicalInterpolator):
+            raise TypeError(
+                "interpolator is {} and must be a GeologicalInterpolator".format(type(interpolator))
+            )
 
     def add_data_from_data_frame(self, data_frame, overwrite=False):
         """
@@ -183,6 +169,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
 
         """
         if self.data_added:
+            logger.info("Data already added to interpolator")
             return
         # first move the data for the fault
         logger.info(f"Adding {len(self.faults)} faults to {self.name}")
@@ -475,7 +462,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
         is big enough to capture the faulted feature.
         """
         if self.interpolator.support is not None:
-
+            logger.info(f"Checking interpolation geometry for {self.name}")
             origin = self.interpolator.support.origin
             maximum = self.interpolator.support.maximum
             pts = self.model.bounding_box.with_buffer(buffer).regular_grid(local=True)
@@ -488,7 +475,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
             ]
             self.interpolator.support.origin = origin
             self.interpolator.support.maximum = maximum
-
+            self.update_build_arguments({'nelements':self.interpolator.n_elements})
     def build(self, data_region=None, **kwargs):
         """
         Runs the interpolation and builds the geological feature
@@ -511,6 +498,15 @@ class GeologicalFeatureBuilder(BaseBuilder):
         for f in self.faults:
             f.builder.update()
         domain = kwargs.get("domain", None)
+        if 'nelements' in kwargs:
+            # if the number of elements has changed then update the interpolator
+            logger.info(f'Interpolator has {self.interpolator.n_elements} elements')
+            logger.info(f'Kwargs has {kwargs["nelements"]} elements')
+            if self.interpolator.n_elements != kwargs['nelements']:
+                logger.info('Setting nelements to {} for {}'.format(kwargs['nelements'], self.name))
+                self.build_arguments['nelements'] = self.interpolator.set_nelements(kwargs['nelements'])
+                logger.info(f'Interpolator nelements {self.interpolator.n_elements}')
+                self._up_to_date = False
         if domain:
             self.check_interpolation_geometry(None)
         self.add_data_to_interpolator(**kwargs)