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

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

@@ -2,7 +2,7 @@
 Piecewise linear interpolator using folds
 """
 
-from typing import Optional
+from typing import Optional, Callable
 
 import numpy as np
 
@@ -64,6 +64,7 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
         fold_normalisation=1.0,
         fold_norm=1.0,
         step=2,
+        mask_fn: Optional[Callable] = None,
     ):
         """
 
@@ -104,6 +105,10 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
         # calculate element volume for weighting
         vecs = nodes[:, 1:, :] - nodes[:, 0, None, :]
         vol = np.abs(np.linalg.det(vecs)) / 6
+        weight = np.ones(self.support.n_elements, dtype=float)
+        if mask_fn is not None:
+            weight[mask_fn(self.support.barycentre)] = 0
+        weight = weight[::step]
         if fold_orientation is not None:
             """
             dot product between vector in deformed ori plane = 0
@@ -120,7 +125,7 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             B = np.zeros(A.shape[0])
             idc = self.support.get_elements()[element_idx[::step], :]
             self.add_constraints_to_least_squares(
-                A, B, idc, w=fold_orientation, name="fold orientation"
+                A, B, idc, w=weight * fold_orientation, name="fold orientation"
             )
 
         if fold_axis_w is not None:
@@ -139,7 +144,9 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             B = np.zeros(A.shape[0]).tolist()
             idc = self.support.get_elements()[element_idx[::step], :]
 
-            self.add_constraints_to_least_squares(A, B, idc, w=fold_axis_w, name="fold axis")
+            self.add_constraints_to_least_squares(
+                A, B, idc, w=weight * fold_axis_w, name="fold axis"
+            )
 
         if fold_normalisation is not None:
             """
@@ -160,7 +167,7 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             idc = self.support.get_elements()[element_idx[::step], :]
 
             self.add_constraints_to_least_squares(
-                A, B, idc, w=fold_normalisation, name="fold normalisation"
+                A, B, idc, w=weight * fold_normalisation, name="fold normalisation"
             )
 
         if fold_regularisation is not None:

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