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

LoopStructural/datatypes/_bounding_box.py

@@ -410,9 +410,15 @@ class BoundingBox:
             import pyvista as pv
         except ImportError:
             raise ImportError("pyvista is required for vtk support")
-        x = np.linspace(self.global_origin[0], self.global_maximum[0], self.nsteps[0])
-        y = np.linspace(self.global_origin[1], self.global_maximum[1], self.nsteps[1])
-        z = np.linspace(self.global_origin[2], self.global_maximum[2], self.nsteps[2])
+        x = np.linspace(
+            self.global_origin[0] + self.origin[0], self.global_maximum[0], self.nsteps[0]
+        )
+        y = np.linspace(
+            self.global_origin[1] + self.origin[1], self.global_maximum[1], self.nsteps[1]
+        )
+        z = np.linspace(
+            self.global_origin[2] + self.origin[2], self.global_maximum[2], self.nsteps[2]
+        )
         return pv.RectilinearGrid(
             x,
             y,
@@ -435,3 +441,52 @@ class BoundingBox:
             properties=_vertex_data,
             name=name,
         )
+
+    def project(self, xyz):
+        """Project a point into the bounding box
+
+        Parameters
+        ----------
+        xyz : np.ndarray
+            point to project
+
+        Returns
+        -------
+        np.ndarray
+            projected point
+        """
+
+        return (xyz - self.global_origin) / np.max(
+            (self.global_maximum - self.global_origin)
+        )  # np.clip(xyz, self.origin, self.maximum)
+
+    def reproject(self, xyz):
+        """Reproject a point from the bounding box to the global space
+
+        Parameters
+        ----------
+        xyz : np.ndarray
+            point to reproject
+
+        Returns
+        -------
+        np.ndarray
+            reprojected point
+        """
+
+        return xyz * np.max((self.global_maximum - self.global_origin)) + self.global_origin
+
+    def __repr__(self):
+        return f"BoundingBox({self.origin}, {self.maximum}, {self.nsteps})"
+
+    def __str__(self):
+        return f"BoundingBox({self.origin}, {self.maximum}, {self.nsteps})"
+
+    def __eq__(self, other):
+        if not isinstance(other, BoundingBox):
+            return False
+        return (
+            np.allclose(self.origin, other.origin)
+            and np.allclose(self.maximum, other.maximum)
+            and np.allclose(self.nsteps, other.nsteps)
+        )

LoopStructural/datatypes/_point.py

@@ -25,11 +25,14 @@ class ValuePoints:
             ),
         }
 
-    def vtk(self):
+    def vtk(self, scalars=None):
         import pyvista as pv
 
         points = pv.PolyData(self.locations)
-        points["values"] = self.values
+        if scalars is not None and len(scalars) == len(self.locations):
+            points.point_data['scalars'] = scalars
+        else:
+            points["values"] = self.values
         return points
 
     def plot(self, pyvista_kwargs={}):
@@ -123,9 +126,19 @@ class VectorPoints:
     def from_dict(self, d):
         return VectorPoints(d['locations'], d['vectors'], d['name'], d.get('properties', None))
 
-    def vtk(self, geom='arrow', scale=1.0, scale_function=None, normalise=True, tolerance=0.05):
+    def vtk(
+        self,
+        geom='arrow',
+        scale=0.10,
+        scale_function=None,
+        normalise=True,
+        tolerance=0.05,
+        bb=None,
+        scalars=None,
+    ):
         import pyvista as pv
 
+        _projected = False
         vectors = np.copy(self.vectors)
         if normalise:
             norm = np.linalg.norm(vectors, axis=1)
@@ -133,15 +146,28 @@ class VectorPoints:
         if scale_function is not None:
             # vectors /= np.linalg.norm(vectors, axis=1)[:, None]
             vectors *= scale_function(self.locations)[:, None]
-        points = pv.PolyData(self.locations)
+        locations = self.locations
+        if bb is not None:
+            try:
+                locations = bb.project(locations)
+                _projected = True
+            except Exception as e:
+                logger.error(f'Failed to project points to bounding box: {e}')
+                logger.error('Using unprojected points, this may cause issues with the glyphing')
+        points = pv.PolyData(locations)
+        if scalars is not None and len(scalars) == len(self.locations):
+            points['scalars'] = scalars
         points.point_data.set_vectors(vectors, 'vectors')
         if geom == 'arrow':
             geom = pv.Arrow(scale=scale)
         elif geom == 'disc':
-            geom = pv.Disc(inner=0, outer=scale)
+            geom = pv.Disc(inner=0, outer=scale).rotate_y(90)
 
         # Perform the glyph
-        return points.glyph(orient="vectors", geom=geom, tolerance=tolerance)
+        glyphed = points.glyph(orient="vectors", geom=geom, tolerance=tolerance, scale=False)
+        if _projected:
+            glyphed.points = bb.reproject(glyphed.points)
+        return glyphed
 
     def plot(self, pyvista_kwargs={}):
         """Calls pyvista plot on the vtk object

LoopStructural/interpolators/__init__.py

@@ -114,5 +114,5 @@ support_interpolator_map = {
 }
 
 from ._interpolator_factory import InterpolatorFactory
-
+from ._interpolator_builder import InterpolatorBuilder
 # from ._api import LoopInterpolator

LoopStructural/interpolators/_builders.py

@@ -1,149 +1,149 @@
-from LoopStructural.utils.exceptions import LoopException
-import numpy as np
-from typing import Optional
-from LoopStructural.interpolators import (
-    P1Interpolator,
-    P2Interpolator,
-    FiniteDifferenceInterpolator,
-    GeologicalInterpolator,
-    DiscreteFoldInterpolator,
-    StructuredGrid,
-    TetMesh,
-)
-from LoopStructural.datatypes import BoundingBox
-from LoopStructural.utils.logging import getLogger
+# from LoopStructural.utils.exceptions import LoopException
+# import numpy as np
+# from typing import Optional
+# from LoopStructural.interpolators import (
+#     P1Interpolator,
+#     P2Interpolator,
+#     FiniteDifferenceInterpolator,
+#     GeologicalInterpolator,
+#     DiscreteFoldInterpolator,
+#     StructuredGrid,
+#     TetMesh,
+# )
+# from LoopStructural.datatypes import BoundingBox
+# from LoopStructural.utils.logging import getLogger
 
-logger = getLogger(__name__)
+# logger = getLogger(__name__)
 
 
-def get_interpolator(
-    bounding_box: BoundingBox,
-    interpolatortype: str,
-    nelements: int,
-    element_volume: Optional[float] = None,
-    buffer: float = 0.2,
-    dimensions: int = 3,
-    support=None,
-) -> GeologicalInterpolator:
-    # add a buffer to the interpolation domain, this is necessary for
-    # faults but also generally a good
-    # idea to avoid boundary problems
-    # buffer = bb[1, :]
-    origin = bounding_box.with_buffer(buffer).origin
-    maximum = bounding_box.with_buffer(buffer).maximum
-    box_vol = np.prod(maximum - origin)
-    if interpolatortype == "PLI":
-        if support is None:
-            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[:] = element_volume ** (1.0 / 3.0)
-            # step_vector /= np.array([1,1,2])
-            # number of steps is the length of the box / step vector
-            nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
-            if np.any(np.less(nsteps, 3)):
-                axis_labels = ["x", "y", "z"]
-                for i in range(3):
-                    if nsteps[i] < 3:
-                        nsteps[i] = 3
-                        logger.error(
-                            f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
-                        )
-                logger.error("Cannot create interpolator: number of steps is too small")
-                raise ValueError("Number of steps too small cannot create interpolator")
+# def get_interpolator(
+#     bounding_box: BoundingBox,
+#     interpolatortype: str,
+#     nelements: int,
+#     element_volume: Optional[float] = None,
+#     buffer: float = 0.2,
+#     dimensions: int = 3,
+#     support=None,
+# ) -> GeologicalInterpolator:
+#     # add a buffer to the interpolation domain, this is necessary for
+#     # faults but also generally a good
+#     # idea to avoid boundary problems
+#     # buffer = bb[1, :]
+#     origin = bounding_box.with_buffer(buffer).origin
+#     maximum = bounding_box.with_buffer(buffer).maximum
+#     box_vol = np.prod(maximum - origin)
+#     if interpolatortype == "PLI":
+#         if support is None:
+#             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[:] = element_volume ** (1.0 / 3.0)
+#             # step_vector /= np.array([1,1,2])
+#             # number of steps is the length of the box / step vector
+#             nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
+#             if np.any(np.less(nsteps, 3)):
+#                 axis_labels = ["x", "y", "z"]
+#                 for i in range(3):
+#                     if nsteps[i] < 3:
+#                         nsteps[i] = 3
+#                         logger.error(
+#                             f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
+#                         )
+#                 logger.error("Cannot create interpolator: number of steps is too small")
+#                 raise ValueError("Number of steps too small cannot create interpolator")
 
-            support = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
-        logger.info(
-            "Creating regular tetrahedron mesh with %i elements \n"
-            "for modelling using PLI" % (support.ntetra)
-        )
+#             support = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
+#         logger.info(
+#             "Creating regular tetrahedron mesh with %i elements \n"
+#             "for modelling using PLI" % (support.ntetra)
+#         )
 
-        return P1Interpolator(support)
-    if interpolatortype == "P2":
-        if support is not None:
-            logger.info(
-                "Creating regular tetrahedron mesh with %i elements \n"
-                "for modelling using P2" % (support.ntetra)
-            )
-            return P2Interpolator(support)
-        else:
-            raise ValueError("Cannot create P2 interpolator without support, try using PLI")
+#         return P1Interpolator(support)
+#     if interpolatortype == "P2":
+#         if support is not None:
+#             logger.info(
+#                 "Creating regular tetrahedron mesh with %i elements \n"
+#                 "for modelling using P2" % (support.ntetra)
+#             )
+#             return P2Interpolator(support)
+#         else:
+#             raise ValueError("Cannot create P2 interpolator without support, try using PLI")
 
-    if interpolatortype == "FDI":
-        # find the volume of one element
-        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[:] = element_volume ** (1.0 / 3.0)
-        # number of steps is the length of the box / step vector
-        nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
-        if np.any(np.less(nsteps, 3)):
-            logger.error("Cannot create interpolator: number of steps is too small")
-            axis_labels = ["x", "y", "z"]
-            for i in range(3):
-                if nsteps[i] < 3:
-                    nsteps[i] = 3
-            #         logger.error(
-            #             f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
-            #         )
-            # raise ValueError("Number of steps too small cannot create interpolator")
-        # create a structured grid using the origin and number of steps
+#     if interpolatortype == "FDI":
+#         # find the volume of one element
+#         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[:] = element_volume ** (1.0 / 3.0)
+#         # number of steps is the length of the box / step vector
+#         nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
+#         if np.any(np.less(nsteps, 3)):
+#             logger.error("Cannot create interpolator: number of steps is too small")
+#             axis_labels = ["x", "y", "z"]
+#             for i in range(3):
+#                 if nsteps[i] < 3:
+#                     nsteps[i] = 3
+#             #         logger.error(
+#             #             f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
+#             #         )
+#             # raise ValueError("Number of steps too small cannot create interpolator")
+#         # create a structured grid using the origin and number of steps
 
-        grid = StructuredGrid(origin=origin, nsteps=nsteps, step_vector=step_vector)
-        logger.info(
-            f"Creating regular grid with {grid.n_elements} elements \n" "for modelling using FDI"
-        )
-        return FiniteDifferenceInterpolator(grid)
-    if interpolatortype == "DFI":
-        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[:] = element_volume ** (1.0 / 3.0)
-        # number of steps is the length of the box / step vector
-        nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
-        # create a structured grid using the origin and number of steps
+#         grid = StructuredGrid(origin=origin, nsteps=nsteps, step_vector=step_vector)
+#         logger.info(
+#             f"Creating regular grid with {grid.n_elements} elements \n" "for modelling using FDI"
+#         )
+#         return FiniteDifferenceInterpolator(grid)
+#     if interpolatortype == "DFI":
+#         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[:] = element_volume ** (1.0 / 3.0)
+#         # number of steps is the length of the box / step vector
+#         nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
+#         # create a structured grid using the origin and number of steps
 
-        mesh = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
-        logger.info(
-            f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
-            "for modelling using DFI"
-        )
-        return DiscreteFoldInterpolator(mesh, None)
-    raise LoopException("No interpolator")
-    # fi interpolatortype == "DFI" and dfi is True:
-    #     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[:] = element_volume ** (1.0 / 3.0)
-    #     # 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
-    #     if "meshbuilder" in kwargs:
-    #         mesh = kwargs["meshbuilder"].build(bb, nelements)
-    #     else:
-    #         mesh = kwargs.get(
-    #             "mesh",
-    #             TetMesh(origin=bb[0, :], nsteps=nsteps, step_vector=step_vector),
-    #         )
-    #     logger.info(
-    #         f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
-    #         "for modelling using DFI"
-    #     )
-    #     return DFI(mesh, kwargs["fold"])
-    # if interpolatortype == "Surfe" or interpolatortype == "surfe":
-    #     # move import of surfe to where we actually try and use it
-    #     if not surfe:
-    #         logger.warning("Cannot import Surfe, try another interpolator")
-    #         raise ImportError("Cannot import surfepy, try pip install surfe")
-    #     method = kwargs.get("method", "single_surface")
-    #     logger.info("Using surfe interpolator")
-    #     return SurfeRBFInterpolator(method)
-    # logger.warning("No interpolator")
-    # raise InterpolatorError("Could not create interpolator")
+#         mesh = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
+#         logger.info(
+#             f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
+#             "for modelling using DFI"
+#         )
+#         return DiscreteFoldInterpolator(mesh, None)
+#     raise LoopException("No interpolator")
+#     # fi interpolatortype == "DFI" and dfi is True:
+#     #     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[:] = element_volume ** (1.0 / 3.0)
+#     #     # 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
+#     #     if "meshbuilder" in kwargs:
+#     #         mesh = kwargs["meshbuilder"].build(bb, nelements)
+#     #     else:
+#     #         mesh = kwargs.get(
+#     #             "mesh",
+#     #             TetMesh(origin=bb[0, :], nsteps=nsteps, step_vector=step_vector),
+#     #         )
+#     #     logger.info(
+#     #         f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
+#     #         "for modelling using DFI"
+#     #     )
+#     #     return DFI(mesh, kwargs["fold"])
+#     # if interpolatortype == "Surfe" or interpolatortype == "surfe":
+#     #     # move import of surfe to where we actually try and use it
+#     #     if not surfe:
+#     #         logger.warning("Cannot import Surfe, try another interpolator")
+#     #         raise ImportError("Cannot import surfepy, try pip install surfe")
+#     #     method = kwargs.get("method", "single_surface")
+#     #     logger.info("Using surfe interpolator")
+#     #     return SurfeRBFInterpolator(method)
+#     # logger.warning("No interpolator")
+#     # raise InterpolatorError("Could not create interpolator")

LoopStructural/interpolators/_finite_difference_interpolator.py

@@ -97,7 +97,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         self.add_interface_constraints(self.interpolation_weights["ipw"])
         self.add_value_inequality_constraints()
         self.add_inequality_pairs_constraints(
-            kwargs.get('inequality_pairs', None),
+            pairs=kwargs.get('inequality_pairs', None),
             upper_bound=kwargs.get('inequality_pair_upper_bound', np.finfo(float).eps),
             lower_bound=kwargs.get('inequality_pair_lower_bound', -np.inf),
         )
@@ -172,16 +172,18 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         # get elements for points
         points = self.get_interface_constraints()
         if points.shape[0] > 1:
-            vertices, c, tetras, inside = self.support.get_element_for_location(
+            node_idx, inside = self.support.position_to_cell_corners(
                 points[:, : self.support.dimension]
             )
-            # calculate volume of tetras
-            # vecs = vertices[inside, 1:, :] - vertices[inside, 0, None, :]
-            # vol = np.abs(np.linalg.det(vecs)) / 6
-            A = c[inside, :]
-            # A *= vol[:,None]
-            idc = tetras[inside, :]
-
+            gi = np.zeros(self.support.n_nodes, dtype=int)
+            gi[:] = -1
+            gi[self.region] = np.arange(0, self.nx, dtype=int)
+            idc = np.zeros(node_idx.shape).astype(int)
+            idc[:] = -1
+            idc[inside, :] = gi[node_idx[inside, :]]
+            inside = np.logical_and(~np.any(idc == -1, axis=1), inside)
+            idc = idc[inside, :]
+            A = self.support.position_to_dof_coefs(points[inside, : self.support.dimension])
             for unique_id in np.unique(
                 points[
                     np.logical_and(~np.isnan(points[:, self.support.dimension]), inside),
@@ -197,7 +199,6 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 ).T.reshape(-1, 2)
                 interface_A = np.hstack([A[mask, :][ij[:, 0], :], -A[mask, :][ij[:, 1], :]])
                 interface_idc = np.hstack([idc[mask, :][ij[:, 0], :], idc[mask, :][ij[:, 1], :]])
-
                 # now map the index from global to region create array size of mesh
                 # initialise as np.nan, then map points inside region to 0->nx
                 gi = np.zeros(self.support.n_nodes).astype(int)
@@ -229,7 +230,6 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         points = self.get_gradient_constraints()
         if points.shape[0] > 0:
             # calculate unit vector for orientation data
-            # points[:,3:]/=np.linalg.norm(points[:,3:],axis=1)[:,None]
 
             node_idx, inside = self.support.position_to_cell_corners(
                 points[:, : self.support.dimension]

LoopStructural/interpolators/_interpolator_builder.py

@@ -0,0 +1,55 @@
+from LoopStructural.interpolators import (
+    GeologicalInterpolator,
+    InterpolatorFactory,
+    InterpolatorType,
+)
+from LoopStructural.datatypes import BoundingBox
+from typing import Optional, Union
+import numpy as np
+
+
+class InterpolatorBuilder:
+    def __init__(
+        self,
+        interpolatortype: Union[str, InterpolatorType],
+        bounding_box: BoundingBox,
+        nelements: int = 1000,
+        buffer: float = 0.2,
+        **kwargs,
+    ):
+        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
+
+    def set_value_constraints(self, value_constraints: np.ndarray) -> 'InterpolatorBuilder':
+        if self.interpolator:
+            self.interpolator.set_value_constraints(value_constraints)
+        return self
+
+    def set_gradient_constraints(self, gradient_constraints: np.ndarray) -> 'InterpolatorBuilder':
+        if self.interpolator:
+            self.interpolator.set_gradient_constraints(gradient_constraints)
+        return self
+
+    def set_normal_constraints(self, normal_constraints: np.ndarray) -> 'InterpolatorBuilder':
+        if self.interpolator:
+            self.interpolator.set_normal_constraints(normal_constraints)
+        return self
+
+    def setup_interpolator(self, **kwargs) -> Optional[GeologicalInterpolator]:
+        if self.interpolator:
+            self.interpolator.setup(**kwargs)
+            return self.interpolator

LoopStructural/interpolators/_interpolator_factory.py

@@ -65,25 +65,14 @@ class InterpolatorFactory:
         gradient_norm_constraints: Optional[np.ndarray] = None,
         gradient_constraints: Optional[np.ndarray] = 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 = InterpolatorType._member_map_[interpolatortype].numerator
-        if support is None:
-            raise Exception("Support must be specified")
-            # supporttype = support_interpolator_map[interpolatortype]
-            # support = SupportFactory.create_support(
-            #     supporttype, boundingbox, nelements, element_volume
-            # )
-        interpolator = interpolator_map[interpolatortype](support)
+        interpolator = InterpolatorFactory.create_interpolator(
+            interpolatortype, boundingbox, nelements, element_volume, support
+        )
         if value_constraints is not None:
-            interpolator.add_value_constraints(value_constraints)
+            interpolator.set_value_constraints(value_constraints)
         if gradient_norm_constraints is not None:
-            interpolator.add_gradient_constraints(gradient_norm_constraints)
+            interpolator.set_normal_constraints(gradient_norm_constraints)
         if gradient_constraints is not None:
-            interpolator.add_gradient_constraints(gradient_constraints)
+            interpolator.set_gradient_constraints(gradient_constraints)
+        interpolator.setup()
         return interpolator

LoopStructural/interpolators/supports/_3d_base_structured.py

@@ -41,6 +41,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"
+            )
         self._nsteps = np.array(nsteps, dtype=int) + 1
         self._step_vector = np.array(step_vector)
         self._origin = np.array(origin)