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

LoopStructural/interpolators/_finite_difference_interpolator.py

@@ -8,8 +8,6 @@ from ..utils import get_vectors
 from ._discrete_interpolator import DiscreteInterpolator
 from ..interpolators import InterpolatorType
 
-from ._operator import Operator
-
 from LoopStructural.utils import getLogger
 
 logger = getLogger(__name__)
@@ -26,13 +24,11 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         """
         self.shape = "rectangular"
         DiscreteInterpolator.__init__(self, grid, data=data)
-        # default weights for the interpolation matrix are 1 in x,y,z and
-        # 1/
         self.set_interpolation_weights(
             {
-                "dxy": 0.7,
-                "dyz": 0.7,
-                "dxz": 0.7,
+                "dxy": 1.0,
+                "dyz": 1.0,
+                "dxz": 1.0,
                 "dxx": 1.0,
                 "dyy": 1.0,
                 "dzz": 1.0,
@@ -47,7 +43,6 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             }
         )
 
-        # grid.step_vector[2]
         self.type = InterpolatorType.FINITE_DIFFERENCE
 
     def setup_interpolator(self, **kwargs):
@@ -88,43 +83,24 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 self.interpolation_weights["dyy"] = 0.1 * kwargs["regularisation"]
                 self.interpolation_weights["dzz"] = 0.1 * kwargs["regularisation"]
             self.interpolation_weights[key] = kwargs[key]
-        # if we want to define the operators manually
-        if "operators" in kwargs:
-            for o in kwargs["operators"].values():
-                self.assemble_inner(o[0], o[1])
-        # otherwise just use defaults
-        if "operators" not in kwargs:
-            operator = Operator.Dxy_mask
-            weight = (
-                self.interpolation_weights["dxy"] / 4
-            )  # (4*self.support.step_vector[0]*self.support.step_vector[1])
-            self.assemble_inner(operator, weight)
-            operator = Operator.Dyz_mask
-            weight = (
-                self.interpolation_weights["dyz"] / 4
-            )  # (4*self.support.step_vector[1]*self.support.step_vector[2])
-            self.assemble_inner(operator, weight)
-            operator = Operator.Dxz_mask
-            weight = (
-                self.interpolation_weights["dxz"] / 4
-            )  # (4*self.support.step_vector[0]*self.support.step_vector[2])
-            self.assemble_inner(operator, weight)
-            operator = Operator.Dxx_mask
-            weight = self.interpolation_weights["dxx"] / 1  # self.support.step_vector[0]**2
-            self.assemble_inner(operator, weight)
-            operator = Operator.Dyy_mask
-            weight = self.interpolation_weights["dyy"] / 1  # self.support.step_vector[1]**2
-            self.assemble_inner(operator, weight)
-            operator = Operator.Dzz_mask
-            weight = self.interpolation_weights["dzz"] / 1  # self.support.step_vector[2]**2
-            self.assemble_inner(operator, weight)
+        # either use the default operators or the ones passed to the function
+        operators = kwargs.get(
+            "operators", self.support.get_operators(weights=self.interpolation_weights)
+        )
+        for k, o in operators.items():
+            self.assemble_inner(o[0], o[1], name=k)
+
         self.add_norm_constraints(self.interpolation_weights["npw"])
         self.add_gradient_constraints(self.interpolation_weights["gpw"])
         self.add_value_constraints(self.interpolation_weights["cpw"])
         self.add_tangent_constraints(self.interpolation_weights["tpw"])
         self.add_interface_constraints(self.interpolation_weights["ipw"])
         self.add_value_inequality_constraints()
-        self.add_inequality_pairs_constraints()
+        self.add_inequality_pairs_constraints(
+            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),
+        )
 
     def copy(self):
         """
@@ -167,9 +143,9 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             # a/=self.support.enp.product(self.support.step_vector)
             self.add_constraints_to_least_squares(
                 a,
-                points[inside, 3],
+                points[inside, self.support.dimension],
                 idc[inside, :],
-                w=w * points[inside, 4],
+                w=w * points[inside, self.support.dimension + 1],
                 name="value",
             )
             if np.sum(inside) <= 0:
@@ -196,18 +172,25 @@ 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, :]
-
-            for unique_id in np.unique(points[np.logical_and(~np.isnan(points[:, 3]), inside), 3]):
-                mask = points[inside, 3] == unique_id
+            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),
+                    self.support.dimension,
+                ]
+            ):
+                mask = points[inside, self.support.dimension] == unique_id
                 ij = np.array(
                     np.meshgrid(
                         np.arange(0, A[mask, :].shape[0]),
@@ -216,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)
@@ -248,9 +230,10 @@ 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[:, :3])
+            node_idx, inside = self.support.position_to_cell_corners(
+                points[:, : self.support.dimension]
+            )
             # calculate unit vector for node gradients
             # this means we are only constraining direction of grad not the
             # magnitude
@@ -267,13 +250,22 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 T,
                 elements,
                 inside_,
-            ) = self.support.get_element_gradient_for_location(points[inside, :3])
+            ) = self.support.get_element_gradient_for_location(
+                points[inside, : self.support.dimension]
+            )
             # normalise constraint vector and scale element matrix by this
-            norm = np.linalg.norm(points[:, 3:6], axis=1)
+            norm = np.linalg.norm(
+                points[:, self.support.dimension : self.support.dimension + self.support.dimension],
+                axis=1,
+            )
             points[:, 3:6] /= norm[:, None]
             T /= norm[inside, None, None]
             # calculate two orthogonal vectors to constraint (strike and dip vector)
-            strike_vector, dip_vector = get_vectors(points[inside, 3:6])
+            strike_vector, dip_vector = get_vectors(
+                points[
+                    inside, self.support.dimension : self.support.dimension + self.support.dimension
+                ]
+            )
             A = np.einsum("ij,ijk->ik", strike_vector.T, T)
             B = np.zeros(points[inside, :].shape[0])
             self.add_constraints_to_least_squares(A, B, idc[inside, :], w=w, name="gradient")
@@ -302,7 +294,9 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         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[:, :3])
+            node_idx, inside = self.support.position_to_cell_corners(
+                points[:, : self.support.dimension]
+            )
             gi = np.zeros(self.support.n_nodes)
             gi[:] = -1
             gi[self.region] = np.arange(0, self.nx)
@@ -319,31 +313,23 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 T,
                 elements,
                 inside_,
-            ) = self.support.get_element_gradient_for_location(points[inside, :3])
+            ) = self.support.get_element_gradient_for_location(
+                points[inside, : self.support.dimension]
+            )
             # T*=np.product(self.support.step_vector)
             # T/=self.support.step_vector[0]
+
             w /= 3
-            self.add_constraints_to_least_squares(
-                T[:, 0, :],
-                points[inside, 3],
-                idc[inside, :],
-                w=w,
-                name="norm",
-            )
-            self.add_constraints_to_least_squares(
-                T[:, 1, :],
-                points[inside, 4],
-                idc[inside, :],
-                w=w,
-                name="norm",
-            )
-            self.add_constraints_to_least_squares(
-                T[:, 2, :],
-                points[inside, 5],
-                idc[inside, :],
-                w=w,
-                name="norm",
-            )
+            for d in range(self.support.dimension):
+
+                self.add_constraints_to_least_squares(
+                    T[:, d, :],
+                    points[inside, self.support.dimension + d],
+                    idc[inside, :],
+                    w=w,
+                    name=f"norm_{d}",
+                )
+
             if np.sum(inside) <= 0:
                 logger.warning(
                     f"{np.sum(~inside)} \
@@ -356,7 +342,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         points: np.ndarray,
         vectors: np.ndarray,
         w: float = 1.0,
-        B: float = 0,
+        b: float = 0,
         name="gradient orthogonal",
     ):
         """
@@ -378,7 +364,9 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         if points.shape[0] > 0:
 
             # calculate unit vector for orientation data
-            node_idx, inside = self.support.position_to_cell_corners(points[:, :3])
+            node_idx, inside = self.support.position_to_cell_corners(
+                points[:, : self.support.dimension]
+            )
             # calculate unit vector for node gradients
             # this means we are only constraining direction of grad not the
             # magnitude
@@ -400,13 +388,15 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 T,
                 elements,
                 inside_,
-            ) = self.support.get_element_gradient_for_location(points[inside, :3])
+            ) = self.support.get_element_gradient_for_location(
+                points[inside, : self.support.dimension]
+            )
             T[norm > 0, :, :] /= norm[norm > 0, None, None]
 
             # dot product of vector and element gradient = 0
-            A = np.einsum("ij,ijk->ik", vectors[inside, :3], T)
-            B = np.zeros(points[inside, :].shape[0]) + B
-            self.add_constraints_to_least_squares(A, B, idc[inside, :], w=w, name=name)
+            A = np.einsum("ij,ijk->ik", vectors[inside, : self.support.dimension], T)
+            b_ = np.zeros(points[inside, :].shape[0]) + b
+            self.add_constraints_to_least_squares(A, b_, idc[inside, :], w=w, name=name)
 
             if np.sum(inside) <= 0:
                 logger.warning(
@@ -432,7 +422,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
 
     # def assemble_borders(self, operator, w):
 
-    def assemble_inner(self, operator, w):
+    def assemble_inner(self, operator, w, name='regularisation'):
         """
 
         Parameters
@@ -465,6 +455,6 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             B[inside],
             idc[inside, :],
             w=w,
-            name="regularisation",
+            name=name,
         )
         return

LoopStructural/interpolators/_geological_interpolator.py

@@ -7,6 +7,7 @@ from LoopStructural.utils.exceptions import LoopTypeError
 from ..interpolators import InterpolatorType
 import numpy as np
 
+from typing import Optional
 from ..utils import getLogger
 
 logger = getLogger(__name__)
@@ -42,6 +43,8 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         self.constraints = []
         self.__str = "Base Geological Interpolator"
         self.valid = True
+        self.dimensions = 3  # default to 3d
+        self.support = None
 
     @property
     def data(self):
@@ -106,9 +109,9 @@ class GeologicalInterpolator(metaclass=ABCMeta):
 
         """
         points = self.check_array(points)
-        if points.shape[1] == 4:
+        if points.shape[1] == self.dimensions + 1:
             points = np.hstack([points, np.ones((points.shape[0], 1))])
-        if points.shape[1] < 5:
+        if points.shape[1] < self.dimensions + 2:
             raise ValueError("Value points must at least have X,Y,Z,val,w")
         self.data["value"] = points
         self.n_i = points.shape[0]
@@ -127,9 +130,9 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         -------
 
         """
-        if points.shape[1] == 6:
+        if points.shape[1] == self.dimensions * 2:
             points = np.hstack([points, np.ones((points.shape[0], 1))])
-        if points.shape[1] < 7:
+        if points.shape[1] < self.dimensions * 2 + 1:
             raise ValueError("Gradient constraints must at least have X,Y,Z,gx,gy,gz")
         self.n_g = points.shape[0]
         self.data["gradient"] = points
@@ -148,9 +151,9 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         -------
 
         """
-        if points.shape[1] == 6:
+        if points.shape[1] == self.dimensions * 2:
             points = np.hstack([points, np.ones((points.shape[0], 1))])
-        if points.shape[1] < 7:
+        if points.shape[1] < self.dimensions * 2 + 1:
             raise ValueError("Nonrmal constraints must at least have X,Y,Z,nx,ny,nz")
         self.n_n = points.shape[0]
         self.data["normal"] = points
@@ -169,9 +172,9 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         -------
 
         """
-        if points.shape[1] == 6:
+        if points.shape[1] == self.dimensions * 2:
             points = np.hstack([points, np.ones((points.shape[0], 1))])
-        if points.shape[1] < 7:
+        if points.shape[1] < self.dimensions * 2 + 1:
             raise ValueError("Tangent constraints must at least have X,Y,Z,tx,ty,tz")
         self.data["tangent"] = points
         self.up_to_date = False
@@ -181,13 +184,13 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         self.up_to_date = False
 
     def set_value_inequality_constraints(self, points: np.ndarray):
-        if points.shape[1] < 5:
+        if points.shape[1] < self.dimensions + 2:
             raise ValueError("Inequality constraints must at least have X,Y,Z,lower,upper")
         self.data["inequality"] = points
         self.up_to_date = False
 
     def set_inequality_pairs_constraints(self, points: np.ndarray):
-        if points.shape[1] < 4:
+        if points.shape[1] < self.dimensions + 1:
             raise ValueError("Inequality pairs constraints must at least have X,Y,Z,rock_id")
 
         self.data["inequality_pairs"] = points
@@ -313,6 +316,20 @@ class GeologicalInterpolator(metaclass=ABCMeta):
     def add_interface_constraints(self, w: float = 1.0):
         pass
 
+    @abstractmethod
+    def add_value_inequality_constraints(self, w: float = 1.0):
+        pass
+
+    @abstractmethod
+    def add_inequality_pairs_constraints(
+        self,
+        w: float = 1.0,
+        upper_bound=np.finfo(float).eps,
+        lower_bound=-np.inf,
+        pairs: Optional[list] = None,
+    ):
+        pass
+
     def to_dict(self):
         return {
             "type": self.type,

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/_p1interpolator.py

@@ -181,7 +181,7 @@ class P1Interpolator(DiscreteInterpolator):
         points: np.ndarray,
         vectors: np.ndarray,
         w: float = 1.0,
-        B: float = 0,
+        b: float = 0,
         name='undefined gradient orthogonal constraint',
     ):
         """
@@ -215,8 +215,8 @@ class P1Interpolator(DiscreteInterpolator):
             norm = np.linalg.norm(vectors, axis=1)
             vectors[norm > 0, :] /= norm[norm > 0, None]
             A = np.einsum("ij,ijk->ik", vectors[inside, :3], grad[inside, :, :])
-            B = np.zeros(points[inside, :].shape[0]) + B
-            self.add_constraints_to_least_squares(A, B, elements, w=wt, name="gradient orthogonal")
+            B = np.zeros(points[inside, :].shape[0]) + b
+            self.add_constraints_to_least_squares(A, B, elements, w=wt, name=name)
             if np.sum(inside) <= 0:
                 logger.warning(
                     f"{np.sum(~inside)} \

LoopStructural/interpolators/_surfe_wrapper.py

@@ -2,15 +2,16 @@
 Wrapper for using surfepy
 """
 
-from ..utils.helper import get_vectors
+from ..utils.maths import get_vectors
 from ..interpolators import GeologicalInterpolator
 
 import numpy as np
 
 from ..utils import getLogger
+import surfepy
+from typing import Optional
 
 logger = getLogger(__name__)
-import surfepy
 
 
 class SurfeRBFInterpolator(GeologicalInterpolator):
@@ -19,6 +20,8 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
     def __init__(self, method="single_surface"):
         GeologicalInterpolator.__init__(self)
         self.surfe = None
+        if not method:
+            method = "single_surface"
         if method == "single_surface":
             logger.info("Using single surface interpolator")
             self.surfe = surfepy.Surfe_API(1)
@@ -29,7 +32,10 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
             logger.info("Using surfe horizon")
             self.surfe = surfepy.Surfe_API(4)
 
-    def add_gradient_ctr_pts(self):
+    def set_region(self, **kwargs):
+        pass
+
+    def add_gradient_constraints(self, w=1):
         points = self.get_gradient_constraints()
         if points.shape[0] > 0:
             logger.info("Adding ")
@@ -40,12 +46,12 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
             self.surfe.SetTangentConstraints(strike_vector)
             self.surfe.SetTangentConstraints(dip_vector)
 
-    def add_norm_ctr_pts(self):
+    def add_norm_constraints(self, w=1):
         points = self.get_norm_constraints()
         if points.shape[0] > 0:
             self.surfe.SetPlanarConstraints(points[:, :6])
 
-    def add_ctr_pts(self):
+    def add_value_constraints(self, w=1):
 
         points = self.get_value_constraints()
         if points.shape[0] > 0:
@@ -59,15 +65,39 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
                     points[i, 3],
                 )
 
-    def add_tangent_ctr_pts(self):
+    def add_interface_constraints(self, w=1):
+        pass
+
+    def add_value_inequality_constraints(self, w=1):
+        ## inequalities are causing a segfault
+        # points = self.get_value_inequality_constraints()
+        # if points.shape[0] > 0:
+        #     #
+        #     self.surfe.AddValueInequalityConstraints(points[:,0],points[:,1],points[:,2],points[:,3])
+        pass
+
+    def add_inequality_pairs_constraints(
+        self,
+        w: float = 1.0,
+        upper_bound=np.finfo(float).eps,
+        lower_bound=-np.inf,
+        pairs: Optional[list] = None,
+    ):
+        # self.surfe.Add
+        pass
+
+    def reset(self):
+        pass
+
+    def add_tangent_constraints(self, w=1):
         points = self.get_tangent_constraints()
         if points.shape[0] > 0:
             self.surfe.SetTangentConstraints(points[:, :6])
 
-    def _solve(self, **kwargs):
+    def solve_system(self, **kwargs):
         self.surfe.ComputeInterpolant()
 
-    def _setup_interpolator(self, **kwargs):
+    def setup_interpolator(self, **kwargs):
         """
         Setup the interpolator
 
@@ -90,10 +120,10 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
 
 
         """
-        self.add_gradient_ctr_pts()
-        self.add_norm_ctr_pts()
-        self.add_ctr_pts()
-        self.add_tangent_ctr_pts()
+        self.add_gradient_constraints()
+        self.add_norm_constraints()
+        self.add_value_constraints()
+        self.add_tangent_constraints()
 
         kernel = kwargs.get("kernel", "r3")
         logger.info("Setting surfe RBF kernel to %s" % kernel)

LoopStructural/interpolators/supports/_2d_base_unstructured.py

@@ -338,3 +338,19 @@ class BaseUnstructured2d(BaseSupport):
         """
         verts, c, tri, inside = self.get_element_for_location(pos, return_verts=False)
         return self.evaluate_shape_derivatives(pos, tri)
+
+    def vtk(self, node_properties={}, cell_properties={}):
+        """
+        Create a vtk unstructured grid from the mesh
+        """
+        import pyvista as pv
+
+        grid = pv.UnstructuredGrid()
+        grid.points = self.nodes
+        grid.cell_types = np.ones(self.elements.shape[0]) * pv.vtk.VTK_TRIANGLE
+        grid.cells = np.c_[np.ones(self.elements.shape[0]) * 3, self.elements]
+        for key, value in node_properties.items():
+            grid.point_data[key] = value
+        for key, value in cell_properties.items():
+            grid.cell_data[key] = value
+        return grid