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

LoopStructural/interpolators/_discrete_interpolator.py

@@ -6,7 +6,6 @@ from abc import abstractmethod
 from typing import Callable, Optional, Union
 import logging
 
-from time import time
 import numpy as np
 from scipy import sparse  # import sparse.coo_matrix, sparse.bmat, sparse.eye
 from ..interpolators import InterpolatorType
@@ -33,6 +32,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         GeologicalInterpolator.__init__(self, data=data, up_to_date=up_to_date)
         self.B = []
         self.support = support
+        self.dimensions = support.dimension
         self.c = (
             np.array(c)
             if c is not None and np.array(c).shape[0] == self.support.n_nodes
@@ -62,7 +62,6 @@ class DiscreteInterpolator(GeologicalInterpolator):
         self.interpolation_weights = {}
         logger.info("Creating discrete interpolator with {} degrees of freedom".format(self.nx))
         self.type = InterpolatorType.BASE_DISCRETE
-        self.c = np.zeros(self.support.n_nodes)
 
     @property
     def nx(self) -> int:
@@ -133,6 +132,28 @@ class DiscreteInterpolator(GeologicalInterpolator):
             self.up_to_date = False
             self.interpolation_weights[key] = weights[key]
 
+    def _pre_solve(self):
+        """
+        Pre solve function to be run before solving the interpolation
+        """
+        self.c = np.zeros(self.support.n_nodes)
+        self.c[:] = np.nan
+        return True
+
+    def _post_solve(self):
+        """Post solve function(s) to be run after the solver has been called"""
+        self.clear_constraints()
+        return True
+
+    def clear_constraints(self):
+        """
+        Clear the constraints from the interpolator, this makes sure we are not storing
+        the constraints after the solver has been run
+        """
+        self.constraints = {}
+        self.ineq_constraints = {}
+        self.equal_constraints = {}
+
     def reset(self):
         """
         Reset the interpolation constraints
@@ -140,7 +161,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         """
         self.constraints = {}
         self.c_ = 0
-        logger.debug("Resetting interpolation constraints")
+        logger.info("Resetting interpolation constraints")
 
     def add_constraints_to_least_squares(self, A, B, idc, w=1.0, name="undefined"):
         """
@@ -181,7 +202,8 @@ class DiscreteInterpolator(GeologicalInterpolator):
             B = B.reshape((A.shape[0]))
             # w = w.reshape((A.shape[0]))
         # normalise by rows of A
-        length = np.linalg.norm(A, axis=1)  # .getcol(0).norm()
+        # Should this be done? It should make the solution more stable
+        length = np.linalg.norm(A, axis=1)
         B[length > 0] /= length[length > 0]
         # going to assume if any are nan they are all nan
         mask = np.any(np.isnan(A), axis=1)
@@ -193,9 +215,6 @@ class DiscreteInterpolator(GeologicalInterpolator):
             raise BaseException("w must be a numpy array")
 
         if w.shape[0] != A.shape[0]:
-            #     # make w the same size as A
-            #     w = np.tile(w,(A.shape[1],1)).T
-            # else:
             raise BaseException("Weight array does not match number of constraints")
         if np.any(np.isnan(idc)) or np.any(np.isnan(A)) or np.any(np.isnan(B)):
             logger.warning("Constraints contain nan not adding constraints: {}".format(name))
@@ -286,31 +305,43 @@ class DiscreteInterpolator(GeologicalInterpolator):
             self.add_inequality_constraints_to_matrix(a, points[:, 3:5], cols, 'inequality_value')
 
     def add_inequality_pairs_constraints(
-        self, w: float = 1.0, upper_bound=np.finfo(float).eps, lower_bound=-np.inf
+        self,
+        w: float = 1.0,
+        upper_bound=np.finfo(float).eps,
+        lower_bound=-np.inf,
+        pairs: Optional[list] = None,
     ):
 
         points = self.get_inequality_pairs_constraints()
         if points.shape[0] > 0:
-
             # assemble a list of pairs in the model
             # this will make pairs even across stratigraphic boundaries
             # TODO add option to only add stratigraphic pairs
-            pairs = {}
-            k = 0
-            for i in np.unique(points[:, self.support.dimension]):
-                for j in np.unique(points[:, self.support.dimension]):
-                    if i == j:
-                        continue
-                    if tuple(sorted([i, j])) not in pairs:
-                        pairs[tuple(sorted([i, j]))] = k
-                        k += 1
-            pairs = list(pairs.keys())
+            if not pairs:
+                pairs = {}
+                k = 0
+                for i in np.unique(points[:, self.support.dimension]):
+                    for j in np.unique(points[:, self.support.dimension]):
+                        if i == j:
+                            continue
+                        if tuple(sorted([i, j])) not in pairs:
+                            pairs[tuple(sorted([i, j]))] = k
+                            k += 1
+                pairs = list(pairs.keys())
             for pair in pairs:
                 upper_points = points[points[:, self.support.dimension] == pair[0]]
                 lower_points = points[points[:, self.support.dimension] == pair[1]]
 
                 upper_interpolation = self.support.get_element_for_location(upper_points)
                 lower_interpolation = self.support.get_element_for_location(lower_points)
+                if (~upper_interpolation[3]).sum() > 0:
+                    logger.warning(
+                        f'Upper points not in mesh {upper_points[~upper_interpolation[3]]}'
+                    )
+                if (~lower_interpolation[3]).sum() > 0:
+                    logger.warning(
+                        f'Lower points not in mesh {lower_points[~lower_interpolation[3]]}'
+                    )
                 ij = np.array(
                     [
                         *np.meshgrid(
@@ -325,7 +356,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
                 rows = np.arange(0, ij.shape[0], dtype=int)
                 rows = np.tile(rows, (upper_interpolation[1].shape[-1], 1)).T
                 rows = np.hstack([rows, rows])
-                a = upper_interpolation[1][upper_interpolation[3]][ij[:, 0]]  # np.ones(ij.shape[0])
+                a = upper_interpolation[1][upper_interpolation[3]][ij[:, 0]]
                 a = np.hstack([a, -lower_interpolation[1][lower_interpolation[3]][ij[:, 1]]])
                 cols = np.hstack(
                     [
@@ -511,7 +542,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
             mats.append(c['matrix'])
             bounds.append(c['bounds'])
         if len(mats) == 0:
-            return None, None
+            return sparse.csr_matrix((0, self.nx), dtype=float), np.zeros((0, 3))
         Q = sparse.vstack(mats)
         bounds = np.vstack(bounds)
         return Q, bounds
@@ -519,6 +550,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
     def solve_system(
         self,
         solver: Optional[Union[Callable[[sparse.csr_matrix, np.ndarray], np.ndarray], str]] = None,
+        tol: Optional[float] = None,
         solver_kwargs: dict = {},
     ) -> bool:
         """
@@ -539,19 +571,16 @@ class DiscreteInterpolator(GeologicalInterpolator):
             True if the interpolation is run
 
         """
-        starttime = time()
-        self.c = np.zeros(self.support.n_nodes)
-        self.c[:] = np.nan
+        if not self._pre_solve():
+            raise ValueError("Pre solve failed")
+
         A, b = self.build_matrix()
         Q, bounds = self.build_inequality_matrix()
         if callable(solver):
             logger.warning('Using custom solver')
             self.c = solver(A.tocsr(), b)
             self.up_to_date = True
-
-            return True
-        ## solve with lsmr
-        if isinstance(solver, str):
+        elif isinstance(solver, str) or solver is None:
             if solver not in ['cg', 'lsmr', 'admm']:
                 logger.warning(
                     f'Unknown solver {solver} using cg. \n Available solvers are cg and lsmr or a custom solver as a callable function'
@@ -559,18 +588,29 @@ class DiscreteInterpolator(GeologicalInterpolator):
                 solver = 'cg'
         if solver == 'cg':
             logger.info("Solving using cg")
-            ATA = A.T.dot(A)
-            ATB = A.T.dot(b)
-            res = sparse.linalg.cg(ATA, ATB, **solver_kwargs)
+            if 'atol' not in solver_kwargs or 'rtol' not in solver_kwargs:
+                if tol is not None:
+                    solver_kwargs['atol'] = tol
+
+            logger.info(f"Solver kwargs: {solver_kwargs}")
+
+            res = sparse.linalg.cg(A.T @ A, A.T @ b, **solver_kwargs)
             if res[1] > 0:
                 logger.warning(
                     f'CG reached iteration limit ({res[1]})and did not converge, check input data. Setting solution to last iteration'
                 )
             self.c = res[0]
             self.up_to_date = True
-            return True
+
         elif solver == 'lsmr':
             logger.info("Solving using lsmr")
+            if 'atol' not in solver_kwargs:
+                if tol is not None:
+                    solver_kwargs['atol'] = tol
+            if 'btol' not in solver_kwargs:
+                if tol is not None:
+                    solver_kwargs['btol'] = tol
+            logger.info(f"Solver kwargs: {solver_kwargs}")
             res = sparse.linalg.lsmr(A, b, **solver_kwargs)
             if res[1] == 1 or res[1] == 4 or res[1] == 2 or res[1] == 5:
                 self.c = res[0]
@@ -585,8 +625,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
                 )
                 self.c = res[0]
             self.up_to_date = True
-            logger.info("Interpolation took %f seconds" % (time() - starttime))
-            return True
+
         elif solver == 'admm':
             logger.info("Solving using admm")
 
@@ -601,28 +640,35 @@ class DiscreteInterpolator(GeologicalInterpolator):
 
             try:
                 from loopsolver import admm_solve
+
+                try:
+                    linsys_solver = solver_kwargs.pop('linsys_solver', 'lsmr')
+                    res = admm_solve(
+                        A,
+                        b,
+                        Q,
+                        bounds,
+                        x0=x0,
+                        admm_weight=solver_kwargs.pop('admm_weight', 0.01),
+                        nmajor=solver_kwargs.pop('nmajor', 200),
+                        linsys_solver_kwargs=solver_kwargs,
+                        linsys_solver=linsys_solver,
+                    )
+                    self.c = res
+                    self.up_to_date = True
+                except ValueError as e:
+                    logger.error(f"ADMM solver failed: {e}")
+                    self.up_to_date = False
             except ImportError:
                 logger.warning(
                     "Cannot import admm solver. Please install loopsolver or use lsmr or cg"
                 )
-                return False
-            try:
-                res = admm_solve(
-                    A,
-                    b,
-                    Q,
-                    bounds,
-                    x0=x0,
-                    admm_weight=solver_kwargs.pop('admm_weight', 0.01),
-                    nmajor=solver_kwargs.pop('nmajor', 200),
-                    linsys_solver_kwargs=solver_kwargs,
-                )
-                self.c = res
-                self.up_to_date = True
-            except ValueError as e:
-                logger.error(f"ADMM solver failed: {e}")
-                return False
-        return False
+                self.up_to_date = False
+        else:
+            logger.error(f"Unknown solver {solver}")
+            self.up_to_date = False
+        # self._post_solve()
+        return self.up_to_date
 
     def update(self) -> bool:
         """
@@ -641,7 +687,8 @@ class DiscreteInterpolator(GeologicalInterpolator):
             return False
         if not self.up_to_date:
             self.setup_interpolator()
-            return self.solve_system(self.solver)
+            self.up_to_date = self.solve_system(self.solver)
+            return self.up_to_date
 
     def evaluate_value(self, locations: np.ndarray) -> np.ndarray:
         """Evaluate the value of the interpolator at location

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(
+            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:
@@ -206,8 +182,13 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             # 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
+            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]),
@@ -250,7 +231,9 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             # 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/_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)} \