LoopStructural 1.0.3__zip → 1.0.71.dev0__zip

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

@@ -1,3 +1,6 @@
+"""
+Piecewise linear interpolator
+"""
 import logging
 
 import numpy as np
@@ -6,7 +9,8 @@ from LoopStructural.interpolators.discrete_interpolator import \
     DiscreteInterpolator
 from LoopStructural.utils.helper import get_vectors
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class PiecewiseLinearInterpolator(DiscreteInterpolator):
@@ -29,11 +33,10 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
         DiscreteInterpolator.__init__(self, mesh)
         # whether to assemble a rectangular matrix or a square matrix
         self.interpolator_type = 'PLI'
-        self.nx = len(self.support.nodes[self.region])
         self.support = mesh
 
-        self.set_interpolation_weights({'cgw': 0.1, 'cpw': 1., 'npw': 1.,
-                                      'gpw': 1., 'tpw': 1.})
+        self.interpolation_weights = {'cgw': 0.1, 'cpw': 1., 'npw': 1.,
+                                      'gpw': 1., 'tpw': 1., 'ipw': 1.}
         self.__str = 'Piecewise Linear Interpolator with %i unknowns. \n' % \
                      self.nx
 
@@ -69,7 +72,10 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
             self.interpolation_weights[key] = kwargs[key]
         if self.interpolation_weights['cgw'] > 0.:
             self.up_to_date = False
-            self.add_constant_gradient(self.interpolation_weights['cgw'])
+            self.add_constant_gradient(self.interpolation_weights['cgw'],
+            direction_feature=kwargs.get('direction_feature',None),
+            direction_vector=kwargs.get('direction_vector',None)
+            )
             logger.info("Using constant gradient regularisation w = %f"
                         %self.interpolation_weights['cgw'])
         logger.info("Added %i gradient constraints, %i normal constraints,"
@@ -80,8 +86,11 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
         self.add_norm_ctr_pts(self.interpolation_weights['npw'])
         self.add_ctr_pts(self.interpolation_weights['cpw'])
         self.add_tangent_ctr_pts(self.interpolation_weights['tpw'])
-
-    def add_constant_gradient(self, w=0.1):
+        self.add_interface_ctr_pts(self.interpolation_weights['ipw'])
+        if 'constant_norm' in kwargs:
+            self.add_constant_norm(w=kwargs['constant_norm'])
+    
+    def add_constant_gradient(self, w= 0.1, direction_vector=None, direction_feature=None):
         """
         Add the constant gradient regularisation to the system
 
@@ -93,8 +102,17 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
         -------
 
         """
+        if direction_feature is not None:
+            print('dir fe')
+            direction_vector = direction_feature.evaluate_gradient(self.support.barycentre())
+        if direction_vector is not None:
+            if direction_vector.shape[0] == 1:
+                # if using a constant direction, tile array so it works for cg calc
+                direction_vector = np.tile(direction_vector,(self.support.barycentre().shape[0],1))
+
+            
         # iterate over all elements
-        A, idc, B = self.support.get_constant_gradient(region=self.region)
+        A, idc, B = self.support.get_constant_gradient(region=self.region,direction=direction_vector)
         A = np.array(A)
         B = np.array(B)
         idc = np.array(idc)
@@ -111,6 +129,79 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
                                               name='regularisation')
         return
 
+    def add_direction_constant_gradient(self, w= 0.1, direction_vector=None, direction_feature=None):
+        """
+        Add the constant gradient regularisation to the system where regularisation is projected
+        on a vector
+
+        Parameters
+        ----------
+        w (double) - weighting of the cg parameter
+        direction_vector
+        direction_feature
+
+        Returns
+        -------
+
+        """
+        if direction_feature:
+            print('dir fe')
+            direction_vector = direction_feature.evaluate_gradient(self.support.barycentre())
+        if direction_vector:
+            if direction_vector.shape[0] == 1:
+                # if using a constant direction, tile array so it works for cg calc
+                direction_vector = np.tile(direction_vector,(self.support.barycentre().shape[0],1))
+
+            
+        # iterate over all elements
+        A, idc, B = self.support.get_constant_gradient(region=self.region,direction=direction_vector)
+        A = np.array(A)
+        B = np.array(B)
+        idc = np.array(idc)
+
+        gi = np.zeros(self.support.n_nodes)
+        gi[:] = -1
+        gi[self.region] = np.arange(0, self.nx)
+        idc = gi[idc]
+        outside = ~np.any(idc == -1, axis=1)
+
+        # w/=A.shape[0]
+        self.add_constraints_to_least_squares(A[outside, :] * w,
+                                              B[outside] * w, idc[outside, :],
+                                              name='directional regularisation')
+        return
+
+
+    def add_constant_norm(self, w=0.1):
+        """
+        Add the constant gradient regularisation to the system
+
+        Parameters
+        ----------
+        w (double) - weighting of the cg parameter
+
+        Returns
+        -------
+
+        """
+        # iterate over all elements
+        A, idc, B = self.support.get_constant_norm(region=self.region)
+        A = np.array(A)
+        B = np.array(B)
+        idc = np.array(idc)
+
+        gi = np.zeros(self.support.n_nodes)
+        gi[:] = -1
+        gi[self.region] = np.arange(0, self.nx)
+        idc = gi[idc]
+        outside = ~np.any(idc == -1, axis=1)
+
+        # w/=A.shape[0]
+        self.add_constraints_to_least_squares(A[outside, :] * w,
+                                              B[outside] * w, idc[outside, :],
+                                              name='norm_regularisation')
+        return
+
     def add_gradient_ctr_pts(self, w=1.0):
         """
         Adds gradient constraints to the least squares system with a weight
@@ -131,6 +222,7 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
         requires at least two other
         value constraints OR a norm constraint for the interpolant to solve.
         """
+
         points = self.get_gradient_constraints()
         if points.shape[0] > 0:
             vertices, element_gradients, tetras, inside = self.support.get_tetra_gradient_for_location(points[:,:3])
@@ -226,7 +318,8 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
 
         Parameters
         ----------
-        w
+        w : double
+            weight
 
         Returns
         -------
@@ -255,6 +348,51 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
                                                   points[inside,:][outside, 3] * w * vol[outside],
                                                   idc[outside, :], 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:
+            vertices, c, tetras, inside = self.support.get_tetra_for_location(points[:,:3])
+            # calculate volume of tetras
+            vecs = vertices[inside, 1:, :] - vertices[inside, 0, None, :]
+            vol = np.abs(np.linalg.det(vecs)) / 6
+            A = c[inside]
+            A *= vol[:,None]
+            idc = tetras[inside,:]
+            for id in np.unique(points[np.logical_and(~np.isnan(points[:,3]),inside),3]):
+                mask = points[inside,3] == id
+                interface_A = A[None,mask,:] - A[mask,None,:]
+                interface_A = np.sum(interface_A,axis=0)
+                # interface_A = interface_A.reshape((interface_A.shape[0]*interface_A.shape[0],A.shape[1]))
+                interface_idc = idc[mask,:]
+
+                # now map the index from global to region create array size of mesh
+                # initialise as np.nan, then map points inside region to 0->nx
+                gi = np.zeros(self.support.n_nodes).astype(int)
+                gi[:] = -1
+
+                gi[self.region] = np.arange(0, self.nx)
+                interface_idc = gi[interface_idc]
+                # interface_idc = np.tile(interface_idc,(interface_idc.shape[0],1)).reshape(interface_A.shape)#flatten()
+                outside = ~np.any(interface_idc == -1, axis=1)
+                self.add_constraints_to_least_squares(interface_A[outside,:] * w,
+                                                      np.zeros(interface_A[outside,:].shape[0]),
+                                                      interface_idc[outside, :], name='interface')
+
     def add_gradient_orthogonal_constraint(self, points, vector, w=1.0,
                                            B=0):
         """
@@ -275,6 +413,7 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
             vertices, element_gradients, tetras, inside = self.support.get_tetra_gradient_for_location(points[:,:3])
             #e, inside = self.support.elements_for_array(points[:, :3])
             #nodes = self.support.nodes[self.support.elements[e]]
+            vector /= np.linalg.norm(vector,axis=1)[:,None]
             vecs = vertices[:, 1:, :] - vertices[:, 0, None, :]
             vol = np.abs(np.linalg.det(vecs))  # / 6
             # d_t = self.support.get_elements_gradients(e)
@@ -290,9 +429,9 @@ class PiecewiseLinearInterpolator(DiscreteInterpolator):
             gi[self.region] = np.arange(0, self.nx).astype(int)
             w /= 3
             idc = gi[tetras]
-            B = np.zeros(idc.shape[0])
+            B = np.zeros(idc.shape[0])+B
             outside = ~np.any(idc == -1, axis=1)
             self.add_constraints_to_least_squares(A[outside, :] * w,
-                                                  B[outside], idc[outside, :])
+                                                  B[outside], idc[outside, :], name='gradient_orthogonal')
 
 

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

@@ -1,11 +1,19 @@
+"""
+Cartesian grid for fold interpolator
+
+"""
 import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from .base_structured_3d_support import BaseStructuredSupport
+
 
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
-class StructuredGrid:
+
+class StructuredGrid(BaseStructuredSupport):
     """
 
     """
@@ -13,7 +21,7 @@ class StructuredGrid:
                  origin=np.zeros(3),
                  nsteps=np.array([10, 10, 10]),
                  step_vector=np.ones(3),
-                 maximum=None
+                 name=None
                  ):
         """
 
@@ -22,69 +30,15 @@ class StructuredGrid:
         origin - 3d list or numpy array
         nsteps - 3d list or numpy array of ints
         step_vector - 3d list or numpy array of int
-        maximum
         """
-
-        self.nsteps = np.array(nsteps)
-        self.step_vector = np.array(step_vector)
-        self.origin = np.array(origin)
-        # self.nsteps+=1
-        self.n_nodes = self.nsteps[0] * self.nsteps[1] * self.nsteps[2]
-        # self.nsteps-=1
-        self.dim = 3
-        self.nsteps_cells = self.nsteps - 1
-        self.n_cell_x = self.nsteps[0] - 1
-        self.n_cell_y = self.nsteps[1] - 1
-        self.n_cell_z = self.nsteps[2] - 1
-        self.properties = {}
-        self.n_elements = self.n_cell_x * self.n_cell_y * self.n_cell_z
-
-        # calculate the node positions using numpy (this should probably not
-        # be stored as it defeats
-        # the purpose of a structured grid
-
-        # self.barycentre = self.cell_centres(np.arange(self.n_elements))
-
+        BaseStructuredSupport.__init__(self,origin,nsteps,step_vector)
         self.regions = {}
         self.regions['everywhere'] = np.ones(self.n_nodes).astype(bool)
-
-    @property
-    def nodes(self):
-        max = self.origin + self.nsteps_cells * self.step_vector
-        x = np.linspace(self.origin[0], max[0], self.nsteps[0])
-        y = np.linspace(self.origin[1], max[1], self.nsteps[1])
-        z = np.linspace(self.origin[2], max[2], self.nsteps[2])
-        xx, yy, zz = np.meshgrid(x, y, z, indexing='ij')
-        return np.array([xx.flatten(order='F'), yy.flatten(order='F'),
-                               zz.flatten(order='F')]).T
+        self.name = name
 
     def barycentre(self):
         return self.cell_centres(np.arange(self.n_elements))
 
-    def print_geometry(self):
-        print('Origin: %f %f %f' % (
-            self.origin[0], self.origin[1], self.origin[2]))
-        print('Cell size: %f %f %f' % (
-            self.step_vector[0], self.step_vector[1], self.step_vector[2]))
-        max = self.origin + self.nsteps_cells * self.step_vector
-        print('Max extent: %f %f %f' % (max[0], max[1], max[2]))
-
-    def update_property(self, propertyname, values):
-        """[summary]
-
-        [extended_summary]
-
-        Parameters
-        ----------
-        propertyname : [type]
-            [description]
-        values : [type]
-            [description]
-        """
-        if values.shape[0] == self.n_nodes:
-            self.properties[propertyname] = values
-        if values.shape[0] == self.n_elements:
-            self.cell_properties[propertyname] = values
 
     def cell_centres(self, global_index):
         """[summary]
@@ -293,10 +247,10 @@ class StructuredGrid:
                  1, 1, 1, 1, 1, 1, 1, 1, 1]
             ])
         neighbours = indexes[:, None, :] + mask[:, :, None]
-        return neighbours[0, :, :] + self.nsteps[0, None, None] * neighbours[1,
+        return(neighbours[0, :, :] + self.nsteps[0, None, None] * neighbours[1,
                                                                   :, :] + \
                self.nsteps[0, None, None] * self.nsteps[
-                   1, None, None] * neighbours[2, :, :]
+                   1, None, None] * neighbours[2, :, :]).astype(np.int64)
 
     def cell_corner_indexes(self, x_cell_index, y_cell_index, z_cell_index):
         """
@@ -363,7 +317,7 @@ class StructuredGrid:
         globalidx[~inside] = -1
         return globalidx, inside
 
-    def evaluate_value(self, evaluation_points, property_name):
+    def evaluate_value(self, evaluation_points, property_array):
         """
         Evaluate the value of of the property at the locations.
         Trilinear interpolation dot corner values
@@ -377,28 +331,36 @@ class StructuredGrid:
         -------
 
         """
+        if property_array.shape[0] != self.n_nodes:
+            logger.error("Property array does not match grid")
+            raise BaseException
         idc, inside = self.position_to_cell_corners(evaluation_points)
         v = np.zeros(idc.shape)
         v[:, :] = np.nan
 
         v[inside, :] = self.position_to_dof_coefs(
             evaluation_points[inside, :]).T
-        v[inside, :] *= self.properties[property_name][idc[inside, :]]
+        
+        v[inside, :] *= property_array[idc[inside, :]]
+        
         return np.sum(v, axis=1)
 
-    def evaluate_gradient(self, evaluation_points, property_name):
+    def evaluate_gradient(self, evaluation_points, property_array):
+        if property_array.shape[0] != self.n_nodes:
+            logger.error("Property array does not match grid")
+            raise BaseException
         idc, inside = self.position_to_cell_corners(evaluation_points)
         T = np.zeros((idc.shape[0], 3, 8))
         T[inside, :, :] = self.calcul_T(evaluation_points[inside, :])
         # indices = np.array([self.position_to_cell_index(evaluation_points)])
         # idc = self.global_indicies(indices.swapaxes(0,1))
         # print(idc)
-        T[inside, 0, :] *= self.properties[property_name][idc[inside, :]]
-        T[inside, 1, :] *= self.properties[property_name][idc[inside, :]]
-        T[inside, 2, :] *= self.properties[property_name][idc[inside, :]]
+        T[inside, 0, :] *= property_array[idc[inside, :]]
+        T[inside, 1, :] *= property_array[idc[inside, :]]
+        T[inside, 2, :] *= property_array[idc[inside, :]]
         return np.array(
-            [np.sum(T[:, 0, :], axis=1) / 8, np.sum(T[:, 1, :], axis=1) / 8,
-             np.sum(T[:, 2, :], axis=1) / 8]).T
+            [np.sum(T[:, 0, :], axis=1), np.sum(T[:, 1, :], axis=1) ,
+             np.sum(T[:, 2, :], axis=1) ]).T
 
     def calcul_T(self, pos):
         """

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

@@ -1,9 +1,13 @@
+"""
+Tetmesh based on cartesian grid for piecewise linear interpolation
+"""
 import logging
 
 import numpy as np
-from LoopStructural.interpolators.cython.dsi_helper import cg
+from LoopStructural.interpolators.cython.dsi_helper import cg, constant_norm, fold_cg
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 class TetMesh:
     """
@@ -13,13 +17,14 @@ class TetMesh:
         self.origin = np.array(origin)
         self.step_vector = np.array(step_vector)
         self.nsteps = np.array(nsteps)
+        self.n_nodes = self.nsteps[0]*self.nsteps[1]*self.nsteps[2]
+
         self.nsteps_cells = self.nsteps - 1
         self.n_cell_x = self.nsteps[0] - 1
         self.n_cell_y = self.nsteps[1] - 1
         self.n_cell_z = self.nsteps[2] - 1
         self.n_cells = self.n_cell_x * self.n_cell_y * self.n_cell_z
-        self.n_nodes = self.nsteps[0]*self.nsteps[1]*self.nsteps[2]
-
+        self.maximum = origin+self.nsteps*self.step_vector
         self.tetra_mask_even = np.array([
             [7,1,2,4],
             [6,2,4,7],
@@ -36,8 +41,6 @@ class TetMesh:
             [1,0,3,5]
         ])
         self.ntetra = self.n_cells * 5
-        self.properties = {}
-        self.property_gradients = {}
         self.n_elements = self.ntetra
         self.cg = None
 
@@ -80,11 +83,7 @@ class TetMesh:
                                  axis=1) / 4.
         return barycentre
 
-    def update_property(self, name, value):
-
-        self.properties[name] = value
-
-    def evaluate_value(self, pos, prop):
+    def evaluate_value(self, pos, property_array):
         """
         Evaluate value of interpolant
 
@@ -102,10 +101,10 @@ class TetMesh:
         values = np.zeros(pos.shape[0])
         values[:] = np.nan
         vertices, c, tetras, inside = self.get_tetra_for_location(pos)
-        values[inside] = np.sum(c[inside,:]*self.properties[prop][tetras[inside,:]],axis=1)
+        values[inside] = np.sum(c[inside,:]*property_array[tetras[inside,:]],axis=1)
         return values
 
-    def evaluate_gradient(self, pos, prop):
+    def evaluate_gradient(self, pos, property_array):
         """
         Evaluate the gradient of an interpolant at the locations
 
@@ -124,13 +123,20 @@ class TetMesh:
         values = np.zeros(pos.shape)
         values[:] = np.nan
         vertices, element_gradients, tetras, inside = self.get_tetra_gradient_for_location(pos)
-        vertex_vals = self.properties[prop][tetras]
         #grads = np.zeros(tetras.shape)
-        values[inside,:] = (element_gradients[inside,:,:]*vertex_vals[inside, None, :]).sum(2)
+        values[inside,:] = (element_gradients[inside,:,:]*property_array[tetras[inside,None,:]]).sum(2)
         length = np.sum(values[inside,:],axis=1)
-        values[inside,:] /= length[:,None]
+        # values[inside,:] /= length[:,None]
         return values
 
+    def inside(self, pos):
+        inside = np.ones(pos.shape[0]).astype(bool)
+        for i in range(3):
+            inside *= pos[:, i] > self.origin[None, i]
+            inside *= pos[:, i] < self.origin[None, i] + \
+                      self.step_vector[None, i] * self.nsteps_cells[None, i]
+        return inside
+
     def get_tetra_for_location(self, pos):
         """
         Determine the tetrahedron from a numpy array of points
@@ -146,11 +152,13 @@ class TetMesh:
 
         """
         pos = np.array(pos)
+        inside = self.inside(pos)
         # initialise array for tetrahedron vertices
         vertices = np.zeros((5, 4, pos.shape[0], 3))
         vertices[:] = np.nan
         # get cell indexes
         c_xi, c_yi, c_zi = self.position_to_cell_index(pos)
+        
         # determine if using +ve or -ve mask
         even_mask = (c_xi + c_yi + c_zi) % 2 == 0
         # get cell corners
@@ -188,15 +196,18 @@ class TetMesh:
         # if all coords are +ve then point is inside cell
         mask = np.all(c > 0, axis=2)
 
-        inside = np.any(mask,axis=1)
+        inside = np.logical_and(inside,np.any(mask,axis=1))
         # get cell corners
         xi, yi, zi = self.cell_corner_indexes(c_xi, c_yi, c_zi)
-
         #create mask to see which cells are even
         even_mask = (c_xi + c_yi + c_zi) % 2 == 0
         # create global node index list
-        gi = xi + yi * self.nsteps[0] + zi * self.nsteps[0] * self.nsteps[1]
+        # print('nsteps',self.nsteps, 'nsteps_cells', self.nsteps_cells)
+        # print('x',np.min(c_xi),np.max(c_xi),np.min(xi),np.max(xi))
+        # print('y',np.min(c_yi),np.max(c_yi),np.min(yi),np.max(yi))
+        # print('z',np.min(c_zi),np.max(c_zi),np.min(zi),np.max(zi))
 
+        gi = xi + yi * self.nsteps[0] + zi * self.nsteps[0] * self.nsteps[1]
         # container for tetras
         tetras = np.zeros((xi.shape[0], 5, 4)).astype(int)
 
@@ -207,7 +218,6 @@ class TetMesh:
         vertices_return[:] = np.nan
         # set all masks not inside to False
         mask[~inside,:] = False
-        #print(mask.shape,inside.shape,vertices.shape,vertices_return.shape,vertices[mask,:,:].shape)
         vertices_return[inside,:,:] = vertices[mask,:,:]#[mask,:,:]#[inside,:,:]
         c_return = np.zeros((pos.shape[0],4))
         c_return[:] = np.nan
@@ -217,7 +227,7 @@ class TetMesh:
         tetra_return[inside,:] = tetras[mask,:]
         return vertices_return, c_return, tetra_return, inside
 
-    def get_constant_gradient(self, region):
+    def get_constant_gradient(self, region, direction=None):
         """
         Get the constant gradient for the specified nodes
 
@@ -230,6 +240,34 @@ class TetMesh:
         -------
 
         """
+        """
+        Add the constant gradient regularisation to the system
+
+        Parameters
+        ----------
+        w (double) - weighting of the cg parameter
+
+        Returns
+        -------
+
+        """
+        if direction is not None:
+            print('using cg direction')
+            logger.info("Running constant gradient")
+            elements_gradients = self.get_element_gradients(np.arange(self.ntetra))
+            if elements_gradients.shape[0] != direction.shape[0]:
+                logger.error('Cannot add directional CG, vector field is not the correct length')
+                return
+            region = region.astype('int64')
+
+            neighbours = self.get_neighbours()
+            elements = self.get_elements()
+            idc, c, ncons = fold_cg(elements_gradients, direction, neighbours.astype('int64'), elements.astype('int64'), self.nodes)
+
+            idc = np.array(idc[:ncons, :])
+            c = np.array(c[:ncons, :])
+            B = np.zeros(c.shape[0])
+            return c, idc, B
         if self.cg is None:
             logger.info("Running constant gradient")
             elements_gradients = self.get_element_gradients(np.arange(self.ntetra))
@@ -245,7 +283,34 @@ class TetMesh:
             B = np.zeros(c.shape[0])
             self.cg = (c,idc,B)
         return self.cg[0], self.cg[1], self.cg[2]
+    def get_constant_norm(self, region):
+        """
+        Get the constant gradient for the specified nodes
+
+        Parameters
+        ----------
+        region : np.array(dtype=bool)
+            mask of nodes to calculate cg for
+
+        Returns
+        -------
+
+        """
+        
+        logger.info("Running constant gradient")
+        elements_gradients = self.get_element_gradients(np.arange(self.ntetra))
+        region = region.astype('int64')
+
+        neighbours = self.get_neighbours()
+        elements = self.get_elements()
+        idc, c, ncons = constant_norm(elements_gradients, neighbours.astype('int64'), elements.astype('int64'), self.nodes,
+                            region.astype('int64'))
 
+        idc = np.array(idc[:ncons, :])
+        c = np.array(c[:ncons, :])
+        B = np.zeros(c.shape[0])
+        
+        return  c,idc,B
     def get_elements(self):
         """
         Get a numpy array of all of the elements in the mesh
@@ -346,12 +411,9 @@ class TetMesh:
         vertices, bc, tetras, inside = self.get_tetra_for_location(pos)
         ps = vertices
         m = np.array(
-            [[(ps[:, 1, 0] - ps[:, 0, 0]), (ps[:, 1, 1] - ps[:, 0, 1]),
-              (ps[:, 1, 2] - ps[:, 0, 2])],
-             [(ps[:, 2, 0] - ps[:, 0, 0]), (ps[:, 2, 1] - ps[:, 0, 1]),
-              (ps[:, 2, 2] - ps[:, 0, 2])],
-             [(ps[:, 3, 0] - ps[:, 0, 0]), (ps[:, 3, 1] - ps[:, 0, 1]),
-              (ps[:, 3, 2] - ps[:, 0, 2])]])
+            [[(ps[:, 1, 0] - ps[:, 0, 0]), (ps[:, 1, 1] - ps[:, 0, 1]),(ps[:, 1, 2] - ps[:, 0, 2])],
+             [(ps[:, 2, 0] - ps[:, 0, 0]), (ps[:, 2, 1] - ps[:, 0, 1]),(ps[:, 2, 2] - ps[:, 0, 2])],
+             [(ps[:, 3, 0] - ps[:, 0, 0]), (ps[:, 3, 1] - ps[:, 0, 1]),(ps[:, 3, 2] - ps[:, 0, 2])]])
         I = np.array(
             [[-1., 1., 0., 0.],
              [-1., 0., 1., 0.],
@@ -363,25 +425,7 @@ class TetMesh:
         element_gradients = element_gradients @ I
         return vertices, element_gradients, tetras, inside
 
-    def inside(self, pos):
-        """
-        Check if a point is inside the structured grid
-
-        Parameters
-        ----------
-        pos
-
-        Returns
-        -------
 
-        """
-        # check whether point is inside box
-        inside = np.ones(pos.shape[0]).astype(bool)
-        for i in range(3):
-            inside *= pos[:, i] > self.origin[None, i]
-            inside *= pos[:, i] < self.origin[None, i] + \
-                      self.step_vector[None, i] * self.nsteps_cells[None, i]
-        return inside
 
     def global_node_indicies(self, indexes):
         """