LoopStructural 1.6.6__py3-none-any.whl → 1.6.8__py3-none-any.whl

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

@@ -338,7 +338,7 @@ class BaseFeature(metaclass=ABCMeta):
         )
         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 +359,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,8 +39,7 @@ class GeologicalFeature(BaseFeature):
     def __init__(
         self,
         name: str,
-        interpolator: GeologicalInterpolator,
-        builder=None,
+        builder,
         regions: list = [],
         faults: list = [],
         model=None,
@@ -61,8 +59,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 None
         self.type = FeatureType.INTERPOLATED
 
     def to_json(self):
@@ -262,7 +260,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,

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)

LoopStructural/modelling/features/builders/_structural_frame_builder.py

@@ -120,7 +120,12 @@ class StructuralFrameBuilder:
             model=self.model,
         )
         self._frame.builder = self
-
+    @property
+    def build_arguments(self):
+        return self.builders[0].build_arguments
+    def update_build_arguments(self, kwargs):
+        for i in range(3):
+            self.builders[i].update_build_arguments(kwargs)
     @property
     def frame(self):
         return self._frame
@@ -197,7 +202,7 @@ class StructuralFrameBuilder:
         if len(self.builders[0].data) > 0:
             logger.info(f"Building {self.name} coordinate 0")
             kwargs["regularisation"] = regularisation[0]
-            self.builders[0].build_arguments = kwargs
+            self.builders[0].update_build_arguments(kwargs)
             kwargs.pop("fold", None)
 
         # make sure that all of the coordinates are using the same region
@@ -206,7 +211,7 @@ class StructuralFrameBuilder:
             if w2 > 0:
                 self.builders[2].add_orthogonal_feature(self.builders[0].feature, w2, step=step)
             kwargs["regularisation"] = regularisation[2]
-            self.builders[2].build_arguments = kwargs
+            self.builders[2].update_build_arguments(kwargs)
 
         if len(self.builders[1].data) > 0:
             logger.info(f"Building {self.name} coordinate 1")
@@ -215,7 +220,7 @@ class StructuralFrameBuilder:
             if w3 > 0 and len(self.builders[2].data) > 0:
                 self.builders[1].add_orthogonal_feature(self.builders[2].feature, w2, step=step)
             kwargs["regularisation"] = regularisation[1]
-            self.builders[1].build_arguments = kwargs
+            self.builders[1].update_build_arguments(kwargs)
 
         if len(self.builders[2].data) == 0:
             from LoopStructural.modelling.features import (

LoopStructural/modelling/features/fault/_fault_segment.py

@@ -270,7 +270,7 @@ class FaultSegment(StructuralFrame):
         v[mask, :] = self.__getitem__(1).evaluate_gradient(locations[mask, :])
         v[mask, :] /= np.linalg.norm(v[mask, :], axis=1)[:, None]
         scale = self.displacementfeature.evaluate_value(locations[mask, :])
-        v[mask, :] *= scale[:, None]
+        v[mask, :] *= scale[:, None] * self.displacement
         return v
 
     def evaluate_displacement(self, points):

LoopStructural/modelling/features/fold/__init__.py

@@ -1,6 +1,4 @@
-"""
-
-"""
+""" """
 
 from ._fold import FoldEvent
 from ._svariogram import SVariogram

LoopStructural/modelling/features/fold/fold_function/_base_fold_rotation_angle.py

@@ -12,7 +12,6 @@ logger = getLogger(__name__)
 
 
 class BaseFoldRotationAngleProfile(metaclass=ABCMeta):
-
     def __init__(
         self,
         rotation_angle: Optional[npt.NDArray[np.float64]] = None,

LoopStructural/modelling/features/fold/fold_function/_lambda_fold_rotation_angle.py

@@ -8,7 +8,6 @@ logger = getLogger(__name__)
 
 
 class LambdaFoldRotationAngleProfile(BaseFoldRotationAngleProfile):
-
     def __init__(
         self,
         fn: Callable[[np.ndarray], np.ndarray],

LoopStructural/modelling/features/fold/fold_function/_trigo_fold_rotation_angle.py

@@ -8,7 +8,6 @@ logger = getLogger(__name__)
 
 
 class TrigoFoldRotationAngleProfile(BaseFoldRotationAngleProfile):
-
     def __init__(
         self,
         rotation_angle: Optional[npt.NDArray[np.float64]] = None,

LoopStructural/modelling/input/process_data.py

@@ -78,7 +78,9 @@ class ProcessInputData:
         self.contacts = contacts
         self._contact_orientations = None
         self.contact_orientations = contact_orientations
-        self._fault_orientations = None
+        self._fault_orientations = pd.DataFrame(
+            columns=["X", "Y", "Z", "gx", "gy", "gz", "coord", "feature_name"]
+        )
         self.fault_orientations = fault_orientations
         self._fault_locations = None
         self.fault_locations = fault_locations
@@ -313,10 +315,11 @@ class ProcessInputData:
                 pts = self.fault_orientations.loc[
                     self.fault_orientations["feature_name"] == fname, ["gx", "gy", "gz"]
                 ]
-                fault_properties.loc[
-                    fname,
-                    ["avgNormalEasting", "avgNormalNorthing", "avgNormalAltitude"],
-                ] = np.nanmean(pts, axis=0)
+                if len(pts) > 0:
+                    fault_properties.loc[
+                        fname,
+                        ["avgNormalEasting", "avgNormalNorthing", "avgNormalAltitude"],
+                    ] = np.nanmean(pts, axis=0)
         if (
             "avgSlipDirEasting" not in fault_properties.columns
             or "avgSlipDirNorthing" not in fault_properties.columns
@@ -399,7 +402,7 @@ class ProcessInputData:
             dataframes.append(self.contacts)
         if self.contact_orientations is not None:
             dataframes.append(self.contact_orientations)
-        if self.fault_orientations is not None:
+        if len(self.fault_orientations) > 0:
             dataframes.append(self.fault_orientations)
         if self.fault_locations is not None:
             dataframes.append(self.fault_locations)

LoopStructural/utils/_surface.py

@@ -63,7 +63,7 @@ class LoopIsosurfacer:
         self,
         values: Optional[Union[list, int, float]],
         name: Optional[Union[List[str], str]] = None,
-        local=False
+        local=False,
     ) -> surface_list:
         """Extract isosurfaces from the interpolator
 
@@ -89,7 +89,7 @@ class LoopIsosurfacer:
             raise ValueError("No interpolator of callable function set")
 
         surfaces = []
-        all_values = self.callable(self.bounding_box.regular_grid(local=local))
+        all_values = self.callable(self.bounding_box.regular_grid(local=local, order='C'))
         ## set value to mean value if its not specified
         if values is None:
             values = [((np.nanmax(all_values) - np.nanmin(all_values)) / 2) + np.nanmin(all_values)]