LoopStructural 1.0.4__zip → 1.0.71.dev0__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/interpolators/discrete_fold_interpolator.py

@@ -9,7 +9,8 @@ from LoopStructural.interpolators.cython.dsi_helper import fold_cg
 from LoopStructural.interpolators.piecewiselinear_interpolator import \
     PiecewiseLinearInterpolator
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
@@ -82,9 +83,9 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
         logger.error('updating fold, this should be done by accessing the fold attribute')
         self.fold = fold
 
-    def add_fold_constraints(self, fold_orientation=10., fold_axis_w=10., fold_regularisation=.1,
+    def add_fold_constraints(self, fold_orientation=10., fold_axis_w=10., fold_regularisation=[.1,0.01,0.01],
                              fold_normalisation=1.,
-                             fold_norm=1.):
+                             fold_norm=1., step=2):
         """
 
         Parameters
@@ -93,12 +94,15 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             weight for the fold direction/orientation in the least squares system
         fold_axis_w : double
             weight for the fold axis in the least squares system
-        fold_regularisation : double
+        fold_regularisation : list
             weight for the fold regularisation in the least squares system
         fold_normalisation : double
             weight for the fold norm constraint in the least squares system
         fold_norm
             length of the interpolation norm in the least squares system
+        step: int
+            array step for adding constraints
+
 
         Returns
         -------
@@ -115,7 +119,8 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
         # calculate the fold geometry for the elements barycentre
         deformed_orientation, fold_axis, dgz = \
             self.fold.get_deformed_orientation(self.support.barycentre())
-
+        element_idx = np.arange(self.support.n_elements)
+        np.random.shuffle(element_idx)
         # calculate element volume for weighting
         vecs = nodes[:, 1:, :] - nodes[:, 0, None, :]
         vol = np.abs(np.linalg.det(vecs)) / 6
@@ -123,49 +128,75 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             """
             dot product between vector in deformed ori plane = 0
             """
+            np.random.shuffle(element_idx)
+
             logger.info("Adding fold orientation constraint to %s w = %f"%(self.propertyname, fold_orientation))
-            A = np.einsum('ij,ijk->ik', deformed_orientation, eg)
-            A *= vol[:, None]
+            A = np.einsum('ij,ijk->ik', deformed_orientation[element_idx[::step],:], eg[element_idx[::step],:,:])
+            A *= vol[element_idx[::step], None]
             A *= fold_orientation
-            B = np.zeros(self.support.n_elements)
-            idc = self.support.get_elements()
-            self.add_constraints_to_least_squares(A, B, idc)
+            B = np.zeros(A.shape[0])
+            idc = self.support.get_elements()[element_idx[::step],:]
+            self.add_constraints_to_least_squares(A, B, idc, name='fold orientation')
 
         if fold_axis_w is not None:
             """
             dot product between axis and gradient should be 0
             """
+            np.random.shuffle(element_idx)
+
             logger.info("Adding fold axis constraint to %s w = %f"%(self.propertyname,fold_axis_w))
-            A = np.einsum('ij,ijk->ik', fold_axis, eg)
-            A *= vol[:, None]
+            A = np.einsum('ij,ijk->ik', fold_axis[element_idx[::step],:], eg[element_idx[::step],:,:])
+            A *= vol[element_idx[::step], None]
             A *= fold_axis_w
-            B = np.zeros(self.support.n_elements).tolist()
-            self.add_constraints_to_least_squares(A, B, self.support.get_elements())
+            B = np.zeros(A.shape[0]).tolist()
+            idc = self.support.get_elements()[element_idx[::step],:]
+
+            self.add_constraints_to_least_squares(A, B, idc, name='fold axis')
 
         if fold_normalisation is not None:
             """
             specify scalar norm in X direction
             """
+            np.random.shuffle(element_idx)
+
             logger.info("Adding fold normalisation constraint to %s w = %f"%(self.propertyname,fold_normalisation))
-            A = np.einsum('ij,ijk->ik', dgz, eg)
-            A *= vol[:, None]
+            A = np.einsum('ij,ijk->ik', dgz[element_idx[::step],:], eg[element_idx[::step],:,:])
+            A *= vol[element_idx[::step], None]
             A *= fold_normalisation
-            B = np.ones(self.support.n_elements)
+            B = np.ones(A.shape[0])
 
             if fold_norm is not None:
                 B[:] = fold_norm
             B *= fold_normalisation
-            B *= vol
-            self.add_constraints_to_least_squares(A, B, self.support.get_elements())
+            B *= vol[element_idx[::step]]
+            idc = self.support.get_elements()[element_idx[::step],:]
+
+            self.add_constraints_to_least_squares(A, B, idc, name='fold normalisation')
 
         if fold_regularisation is not None:
             """
             fold constant gradient  
             """
-            logger.info("Adding fold regularisation constraint to %s w = %f"%(self.propertyname,fold_regularisation))
+            logger.info("Adding fold regularisation constraint to {} w = {} {} {}".format(self.propertyname,
+            fold_regularisation[0],fold_regularisation[1],fold_regularisation[1]))
+
             idc, c, ncons = fold_cg(eg, dgz, self.support.get_neighbours(), self.support.get_elements(), self.support.nodes)
             A = np.array(c[:ncons, :])
-            A *= fold_regularisation
+            A *= fold_regularisation[0]
+            B = np.zeros(A.shape[0])
+            idc = np.array(idc[:ncons, :])
+            self.add_constraints_to_least_squares(A, B, idc, name='fold regularisation 1')
+
+            idc, c, ncons = fold_cg(eg, deformed_orientation, self.support.get_neighbours(), self.support.get_elements(), self.support.nodes)
+            A = np.array(c[:ncons, :])
+            A *= fold_regularisation[1]
+            B = np.zeros(A.shape[0])
+            idc = np.array(idc[:ncons, :])
+            self.add_constraints_to_least_squares(A, B, idc, name='fold regularisation 2')
+
+            idc, c, ncons = fold_cg(eg, fold_axis, self.support.get_neighbours(), self.support.get_elements(), self.support.nodes)
+            A = np.array(c[:ncons, :])
+            A *= fold_regularisation[2]
             B = np.zeros(A.shape[0])
             idc = np.array(idc[:ncons, :])
-            self.add_constraints_to_least_squares(A, B, idc)
+            self.add_constraints_to_least_squares(A, B, idc, name='fold regularisation 3')

Miniconda/envs/loop/Lib/site-packages/LoopStructural/interpolators/discrete_interpolator.py

@@ -10,7 +10,8 @@ from scipy.sparse import linalg as sla
 from LoopStructural.interpolators.geological_interpolator import \
     GeologicalInterpolator
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class DiscreteInterpolator(GeologicalInterpolator):
@@ -30,12 +31,9 @@ class DiscreteInterpolator(GeologicalInterpolator):
         GeologicalInterpolator.__init__(self)
         self.B = []
         self.support = support
-        self.region_function = None
-        self.region = np.arange(0, support.n_nodes)
-        self.region_map = np.zeros(support.n_nodes).astype(int)
+        self.region_function = lambda xyz : np.ones(xyz.shape[0],dtype=int)
         # self.region_map[self.region] = np.array(range(0,
         # len(self.region_map[self.region])))
-        self.nx = len(self.support.nodes[self.region])
         self.shape = 'rectangular'
         if self.shape == 'square':
             self.B = np.zeros(self.nx)
@@ -51,7 +49,22 @@ class DiscreteInterpolator(GeologicalInterpolator):
         self.eq_const_c_ = 0
         self.constraints = {}
         self.interpolation_weights= {}
-
+        logger.info("Creating discrete interpolator with {} degrees of freedom".format(self.nx))
+
+    @property
+    def nx(self):
+        return len(self.support.nodes[self.region])
+
+    @property
+    def region(self):
+        return self.region_function(self.support.nodes)
+
+    @property
+    def region_map(self):
+        region_map = np.zeros(self.support.n_nodes).astype(int)
+        region_map[self.region] = np.array(
+            range(0, len(region_map[self.region])))
+        return region_map
     def set_property_name(self, propertyname):
         """
         Set the property name attribute, this is usually used to
@@ -83,12 +96,8 @@ class DiscreteInterpolator(GeologicalInterpolator):
         # evaluate the region function on the support to determine
         # which nodes are inside update region map and degrees of freedom
         self.region_function = region
-        self.region = region(self.support.nodes)
-        self.region_map = np.zeros(self.support.n_nodes).astype(int)
-        self.region_map[self.region] = np.array(
-            range(0, len(self.region_map[self.region])))
-        self.nx = len(self.support.nodes[self.region])
-        
+        logger.info("Interpolation now uses region and has {} degrees of freedom".format(self.nx))
+
     def set_interpolation_weights(self, weights):
         """
         Set the interpolation weights dictionary
@@ -147,21 +156,36 @@ class DiscreteInterpolator(GeologicalInterpolator):
         A = np.array(A)
         B = np.array(B)
         idc = np.array(idc)
-        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))
-            return
         nr = A.shape[0]
+        #logger.debug('Adding constraints to interpolator: {} {} {}'.format(A.shape[0]))
+        # print(A.shape,B.shape,idc.shape)
+        if A.shape != idc.shape:
+            return
+        
         if len(A.shape) > 2:
             nr = A.shape[0] * A.shape[1]
+            A = A.reshape((A.shape[0]*A.shape[1],A.shape[2]))
+            idc = idc.reshape((idc.shape[0]*idc.shape[1],idc.shape[2]))
+        # going to assume if any are nan they are all nan
+        mask = np.any(np.isnan(A),axis=1)
+        A[mask,:] = 0
+        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))
+            # return
+        
         rows = np.arange(0, nr).astype(int)
         rows += self.c_
         constraint_ids = rows.copy()
 
-        if name in self.constraints:
-            self.constraints[name] = np.hstack([self.constraints[name],
-                                                constraint_ids])
+        if name in self.constraints:            
+            
+            self.constraints[name]['A'] =  np.vstack([self.constraints[name]['A'],A])
+            self.constraints[name]['B'] =  np.hstack([self.constraints[name]['B'], B])
+            self.constraints[name]['idc'] = np.vstack([self.constraints[name]['idc'],
+                                                idc])
+                                   
         if name not in self.constraints:
-            self.constraints[name] = constraint_ids
+            self.constraints[name] = {'node_indexes':constraint_ids,'A':A,'B':B.flatten(),'idc':idc}
         rows = np.tile(rows, (A.shape[-1], 1)).T
 
         self.c_ += nr
@@ -176,7 +200,12 @@ class DiscreteInterpolator(GeologicalInterpolator):
             self.row.extend(rows[~mask].tolist())
             self.col.extend(idc[~mask].tolist())
             self.B.extend(B.tolist())
-
+    
+    def calculate_residual_for_constraints(self):
+        residuals = {}
+        for constraint_name, constraint in self.constraints:
+            residuals[constraint_name] = np.einsum('ij,ij->i',constraint['A'],self.c[constraint['idc'].astype(int)]) - constraint['B'].flatten()
+        return residuals
     def remove_constraints_from_least_squares(self, name='undefined',
                                               constraint_ids=None):
         """
@@ -345,7 +374,8 @@ class DiscreteInterpolator(GeologicalInterpolator):
         """
 
         lsqrargs = {}
-        # lsqrargs['tol'] = 1e-12
+        lsqrargs['tol'] = 1e-12
+        lsqrargs['atol'] = 0
         if 'iter_lim' in kwargs:
             logger.info("Using %i maximum iterations" % kwargs['iter_lim'])
             lsqrargs['iter_lim'] = kwargs['iter_lim']
@@ -427,7 +457,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
             cgargs['M'] = precon(A)
         return sla.cg(A, B, **cgargs)[0][:self.nx]
 
-    def _solve_pyamg(self, A, B):
+    def _solve_pyamg(self, A, B, tol=1e-12,x0=None,**kwargs):
         """
         Solve least squares system using pyamg algorithmic multigrid solver
 
@@ -441,7 +471,8 @@ class DiscreteInterpolator(GeologicalInterpolator):
 
         """
         import pyamg
-        return pyamg.solve(A, B, verb=False)[:self.nx]
+        logger.info("Solving using pyamg: tol {}".format(tol))
+        return pyamg.solve(A, B, tol=tol, x0=x0, verb=False)[:self.nx]
 
     def _solve(self, solver='cg', **kwargs):
         """
@@ -462,6 +493,8 @@ class DiscreteInterpolator(GeologicalInterpolator):
             True if the interpolation is run
 
         """
+        logger.info("Solving interpolation for {}".format(self.propertyname))
+
         self.c = np.zeros(self.support.n_nodes)
         self.c[:] = np.nan
         damp = True
@@ -487,7 +520,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
         if solver == 'pyamg':
             try:
                 logger.info("Solving with pyamg solve")
-                self.c[self.region] = self._solve_pyamg(A, B)
+                self.c[self.region] = self._solve_pyamg(A, B,**kwargs)
             except ImportError:
                 logger.warn("Pyamg not installed using cg instead")
                 self.c[self.region] = self._solve_cg(A, B)
@@ -497,12 +530,12 @@ class DiscreteInterpolator(GeologicalInterpolator):
             logger.warning("Using external solver")
             self.c[self.region] = kwargs['external'](A, B)[:self.nx]
         # check solution is not nan
-        self.support.properties[self.propertyname] = self.c
+        # self.support.properties[self.propertyname] = self.c
         if np.all(self.c == np.nan):
             logger.warning("Solver not run, no scalar field")
         # if solution is all 0, probably didn't work
         if np.all(self.c[self.region] == 0):
-            logger.warning("No solution, scalar field 0. Add more data.")
+            logger.warning("No solution, {} scalar field 0. Add more data.".format(self.propertyname))
 
     def update(self):
         """
@@ -530,7 +563,7 @@ class DiscreteInterpolator(GeologicalInterpolator):
 
         if evaluation_points[~mask, :].shape[0] > 0:
             evaluated[~mask] = self.support.evaluate_value(
-                evaluation_points[~mask], self.propertyname)
+                evaluation_points[~mask], self.c)
         return evaluated
 
     def evaluate_gradient(self, evaluation_points):
@@ -547,5 +580,5 @@ class DiscreteInterpolator(GeologicalInterpolator):
         """
         if evaluation_points.shape[0] > 0:
             return self.support.evaluate_gradient(evaluation_points,
-                                                  self.propertyname)
+                                                  self.c)
         return np.zeros((0, 3))

Miniconda/envs/loop/Lib/site-packages/LoopStructural/interpolators/finite_difference_interpolator.py

@@ -9,7 +9,8 @@ from LoopStructural.utils.helper import get_vectors
 from .discrete_interpolator import DiscreteInterpolator
 from .operator import Operator
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FiniteDifferenceInterpolator(DiscreteInterpolator):
@@ -41,7 +42,9 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                                       'cpw': 1.,
                                       'gpw': 1.,
                                       'npw': 1.,
-                                      'tpw': 1.})
+                                      'tpw': 1.,
+                                      'ipw': 1.
+                                      })
 
         self.vol = grid.step_vector[0] * grid.step_vector[1] * \
                    grid.step_vector[2]
@@ -72,7 +75,6 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         -------
 
         """
-
         for key in kwargs:
             self.up_to_date = False
             if 'regularisation' in kwargs:
@@ -126,6 +128,9 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         self.add_tangent_ctr_pts(
             np.sqrt(self.vol) * self.interpolation_weights['tpw']
         )
+        self.add_interface_ctr_pts(
+            np.sqrt(self.vol)*self.interpolation_weights['ipw']
+        )
 
     def copy(self):
         """
@@ -169,7 +174,58 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
 
             self.add_constraints_to_least_squares(a.T * w,
                                                   points[inside, 3] * w,
-                                                  idc[inside, :])
+                                                  idc[inside, :],
+                                                  name='value')
+    def add_interface_ctr_pts(self, w=1.0):  # for now weight all value points the same
+        """
+        Adds a constraint that defines all points with the same 'id' to be the same value
+        Sets all P1-P2 = 0 for all pairs of points
+
+        Parameters
+        ----------
+        w : double
+            weight
+
+        Returns
+        -------
+
+        """
+        # get elements for points
+        points = self.get_interface_constraints()
+        if points.shape[0] > 1:
+            node_idx, inside = self.support.position_to_cell_corners(
+                            points[:, :3])
+            # print(points[inside,:].shape)
+
+            gi = np.zeros(self.support.n_nodes)
+            gi[:] = -1
+            gi[self.region] = np.arange(0, self.nx)
+            idc = np.zeros(node_idx.shape)
+            idc[:] = -1
+
+            idc[inside, :] = gi[node_idx[inside, :]]
+            inside = np.logical_and(~np.any(idc == -1, axis=1), inside)
+            a = self.support.position_to_dof_coefs(points[inside, :3]).T
+            # create oversided array for storing constraints
+            A = np.zeros((a.shape[0]*a.shape[0],a.shape[1]*2))
+            interface_idc = np.zeros((a.shape[0]*a.shape[0],a.shape[1]*2),dtype=int)
+            interface_idc[:] = -1
+            c_i = 0
+            
+            for i in np.unique(points[np.logical_and(~np.isnan(points[:,3]),inside),3]):
+                mask = points[inside,3] == i
+                for p1 in range(points[inside][mask].shape[0]):
+                    for p2 in range(p1+1,points[inside][mask].shape[0]):
+                        A[c_i,:8] = a[mask][p1,:]
+                        A[c_i,8:] -= a[mask][p2,:]
+                        interface_idc[c_i,:8] = idc[inside,:][mask,:][p1,:]
+                        interface_idc[c_i,8:] = idc[inside,:][mask,:][p2,:]
+                        c_i+=1
+            outside = ~np.any(interface_idc == -1, axis=1) 
+            
+            self.add_constraints_to_least_squares(A[outside,:] * w,
+                                                    np.zeros(A[outside,:].shape[0]),
+                                                    interface_idc[outside, :], name='interface')
 
     def add_gradient_constraint(self, w=1.):
         """
@@ -206,9 +262,9 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             A = np.einsum('ij,ijk->ik', strike_vector.T, T)
 
             B = np.zeros(points[inside, :].shape[0])
-            self.add_constraints_to_least_squares(A * w, B, idc[inside, :])
+            self.add_constraints_to_least_squares(A * w, B, idc[inside, :], name='gradient')
             A = np.einsum('ij,ijk->ik', dip_vector.T, T)
-            self.add_constraints_to_least_squares(A * w, B, idc[inside, :])
+            self.add_constraints_to_least_squares(A * w, B, idc[inside, :], name='gradient')
 
     def add_norm_constraint(self, w=1.):
         """
@@ -246,13 +302,13 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             w /= 3
             self.add_constraints_to_least_squares(T[:, 0, :] * w,
                                                   points[inside, 3] * w,
-                                                  idc[inside, :])
+                                                  idc[inside, :], name='norm')
             self.add_constraints_to_least_squares(T[:, 1, :] * w,
                                                   points[inside, 4] * w,
-                                                  idc[inside, :])
+                                                  idc[inside, :], name='norm')
             self.add_constraints_to_least_squares(T[:, 2, :] * w,
                                                   points[inside, 5] * w,
-                                                  idc[inside, :])
+                                                  idc[inside, :], name='norm')
 
     def add_gradient_orthogonal_constraint(self, points, vector, w=1.0,
                                            B=0):
@@ -292,7 +348,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             A = np.einsum('ij,ijk->ik', vector[inside, :3], T)
 
             B = np.zeros(points[inside, :].shape[0])
-            self.add_constraints_to_least_squares(A * w, B, idc[inside, :])
+            self.add_constraints_to_least_squares(A * w, B, idc[inside, :], name='gradient orthogonal')
 
     def add_regularisation(self, operator, w=0.1):
         """
@@ -337,6 +393,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
         B = np.zeros(global_indexes.shape[1])
         self.add_constraints_to_least_squares(a[inside, :] * w,
                                               B[inside],
-                                              idc[inside, :]
+                                              idc[inside, :],
+                                              name='regularisation'
                                               )
         return

Miniconda/envs/loop/Lib/site-packages/LoopStructural/interpolators/geological_interpolator.py

@@ -5,7 +5,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class GeologicalInterpolator:
@@ -157,6 +158,12 @@ class GeologicalInterpolator:
         """
         return self.data['normal']
 
+    def get_data_locations(self):
+        norm = self.get_norm_constraints()
+        grad = self.get_gradient_constraints()
+        val = self.get_value_constraints()
+        return np.vstack([norm[:,:3],grad[:,:3],val[:,:3]])
+        
     def get_interface_constraints(self):
         return self.data['interface']
     def setup_interpolator(self, **kwargs):

Miniconda/envs/loop/Lib/site-packages/LoopStructural/interpolators/operator.py

@@ -5,7 +5,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class Operator(object):