LoopStructural 1.6.13__tar.gz → 1.6.15__tar.gz

{loopstructural-1.6.13 → loopstructural-1.6.15}/LoopStructural/datatypes/_bounding_box.py

@@ -17,6 +17,7 @@ class BoundingBox:
         origin: Optional[np.ndarray] = None,
         maximum: Optional[np.ndarray] = None,
         global_origin: Optional[np.ndarray] = None,
+        global_maximum: Optional[np.ndarray] = None,
         nsteps: Optional[np.ndarray] = None,
         step_vector: Optional[np.ndarray] = None,
         dimensions: Optional[int] = 3,
@@ -39,9 +40,12 @@ class BoundingBox:
         # we want the local coordinates to start at 0
         # otherwise uses provided origin. This is useful for having multiple bounding boxes rela
         if global_origin is not None and origin is None:
-            origin = np.zeros(global_origin.shape)
+            origin = np.zeros(np.array(global_origin).shape)
+        if global_maximum is not None and global_origin is not None:
+            maximum = np.array(global_maximum) - np.array(global_origin)
+        
         if maximum is None and nsteps is not None and step_vector is not None:
-            maximum = origin + nsteps * step_vector
+            maximum = np.array(origin) + np.array(nsteps) * np.array(step_vector)
         if origin is not None and global_origin is None:
             global_origin = np.zeros(3)
         self._origin = np.array(origin)
@@ -281,6 +285,7 @@ class BoundingBox:
             origin=origin,
             maximum=maximum,
             global_origin=self.global_origin,
+            nsteps=self.nsteps,
             dimensions=self.dimensions,
         )
 
@@ -499,48 +504,53 @@ class BoundingBox:
             name=name,
         )
 
-    def project(self, xyz):
+    def project(self, xyz, inplace=False):
         """Project a point into the bounding box
 
         Parameters
         ----------
         xyz : np.ndarray
             point to project
+        inplace : bool, optional
+            Whether to modify the input array in place, by default False
 
         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)
+        if inplace:
+            xyz -= self.global_origin
+            return xyz
+        return (xyz - self.global_origin)  # np.clip(xyz, self.origin, self.maximum)
 
     def scale_by_projection_factor(self, value):
         return value / np.max((self.global_maximum - self.global_origin))
 
-    def reproject(self, xyz):
+    def reproject(self, xyz, inplace=False):
         """Reproject a point from the bounding box to the global space
 
         Parameters
         ----------
         xyz : np.ndarray
             point to reproject
-
+        inplace : bool, optional
+            Whether to modify the input array in place, by default False
         Returns
         -------
         np.ndarray
             reprojected point
         """
-
-        return xyz * np.max((self.global_maximum - self.global_origin)) + self.global_origin
+        if inplace:
+            xyz += self.global_origin
+            return xyz
+        return xyz + self.global_origin
 
     def __repr__(self):
-        return f"BoundingBox({self.origin}, {self.maximum}, {self.nsteps})"
+        return f"BoundingBox(origin:{self.origin}, maximum:{self.maximum}, nsteps:{self.nsteps})"
 
     def __str__(self):
-        return f"BoundingBox({self.origin}, {self.maximum}, {self.nsteps})"
+        return f"BoundingBox(origin:{self.origin}, maximum:{self.maximum}, nsteps:{self.nsteps})"
 
     def __eq__(self, other):
         if not isinstance(other, BoundingBox):

{loopstructural-1.6.13 → loopstructural-1.6.15}/LoopStructural/datatypes/_point.py

@@ -157,7 +157,6 @@ class VectorPoints:
             try:
                 locations = bb.project(locations)
                 _projected = True
-                scale = bb.scale_by_projection_factor(scale)
             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')

{loopstructural-1.6.13 → loopstructural-1.6.15}/LoopStructural/export/exporters.py

@@ -423,7 +423,7 @@ def _write_vol_evtk(model, file_name, data_label, nsteps, real_coords=True):
 
     """
     # Define grid spacing
-    xyz = model.bounding_box.regular_grid(nsteps)
+    xyz = model.bounding_box.regular_grid(nsteps=nsteps)
     vals = model.evaluate_model(xyz, scale=False)
     if real_coords:
         model.rescale(xyz)
@@ -465,7 +465,7 @@ def _write_vol_gocad(model, file_name, data_label, nsteps, real_coords=True):
 
     """
     # Define grid spacing in model scale coords
-    xyz = model.bounding_box.regular_grid(nsteps)
+    xyz = model.bounding_box.regular_grid(nsteps=nsteps)
 
     vals = model.evaluate_model(xyz, scale=False)
     # Use FORTRAN style indexing for GOCAD VOXET

{loopstructural-1.6.13 → loopstructural-1.6.15}/LoopStructural/interpolators/__init__.py

@@ -3,6 +3,7 @@ Interpolators and interpolation supports
 
 """
 
+
 __all__ = [
     "InterpolatorType",
     "GeologicalInterpolator",
@@ -21,39 +22,12 @@ __all__ = [
     "StructuredGrid2D",
     "P2UnstructuredTetMesh",
 ]
-from enum import IntEnum
+from ._interpolatortype import InterpolatorType
 
 from ..utils import getLogger
 
 logger = getLogger(__name__)
 
-
-class InterpolatorType(IntEnum):
-    """
-    Enum for the different interpolator types
-
-    1-9 should cover interpolators with supports
-    9+ are data supported
-    """
-
-    BASE = 0
-    BASE_DISCRETE = 1
-    FINITE_DIFFERENCE = 2
-    DISCRETE_FOLD = 3
-    PIECEWISE_LINEAR = 4
-    PIECEWISE_QUADRATIC = 5
-    BASE_DATA_SUPPORTED = 10
-    SURFE = 11
-
-
-interpolator_string_map = {
-    "FDI": InterpolatorType.FINITE_DIFFERENCE,
-    "PLI": InterpolatorType.PIECEWISE_LINEAR,
-    "P2": InterpolatorType.PIECEWISE_QUADRATIC,
-    "P1": InterpolatorType.PIECEWISE_LINEAR,
-    "DFI": InterpolatorType.DISCRETE_FOLD,
-    'surfe': InterpolatorType.SURFE,
-}
 from ..interpolators._geological_interpolator import GeologicalInterpolator
 from ..interpolators._discrete_interpolator import DiscreteInterpolator
 from ..interpolators.supports import (
@@ -79,12 +53,38 @@ from ..interpolators._discrete_fold_interpolator import (
 )
 from ..interpolators._p2interpolator import P2Interpolator
 from ..interpolators._p1interpolator import P1Interpolator
-
+from ..interpolators._constant_norm import ConstantNormP1Interpolator, ConstantNormFDIInterpolator
 try:
     from ..interpolators._surfe_wrapper import SurfeRBFInterpolator
 except ImportError:
-    logger.warning("Surfe is not installed, SurfeRBFInterpolator will not be available")
-    SurfeRBFInterpolator = None
+    class SurfeRBFInterpolator(GeologicalInterpolator):
+        """
+        Dummy class to handle the case where Surfe is not installed.
+        This will raise a warning when used.
+        """
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "Surfe cannot be imported. Please install Surfe. pip install surfe/ conda install -c loop3d surfe"
+            ) 
+
+# Ensure compatibility between the fallback and imported class
+SurfeRBFInterpolator = SurfeRBFInterpolator
+
+
+interpolator_string_map = {
+    "FDI": InterpolatorType.FINITE_DIFFERENCE,
+    "PLI": InterpolatorType.PIECEWISE_LINEAR,
+    "P2": InterpolatorType.PIECEWISE_QUADRATIC,
+    "P1": InterpolatorType.PIECEWISE_LINEAR,
+    "DFI": InterpolatorType.DISCRETE_FOLD,
+    'surfe': InterpolatorType.SURFE,
+    "FDI_CN": InterpolatorType.FINITE_DIFFERENCE_CONSTANT_NORM,
+    "P1_CN": InterpolatorType.PIECEWISE_LINEAR_CONSTANT_NORM,
+
+}
+
+# Define the mapping after all imports
 interpolator_map = {
     InterpolatorType.BASE: GeologicalInterpolator,
     InterpolatorType.BASE_DISCRETE: DiscreteInterpolator,
@@ -94,6 +94,8 @@ interpolator_map = {
     InterpolatorType.PIECEWISE_QUADRATIC: P2Interpolator,
     InterpolatorType.BASE_DATA_SUPPORTED: GeologicalInterpolator,
     InterpolatorType.SURFE: SurfeRBFInterpolator,
+    InterpolatorType.PIECEWISE_LINEAR_CONSTANT_NORM: ConstantNormP1Interpolator,
+    InterpolatorType.FINITE_DIFFERENCE_CONSTANT_NORM: ConstantNormFDIInterpolator,
 }
 
 support_interpolator_map = {
@@ -111,9 +113,18 @@ support_interpolator_map = {
         3: SupportType.DataSupported,
         2: SupportType.DataSupported,
     },
+    InterpolatorType.PIECEWISE_LINEAR_CONSTANT_NORM:{
+        3: SupportType.TetMesh,
+        2: SupportType.P1Unstructured2d,
+    },
+    InterpolatorType.FINITE_DIFFERENCE_CONSTANT_NORM: {
+        3: SupportType.StructuredGrid,
+        2: SupportType.StructuredGrid2D,
+    }
 }
 
 from ._interpolator_factory import InterpolatorFactory
 from ._interpolator_builder import InterpolatorBuilder
 
-# from ._api import LoopInterpolator
+
+

loopstructural-1.6.15/LoopStructural/interpolators/_constant_norm.py

@@ -0,0 +1,205 @@
+import numpy as np
+
+from LoopStructural.interpolators._discrete_interpolator import DiscreteInterpolator
+from LoopStructural.interpolators._finite_difference_interpolator import FiniteDifferenceInterpolator
+from ._p1interpolator import P1Interpolator
+from typing import Optional, Union, Callable
+from scipy import sparse
+from LoopStructural.utils import rng
+
+class ConstantNormInterpolator:
+    """Adds a non linear constraint to an interpolator to constrain
+    the norm of the gradient to be a set value.
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    def __init__(self, interpolator: DiscreteInterpolator,basetype):
+        """Initialise the constant norm inteprolator
+        with a discrete interpolator.
+
+        Parameters
+        ----------
+        interpolator : DiscreteInterpolator
+            The discrete interpolator to add constant norm to.
+        """
+        self.basetype = basetype
+        self.interpolator = interpolator
+        self.support = interpolator.support
+        self.random_subset = False
+        self.norm_length = 1.0
+        self.n_iterations = 20
+        self.store_solution_history = False
+        self.solution_history = []#np.zeros((self.n_iterations, self.support.n_nodes))
+        self.gradient_constraint_store = []
+    def add_constant_norm(self, w:float):
+        """Add a constraint to the interpolator to constrain the norm of the gradient
+        to be a set value
+
+        Parameters
+        ----------
+        w : float
+            weighting of the constraint
+        """
+        if "constant norm" in self.interpolator.constraints:
+            _ = self.interpolator.constraints.pop("constant norm")
+        
+        element_indices = np.arange(self.support.elements.shape[0])
+        if self.random_subset:
+            rng.shuffle(element_indices)
+            element_indices = element_indices[: int(0.1 * self.support.elements.shape[0])]
+        vertices, gradient, elements, inside = self.support.get_element_gradient_for_location(
+            self.support.barycentre[element_indices]
+        )
+
+        t_g = gradient[:, :, :]
+        # t_n = gradient[self.support.shared_element_relationships[:, 1], :, :]
+        v_t = np.einsum(
+            "ijk,ik->ij",
+            t_g,
+            self.interpolator.c[self.support.elements[elements]],
+        )
+
+        v_t = v_t / np.linalg.norm(v_t, axis=1)[:, np.newaxis]
+        self.gradient_constraint_store.append(np.hstack([self.support.barycentre[element_indices],v_t]))
+        A1 = np.einsum("ij,ijk->ik", v_t, t_g)
+        volume = self.support.element_size[element_indices]
+        A1 = A1 / volume[:, np.newaxis]  # normalise by element size
+        
+        b = np.zeros(A1.shape[0]) + self.norm_length
+        b = b / volume  # normalise by element size
+        idc = np.hstack(
+            [
+                self.support.elements[elements],
+            ]
+        )
+        self.interpolator.add_constraints_to_least_squares(A1, b, idc, w=w, name="constant norm")
+
+    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:
+        """Solve the system of equations iteratively for the constant norm interpolator.
+
+        Parameters
+        ----------
+        solver : Optional[Union[Callable[[sparse.csr_matrix, np.ndarray], np.ndarray], str]], optional
+            Solver function or name, by default None
+        tol : Optional[float], optional
+            Tolerance for the solver, by default None
+        solver_kwargs : dict, optional
+            Additional arguments for the solver, by default {}
+
+        Returns
+        -------
+        bool
+            Success status of the solver
+        """
+        success = True
+        for i in range(self.n_iterations):
+            if i > 0:
+                self.add_constant_norm(w=(0.1 * i) ** 2 + 0.01)
+            # Ensure the interpolator is cast to P1Interpolator before calling solve_system
+            if isinstance(self.interpolator, self.basetype):
+                success = self.basetype.solve_system(self.interpolator, solver=solver, tol=tol, solver_kwargs=solver_kwargs)
+                if self.store_solution_history:
+
+                    self.solution_history.append(self.interpolator.c)
+            else:
+                raise TypeError("self.interpolator is not an instance of P1Interpolator")
+            if not success:
+                break
+        return success
+
+class ConstantNormP1Interpolator(P1Interpolator, ConstantNormInterpolator):
+    """Constant norm interpolator using P1 base interpolator
+
+    Parameters
+    ----------
+    P1Interpolator : class
+        The P1Interpolator class.
+    ConstantNormInterpolator : class
+        The ConstantNormInterpolator class.
+    """
+    def __init__(self, support):
+        """Initialise the constant norm P1 interpolator.
+
+        Parameters
+        ----------
+        support : _type_
+            _description_
+        """
+        P1Interpolator.__init__(self, support)
+        ConstantNormInterpolator.__init__(self, self, P1Interpolator)
+
+    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:
+        """Solve the system of equations for the constant norm P1 interpolator.
+
+        Parameters
+        ----------
+        solver : Optional[Union[Callable[[sparse.csr_matrix, np.ndarray], np.ndarray], str]], optional
+            Solver function or name, by default None
+        tol : Optional[float], optional
+            Tolerance for the solver, by default None
+        solver_kwargs : dict, optional
+            Additional arguments for the solver, by default {}
+
+        Returns
+        -------
+        bool
+            Success status of the solver
+        """
+        return ConstantNormInterpolator.solve_system(self, solver=solver, tol=tol, solver_kwargs=solver_kwargs)
+
+class ConstantNormFDIInterpolator(FiniteDifferenceInterpolator, ConstantNormInterpolator):
+    """Constant norm interpolator using finite difference base interpolator
+
+    Parameters
+    ----------
+    FiniteDifferenceInterpolator : class
+        The FiniteDifferenceInterpolator class.
+    ConstantNormInterpolator : class
+        The ConstantNormInterpolator class.
+    """
+    def __init__(self, support):
+        """Initialise the constant norm finite difference interpolator.
+
+        Parameters
+        ----------
+        support : _type_
+            _description_
+        """
+        FiniteDifferenceInterpolator.__init__(self, support)
+        ConstantNormInterpolator.__init__(self, self, FiniteDifferenceInterpolator)
+    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:
+        """Solve the system of equations for the constant norm finite difference interpolator.
+
+        Parameters
+        ----------
+        solver : Optional[Union[Callable[[sparse.csr_matrix, np.ndarray], np.ndarray], str]], optional
+            Solver function or name, by default None
+        tol : Optional[float], optional
+            Tolerance for the solver, by default None
+        solver_kwargs : dict, optional
+            Additional arguments for the solver, by default {}
+
+        Returns
+        -------
+        bool
+            Success status of the solver
+        """
+        return ConstantNormInterpolator.solve_system(self, solver=solver, tol=tol, solver_kwargs=solver_kwargs)

{loopstructural-1.6.13 → loopstructural-1.6.15}/LoopStructural/interpolators/_discrete_interpolator.py

@@ -42,7 +42,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
 
         self.shape = "rectangular"
         if self.shape == "square":
-            self.B = np.zeros(self.nx)
+            self.B = np.zeros(self.dof)
         self.c_ = 0
 
         self.solver = "cg"
@@ -60,7 +60,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         self.non_linear_constraints = []
         self.constraints = {}
         self.interpolation_weights = {}
-        logger.info("Creating discrete interpolator with {} degrees of freedom".format(self.nx))
+        logger.info("Creating discrete interpolator with {} degrees of freedom".format(self.dof))
         self.type = InterpolatorType.BASE_DISCRETE
 
     def set_nelements(self, nelements: int) -> int:
@@ -78,7 +78,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         return self.support.n_elements
 
     @property
-    def nx(self) -> int:
+    def dof(self) -> int:
         """Number of degrees of freedom for the interpolator
 
         Returns
@@ -125,7 +125,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         # self.region_function = region
         logger.info(
             "Cannot use region at the moment. Interpolation now uses region and has {} degrees of freedom".format(
-                self.nx
+                self.dof
             )
         )
 
@@ -175,7 +175,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         """
         self.constraints = {}
         self.c_ = 0
-        self.regularisation_scale = np.ones(self.nx)
+        self.regularisation_scale = np.ones(self.dof)
         logger.info("Resetting interpolation constraints")
 
     def add_constraints_to_least_squares(self, A, B, idc, w=1.0, name="undefined"):
@@ -219,6 +219,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         # normalise by rows of A
         # Should this be done? It should make the solution more stable
         length = np.linalg.norm(A, axis=1)
+        # length[length>0] = 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)
@@ -245,7 +246,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         rows = np.tile(rows, (A.shape[-1], 1)).T
         self.constraints[name] = {
             'matrix': sparse.coo_matrix(
-                (A.flatten(), (rows.flatten(), idc.flatten())), shape=(n_rows, self.nx)
+                (A.flatten(), (rows.flatten(), idc.flatten())), shape=(n_rows, self.dof)
             ).tocsc(),
             'b': B.flatten(),
             'w': w,
@@ -286,7 +287,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         A : numpy array
             matrix of coefficients
         bounds : numpy array
-            nx3 lower, upper, 1
+            n*3 lower, upper, 1
         idc : numpy array
             index of constraints in the matrix
         Returns
@@ -296,14 +297,14 @@ class DiscreteInterpolator(GeologicalInterpolator):
         # map from mesh node index to region node index
         gi = np.zeros(self.support.n_nodes, dtype=int)
         gi[:] = -1
-        gi[self.region] = np.arange(0, self.nx, dtype=int)
+        gi[self.region] = np.arange(0, self.dof, dtype=int)
         idc = gi[idc]
         rows = np.arange(0, idc.shape[0])
         rows = np.tile(rows, (A.shape[-1], 1)).T
 
         self.ineq_constraints[name] = {
             'matrix': sparse.coo_matrix(
-                (A.flatten(), (rows.flatten(), idc.flatten())), shape=(rows.shape[0], self.nx)
+                (A.flatten(), (rows.flatten(), idc.flatten())), shape=(rows.shape[0], self.dof)
             ).tocsc(),
             "bounds": bounds,
         }
@@ -431,7 +432,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
             np.ones((value.shape[0], 1)),
             l,
             u,
-            np.arange(0, self.nx, dtype=int),
+            np.arange(0, self.dof, dtype=int),
         )
 
     def add_equality_constraints(self, node_idx, values, name="undefined"):
@@ -454,7 +455,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         # map from mesh node index to region node index
         gi = np.zeros(self.support.n_nodes)
         gi[:] = -1
-        gi[self.region] = np.arange(0, self.nx)
+        gi[self.region] = np.arange(0, self.dof)
         idc = gi[node_idx]
         outside = ~(idc == -1)
 
@@ -515,7 +516,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         if len(self.equal_constraints) > 0:
             ATA = A.T.dot(A)
             ATB = A.T.dot(B)
-            logger.info(f"Equality block is {self.eq_const_c} x {self.nx}")
+            logger.info(f"Equality block is {self.eq_const_c} x {self.dof}")
             # solving constrained least squares using
             # | ATA CT | |c| = b
             # | C   0  | |y|   d
@@ -540,7 +541,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
 
             C = sparse.coo_matrix(
                 (np.array(a), (np.array(rows), cols)),
-                shape=(self.eq_const_c, self.nx),
+                shape=(self.eq_const_c, self.dof),
                 dtype=float,
             ).tocsr()
 
@@ -557,7 +558,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
             mats.append(c['matrix'])
             bounds.append(c['bounds'])
         if len(mats) == 0:
-            return sparse.csr_matrix((0, self.nx), dtype=float), np.zeros((0, 3))
+            return sparse.csr_matrix((0, self.dof), dtype=float), np.zeros((0, 3))
         Q = sparse.vstack(mats)
         bounds = np.vstack(bounds)
         return Q, bounds