LoopStructural 1.6.1__py3-none-any.whl

LoopStructural/interpolators/_p1interpolator.py

@@ -0,0 +1,228 @@
+"""
+Piecewise linear interpolator
+"""
+
+import logging
+
+import numpy as np
+
+from ._discrete_interpolator import DiscreteInterpolator
+
+logger = logging.getLogger(__name__)
+
+
+class P1Interpolator(DiscreteInterpolator):
+    def __init__(self, mesh):
+        """
+        Piecewise Linear Interpolator
+        Approximates scalar field by finding coefficients to a piecewise linear
+        equation on a tetrahedral mesh. Uses constant gradient regularisation.
+
+        Parameters
+        ----------
+        mesh - TetMesh
+            interpolation support
+        """
+
+        self.shape = "rectangular"
+        DiscreteInterpolator.__init__(self, mesh)
+        # whether to assemble a rectangular matrix or a square matrix
+        self.support = mesh
+
+        self.interpolation_weights = {
+            "cgw": 0.1,
+            "cpw": 1.0,
+            "npw": 1.0,
+            "gpw": 1.0,
+            "tpw": 1.0,
+            "ipw": 1.0,
+        }
+
+    def add_gradient_constraints(self, w=1.0):
+        pass
+
+    def add_norm_constraints(self, w=1.0):
+        points = self.get_norm_constraints()
+        if points.shape[0] > 0:
+            grad, elements, inside = self.support.evaluate_shape_derivatives(points[:, :3])
+            size = self.support.element_size[elements[inside]]
+            wt = np.ones(size.shape[0])
+            wt *= w  # s* size
+            elements = np.tile(self.support.elements[elements[inside]], (3, 1, 1))
+
+            elements = elements.swapaxes(0, 1)
+            # elements = elements.swapaxes(0, 2)
+            # grad = grad.swapaxes(1, 2)
+            # elements = elements.swapaxes(1, 2)
+
+            self.add_constraints_to_least_squares(
+                grad[inside, :, :],
+                points[inside, 3:6],
+                elements,
+                w=wt,
+                name="norm",
+            )
+            self.up_to_date = False
+        pass
+
+    def add_value_constraints(self, w=1.0):
+        points = self.get_value_constraints()
+        if points.shape[0] > 1:
+            N, elements, inside = self.support.evaluate_shape(points[:, :3])
+            size = self.support.element_size[elements[inside]]
+            wt = np.ones(size.shape[0])
+            wt *= w  # * size
+            self.add_constraints_to_least_squares(
+                N[inside, :],
+                points[inside, 3],
+                self.support.elements[elements[inside], :],
+                w=wt,
+                name="value",
+            )
+            self.up_to_date = False
+
+    def minimise_edge_jumps(self, w=0.1, vector_func=None, vector=None, name="edge jump"):
+        # NOTE: imposes \phi_T1(xi)-\phi_T2(xi) dot n =0
+        # iterate over all triangles
+        # flag inidicate which triangles have had all their relationships added
+        v1 = self.support.nodes[self.support.shared_elements][:, 0, :]
+        v2 = self.support.nodes[self.support.shared_elements][:, 1, :]
+        bc_t1 = self.support.barycentre[self.support.shared_element_relationships[:, 0]]
+        bc_t2 = self.support.barycentre[self.support.shared_element_relationships[:, 1]]
+        norm = self.support.shared_element_norm
+        # shared_element_scale = self.support.shared_element_scale
+
+        # evaluate normal if using vector func for cp2
+        if vector_func:
+            norm = vector_func((v1 + v2) / 2)
+        if vector is not None:
+            if bc_t1.shape[0] == vector.shape[0]:
+                norm = vector
+        # evaluate the shape function for the edges for each neighbouring triangle
+        Dt, tri1, inside = self.support.evaluate_shape_derivatives(
+            bc_t1, elements=self.support.shared_element_relationships[:, 0]
+        )
+        Dn, tri2, inside = self.support.evaluate_shape_derivatives(
+            bc_t2, elements=self.support.shared_element_relationships[:, 1]
+        )
+        # constraint for each cp is triangle - neighbour create a Nx12 matrix
+        const_t = np.einsum("ij,ijk->ik", norm, Dt)
+        const_n = -np.einsum("ij,ijk->ik", norm, Dn)
+        # const_t_cp2 = np.einsum('ij,ikj->ik',normal,cp2_Dt)
+        # const_n_cp2 = -np.einsum('ij,ikj->ik',normal,cp2_Dn)
+
+        const = np.hstack([const_t, const_n])
+
+        # get vertex indexes
+        tri_cp1 = np.hstack([self.support.elements[tri1], self.support.elements[tri2]])
+        # tri_cp2 = np.hstack([self.support.elements[cp2_tri1],self.support.elements[tri2]])
+        # add cp1 and cp2 to the least squares system
+        self.add_constraints_to_least_squares(
+            const,
+            np.zeros(const.shape[0]),
+            tri_cp1,
+            w=w,
+            name=name,
+        )
+        self.up_to_date = False
+        # p2.add_constraints_to_least_squares(const_cp2*e_len[:,None]*w,np.zeros(const_cp1.shape[0]),tri_cp2, name='edge jump cp2')
+
+    def setup_interpolator(self, **kwargs):
+        """
+        Searches through kwargs for any interpolation weights and updates
+        the dictionary.
+        Then adds the constraints to the linear system using the
+        interpolation weights values
+        Parameters
+        ----------
+        kwargs -
+            interpolation weights
+
+        Returns
+        -------
+
+        """
+        # can't reset here, clears fold constraints
+        self.reset()
+        for key in kwargs:
+            if "regularisation" in kwargs:
+                self.interpolation_weights["cgw"] = 0.1 * kwargs["regularisation"]
+            self.up_to_date = False
+            self.interpolation_weights[key] = kwargs[key]
+        if self.interpolation_weights["cgw"] > 0.0:
+            self.up_to_date = False
+            self.minimise_edge_jumps(self.interpolation_weights["cgw"])
+            #     direction_feature=kwargs.get("direction_feature", None),
+            #     direction_vector=kwargs.get("direction_vector", None),
+            # )
+            # self.minimise_grad_steepness(
+            #     w=self.interpolation_weights.get("steepness_weight", 0.01),
+            #     wtfunc=self.interpolation_weights.get("steepness_wtfunc", None),
+            # )
+            logger.info(
+                "Using constant gradient regularisation w = %f" % self.interpolation_weights["cgw"]
+            )
+
+        logger.info(
+            "Added %i gradient constraints, %i normal constraints,"
+            "%i tangent constraints and %i value constraints"
+            % (self.n_g, self.n_n, self.n_t, self.n_i)
+        )
+        self.add_gradient_constraints(self.interpolation_weights["gpw"])
+        self.add_norm_constraints(self.interpolation_weights["npw"])
+        self.add_value_constraints(self.interpolation_weights["cpw"])
+        self.add_tangent_constraints(self.interpolation_weights["tpw"])
+        self.add_value_inequality_constraints()
+        self.add_inequality_pairs_constraints()
+        # self.add_interface_constraints(self.interpolation_weights["ipw"])
+
+    def add_gradient_orthogonal_constraints(
+        self,
+        points: np.ndarray,
+        vectors: np.ndarray,
+        w: float = 1.0,
+        B: float = 0,
+        name='undefined gradient orthogonal constraint',
+    ):
+        """
+        constraints scalar field to be orthogonal to a given vector
+
+        Parameters
+        ----------
+        points : np.darray
+            location to add gradient orthogonal constraint
+        vector : np.darray
+            vector to be orthogonal to, should be the same shape as points
+        w : double
+        B : np.array
+
+        Returns
+        -------
+
+        """
+        if points.shape[0] > 0:
+            grad, elements, inside = self.support.evaluate_shape_derivatives(points[:, :3])
+            size = self.support.element_size[elements[inside]]
+            wt = np.ones(size.shape[0])
+            wt *= w * size
+            elements = self.support.elements[elements[inside], :]
+            # elements = np.tile(self.support.elements[elements[inside]], (3, 1, 1))
+
+            # elements = elements.swapaxes(0, 1)
+            # elements = elements.swapaxes(0, 2)
+            # grad = grad.swapaxes(1, 2)
+            # elements = elements.swapaxes(1, 2)
+            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")
+            if np.sum(inside) <= 0:
+                logger.warning(
+                    f"{np.sum(~inside)} \
+                        gradient constraints not added: outside of model bounding box"
+                )
+            self.up_to_date = False
+
+    def add_interface_constraints(self, w: float = 1):
+        raise NotImplementedError

LoopStructural/interpolators/_p2interpolator.py

@@ -0,0 +1,277 @@
+"""
+Piecewise linear interpolator
+"""
+
+import logging
+from typing import Optional, Callable
+
+import numpy as np
+
+from ..interpolators import DiscreteInterpolator
+
+logger = logging.getLogger(__name__)
+
+
+class P2Interpolator(DiscreteInterpolator):
+    """ """
+
+    def __init__(self, mesh):
+        """
+        Piecewise Linear Interpolator
+        Approximates scalar field by finding coefficients to a piecewise linear
+        equation on a tetrahedral mesh. Uses constant gradient regularisation.
+
+        Parameters
+        ----------
+        mesh - TetMesh
+            interpolation support
+        """
+
+        self.shape = "rectangular"
+        DiscreteInterpolator.__init__(self, mesh)
+        # whether to assemble a rectangular matrix or a square matrix
+        self.interpolator_type = "P2"
+        self.support = mesh
+
+        self.interpolation_weights = {
+            "cgw": 0.1,
+            "cpw": 1.0,
+            "npw": 1.0,
+            "gpw": 1.0,
+            "tpw": 1.0,
+            "ipw": 1.0,
+        }
+
+    def setup_interpolator(self, **kwargs):
+        """
+        Searches through kwargs for any interpolation weights and updates
+        the dictionary.
+        Then adds the constraints to the linear system using the
+        interpolation weights values
+        Parameters
+        ----------
+        kwargs -
+            interpolation weights
+
+        Returns
+        -------
+
+        """
+        # can't reset here, clears fold constraints
+        # self.reset()
+        for key in kwargs:
+            if "regularisation" in kwargs:
+                self.interpolation_weights["cgw"] = 0.1 * kwargs["regularisation"]
+            self.up_to_date = False
+            self.interpolation_weights[key] = kwargs[key]
+        if self.interpolation_weights["cgw"] > 0.0:
+            self.up_to_date = False
+            self.minimise_edge_jumps(self.interpolation_weights["cgw"])
+            #     direction_feature=kwargs.get("direction_feature", None),
+            #     direction_vector=kwargs.get("direction_vector", None),
+            # )
+            self.minimise_grad_steepness(
+                w=self.interpolation_weights.get("steepness_weight", 0.01),
+                wtfunc=self.interpolation_weights.get("steepness_wtfunc", None),
+            )
+            logger.info(
+                "Using constant gradient regularisation w = %f" % self.interpolation_weights["cgw"]
+            )
+
+        logger.info(
+            "Added %i gradient constraints, %i normal constraints,"
+            "%i tangent constraints and %i value constraints"
+            % (self.n_g, self.n_n, self.n_t, self.n_i)
+        )
+        self.add_gradient_constraints(self.interpolation_weights["gpw"])
+        self.add_norm_constraints(self.interpolation_weights["npw"])
+        self.add_value_constraints(self.interpolation_weights["cpw"])
+        self.add_tangent_constraints(self.interpolation_weights["tpw"])
+        # self.add_interface_constraints(self.interpolation_weights["ipw"])
+
+    def copy(self):
+        return P2Interpolator(self.support)
+
+    def add_gradient_constraints(self, w: float = 1.0):
+        points = self.get_gradient_constraints()
+        if points.shape[0] > 0:
+            grad, elements = self.support.evaluate_shape_derivatives(points[:, :3])
+            inside = elements > -1
+            area = self.support.element_size[elements[inside]]
+            wt = np.ones(area.shape[0])
+            wt *= w * area
+            A = np.einsum("ikj,ij->ik", grad[inside, :], points[inside, 3:6])
+            B = np.zeros(A.shape[0])
+            elements = self.support[elements[inside]]
+            self.add_constraints_to_least_squares(A * wt[:, None], B, elements, name="gradient")
+
+    def add_gradient_orthogonal_constraints(
+        self, points: np.ndarray, vector: np.ndarray, w=1.0, B=0
+    ):
+        """
+        constraints scalar field to be orthogonal to a given vector
+
+        Parameters
+        ----------
+        position
+        normals
+        w
+        B
+
+        Returns
+        -------
+
+        """
+        if points.shape[0] > 0:
+            grad, elements = self.support.evaluate_shape_derivatives(points[:, :3])
+            inside = elements > -1
+            area = self.support.element_size[elements[inside]]
+            wt = np.ones(area.shape[0])
+            wt *= w * area
+            A = np.einsum("ijk,ij->ik", grad[inside, :], vector[inside, :])
+            B = np.zeros(A.shape[0])
+            elements = self.support.elements[elements[inside]]
+            self.add_constraints_to_least_squares(
+                A * wt[:, None], B, elements, name="gradient orthogonal"
+            )
+
+    def add_norm_constraints(self, w: float = 1.0):
+        points = self.get_norm_constraints()
+        if points.shape[0] > 0:
+            grad, elements = self.support.evaluate_shape_derivatives(points[:, :3])
+            inside = elements > -1
+            area = self.support.element_size[elements[inside]]
+            wt = np.ones(area.shape[0])
+            wt *= w * area
+            elements = np.tile(self.support.elements[elements[inside]], (3, 1, 1))
+            elements = elements.swapaxes(0, 1)
+            self.add_constraints_to_least_squares(
+                grad[inside, :, :] * wt[:, None, None],
+                points[inside, 3:6] * wt[:, None],
+                elements,
+                name="norm",
+            )
+
+    def add_value_constraints(self, w: float = 1.0):
+        points = self.get_value_constraints()
+        if points.shape[0] > 1:
+            N, elements, mask = self.support.evaluate_shape(points[:, :3])
+            # mask = elements > 0
+            size = self.support.element_size[elements[mask]]
+            wt = np.ones(size.shape[0])
+            wt *= w
+            self.add_constraints_to_least_squares(
+                N[mask, :],
+                points[mask, 3],
+                self.support.elements[elements[mask], :],
+                w=wt,
+                name="value",
+            )
+
+    def minimise_grad_steepness(
+        self,
+        w: float = 0.1,
+        maskall: bool = False,
+        wtfunc: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+    ):
+        """This constraint minimises the second derivative of the gradient
+        mimimising the 2nd derivative should prevent high curvature solutions
+        It is not added on the borders
+
+        Parameters
+        ----------
+        w : float, optional
+            [description], by default 0.1
+        maskall : bool, default False
+            whether to apply on all elements or just internal elements (default)
+        wtfunc :  callable, optional
+            a function that returns the weight to be applied at xyz. Called on the barycentre
+            of the tetrahedron
+        """
+        elements = np.arange(0, len(self.support.elements))
+        mask = np.ones(self.support.neighbours.shape[0], dtype=bool)
+        if not maskall:
+            mask[:] = np.all(self.support.neighbours > 3, axis=1)
+
+        d2 = self.support.evaluate_shape_d2(elements[mask])
+        # d2 shape is [ele_idx, deriv, node]
+        wt = np.ones(d2.shape[0])
+        wt *= w  # * self.support.element_size[mask]
+        if callable(wtfunc):
+            logger.info("Using function to weight gradient steepness")
+            wt = wtfunc(self.support.barycentre) * self.support.element_size[mask]
+        idc = self.support.elements[elements[mask]]
+        for i in range(d2.shape[1]):
+            self.add_constraints_to_least_squares(
+                d2[:, i, :],
+                np.zeros(d2.shape[0]),
+                idc[:, :],
+                w=wt,
+                name=f"gradsteepness_{i}",
+            )
+
+    def minimise_edge_jumps(
+        self,
+        w: float = 0.1,
+        wtfunc: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+        vector_func: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+        quadrature_points: Optional[int] = None,
+    ):
+        """_summary_
+
+        Parameters
+        ----------
+        w : float, optional
+            _description_, by default 0.1
+        wtfunc : callable, optional
+            _description_, by default None
+        vector_func : callable, optional
+            _description_, by default None
+        """
+        # NOTE: imposes \phi_T1(xi)-\phi_T2(xi) dot n =0
+        # iterate over all triangles
+
+        cp, weight = self.support.get_quadrature_points()
+
+        norm = self.support.shared_element_norm
+
+        # evaluate normal if using vector func for cp1
+        for i in range(cp.shape[1]):
+            if callable(vector_func):
+                norm = vector_func(cp[:, i, :])
+            # evaluate the shape function for the edges for each neighbouring triangle
+            cp_Dt, cp_tri1 = self.support.evaluate_shape_derivatives(
+                cp[:, i, :], elements=self.support.shared_element_relationships[:, 0]
+            )
+            cp_Dn, cp_tri2 = self.support.evaluate_shape_derivatives(
+                cp[:, i, :], elements=self.support.shared_element_relationships[:, 1]
+            )
+            # constraint for each cp is triangle - neighbour create a Nx12 matrix
+            const_t_cp = np.einsum("ij,ijk->ik", norm, cp_Dt)
+            const_n_cp = -np.einsum("ij,ijk->ik", norm, cp_Dn)
+
+            const_cp = np.hstack([const_t_cp, const_n_cp])
+            tri_cp = np.hstack([self.support.elements[cp_tri1], self.support.elements[cp_tri2]])
+            wt = np.zeros(tri_cp.shape[0])
+            wt[:] = w * weight[:, i]
+            if wtfunc:
+                wt = wtfunc(tri_cp)
+            self.add_constraints_to_least_squares(
+                const_cp,
+                np.zeros(const_cp.shape[0]),
+                tri_cp,
+                w=wt,
+                name=f"shared element jump cp{i}",
+            )
+
+    def evaluate_d2(self, evaluation_points: np.ndarray) -> np.ndarray:
+        evaluation_points = np.array(evaluation_points)
+        evaluated = np.zeros(evaluation_points.shape[0])
+        mask = np.any(evaluation_points == np.nan, axis=1)
+
+        if evaluation_points[~mask, :].shape[0] > 0:
+            evaluated[~mask] = self.support.evaluate_d2(evaluation_points[~mask], self.c)
+        return evaluated
+
+    def add_interface_constraints(self, w: float = 1):
+        raise NotImplementedError

LoopStructural/interpolators/_surfe_wrapper.py

@@ -0,0 +1,174 @@
+"""
+Wrapper for using surfepy
+"""
+
+from ..utils.helper import get_vectors
+from ..interpolators import GeologicalInterpolator
+
+import numpy as np
+
+from ..utils import getLogger
+
+logger = getLogger(__name__)
+import surfepy
+
+
+class SurfeRBFInterpolator(GeologicalInterpolator):
+    """ """
+
+    def __init__(self, method="single_surface"):
+        GeologicalInterpolator.__init__(self)
+        self.surfe = None
+        if method == "single_surface":
+            logger.info("Using single surface interpolator")
+            self.surfe = surfepy.Surfe_API(1)
+        if method == "Lajaunie" or method == "increments":
+            logger.info("Using Lajaunie method")
+            self.surfe = surfepy.Surfe_API(2)
+        if method == "horizons":
+            logger.info("Using surfe horizon")
+            self.surfe = surfepy.Surfe_API(4)
+
+    def add_gradient_ctr_pts(self):
+        points = self.get_gradient_constraints()
+        if points.shape[0] > 0:
+            logger.info("Adding ")
+            strike_vector, dip_vector = get_vectors(points[:, 3:6])
+
+            strike_vector = np.hstack([points[:, :3], strike_vector.T])
+            dip_vector = np.hstack([points[:, :3], dip_vector.T])
+            self.surfe.SetTangentConstraints(strike_vector)
+            self.surfe.SetTangentConstraints(dip_vector)
+
+    def add_norm_ctr_pts(self):
+        points = self.get_norm_constraints()
+        if points.shape[0] > 0:
+            self.surfe.SetPlanarConstraints(points[:, :6])
+
+    def add_ctr_pts(self):
+
+        points = self.get_value_constraints()
+        if points.shape[0] > 0:
+            # self.surfe.SetInterfaceConstraints(points[:,:4])
+            for i in range(points.shape[0]):
+
+                self.surfe.AddInterfaceConstraint(
+                    points[i, 0],
+                    points[i, 1],
+                    points[i, 2],
+                    points[i, 3],
+                )
+
+    def add_tangent_ctr_pts(self):
+        points = self.get_tangent_constraints()
+        if points.shape[0] > 0:
+            self.surfe.SetTangentConstraints(points[:, :6])
+
+    def _solve(self, **kwargs):
+        self.surfe.ComputeInterpolant()
+
+    def _setup_interpolator(self, **kwargs):
+        """
+        Setup the interpolator
+
+        Parameters
+        ----------
+        kernel: str
+            kernel for interpolation r3, r, Gaussian, Multiquadrics, Inverse Multiquadrics
+            Thin Plate Spline, WendlandC2, MaternC4
+        regression: float
+            smoothing parameter default 0
+        greedy: tuple
+            greedy parameters first is interface threshold, second is angular threshold
+             default (0,0)
+        poly_order: int
+            order of the polynomial used for interpolation, default 1
+        radius: float
+            radius of the kernel, default None but required for SPD kernels
+        anisotropy: bool
+            apply global anisotropy from eigenvectors of orientation constraints, default False
+
+
+        """
+        self.add_gradient_ctr_pts()
+        self.add_norm_ctr_pts()
+        self.add_ctr_pts()
+        self.add_tangent_ctr_pts()
+
+        kernel = kwargs.get("kernel", "r3")
+        logger.info("Setting surfe RBF kernel to %s" % kernel)
+        self.surfe.SetRBFKernel(kernel)
+        regression = kwargs.get("regression_smoothing", 0.0)
+        if regression > 0:
+            logger.info("Using regression smoothing %f" % regression)
+            self.surfe.SetRegressionSmoothing(True, regression)
+        greedy = kwargs.get("greedy", (0, 0))
+
+        if greedy[0] > 0 or greedy[1] > 0:
+            logger.info(
+                "Using greedy algorithm: inferface %f and angular %f" % (greedy[0], greedy[1])
+            )
+            self.surfe.SetGreedyAlgorithm(True, greedy[0], greedy[1])
+        poly_order = kwargs.get("poly_order", None)
+        if poly_order:
+            logger.info("Setting poly order to %i" % poly_order)
+            self.surfe.SetPolynomialOrder(poly_order)
+        global_anisotropy = kwargs.get("anisotropy", False)
+        if global_anisotropy:
+            logger.info("Using global anisotropy")
+            self.surfe.SetGlobalAnisotropy(global_anisotropy)
+        radius = kwargs.get("radius", False)
+        if radius:
+            logger.info("Setting RBF radius to %f" % radius)
+            self.surfe.SetRBFShapeParameter(radius)
+
+    def update(self):
+        return self.surfe.InterpolantComputed()
+
+    def evaluate_value(self, evaluation_points):
+        """Evaluate surfe interpolant at points
+
+        Parameters
+        ----------
+        evaluation_points : array of locations N,3
+            xyz of locations to evaluate
+
+        Returns
+        -------
+        np.array (N)
+            value of interpolant at points
+        """
+        evaluation_points = np.array(evaluation_points)
+        evaluated = np.zeros(evaluation_points.shape[0])
+        mask = np.any(evaluation_points == np.nan, axis=1)
+
+        if evaluation_points[~mask, :].shape[0] > 0:
+            evaluated[~mask] = self.surfe.EvaluateInterpolantAtPoints(evaluation_points[~mask])
+        return evaluated
+
+    def evaluate_gradient(self, evaluation_points):
+        """Evaluate surfe interpolant gradient at points
+
+        Parameters
+        ----------
+        evaluation_points : array of locations N,3
+            xyz of locations to evaluate
+
+        Returns
+        -------
+        np.array (N,3)
+            gradient of interpolant at points
+
+        """
+        evaluation_points = np.array(evaluation_points)
+        evaluated = np.zeros(evaluation_points.shape)
+        mask = np.any(evaluation_points == np.nan, axis=1)
+        if evaluation_points[~mask, :].shape[0] > 0:
+            evaluated[~mask, :] = self.surfe.EvaluateVectorInterpolantAtPoints(
+                evaluation_points[~mask]
+            )
+        return
+
+    @property
+    def nx(self):
+        return self.get_data_locations().shape[0]