openpnm 1.0.0__zip

OpenPNM-1.1/OpenPNM/Geometry/models/throat_vector.py

@@ -0,0 +1,27 @@
+r"""
+===============================================================================
+Submodule -- throat_vector
+===============================================================================
+
+"""
+import scipy as _sp
+
+def pore_to_pore(geometry,network,**kwargs):
+    r"""
+    Calculates throat vector as straight path between connected pores.
+    
+    Notes
+    -----
+    There is an important impicit assumption here: the positive direction is
+    taken as the direction from the pore with the lower index to the higher.
+    This corresponds to the pores in the 1st and 2nd columns of the 
+    'conns' array as stored on the network.
+    """
+    throats = network.throats(geometry.name)
+    pores = network.find_connected_pores(throats,flatten=False)
+    C0 = network['pore.coords'][pores,0]
+    C1 = network['pore.coords'][pores,1]
+    V = C1 - C0
+    L = _sp.array(_sp.sqrt(_sp.sum(V[:,:]**2,axis=1)),ndmin=1)
+    value = V/_sp.array(L,ndmin=2).T
+    return value

OpenPNM-1.1/OpenPNM/Geometry/models/throat_vertices.py

@@ -0,0 +1,19 @@
+r"""
+===============================================================================
+throat_vertices -- update throat vertices from Vornoi object
+===============================================================================
+
+"""
+import scipy as _sp
+
+def voronoi(network,
+            geometry,
+              **kwargs):
+    r"""
+    Update the pore vertices from the voronoi vertices
+    """    
+    throats = geometry.map_throats(network,geometry.throats())   
+    value = _sp.ndarray(len(throats),dtype=object)
+    for i in range(len(throats)):
+        value[i]=_sp.asarray(list(network["throat.vert_index"][throats[i]].values()))
+    return value

OpenPNM-1.1/OpenPNM/Geometry/models/throat_volume.py

@@ -0,0 +1,45 @@
+r"""
+===============================================================================
+Submodule -- throat_volume
+===============================================================================
+
+"""
+import scipy as _sp
+
+def cylinder(geometry,
+             throat_length='throat.length',
+             throat_diameter='throat.diameter',
+             **kwargs):
+    r"""
+    Calculate throat diameter from seeds for a cylindrical throat
+    - note: this will need to account for volume taken up by spherical pore bodies
+    """
+    leng = geometry[throat_length]
+    diam = geometry[throat_diameter]
+    value = _sp.pi/4*leng*diam**2
+    return value
+
+def cuboid(geometry,
+           throat_length='throat.length',
+           throat_diameter='throat.diameter',
+           **kwargs):
+    r"""
+    Calculate throat volume of cuboidal throat
+    - note: this will need to account for volume taken up by spherical pore bodies
+    """
+    leng = geometry[throat_length]
+    diam = geometry[throat_diameter]
+    value = leng*diam**2
+    return value
+
+def extrusion(geometry,
+              throat_length='throat.length',
+              throat_area='throat.area',
+              **kwargs):
+    r"""
+    Calculate volume from the throat area and the throat length
+    """
+    leng = geometry[throat_length]
+    area = geometry[throat_area]
+    value = leng*area
+    return value

OpenPNM-1.1/OpenPNM/Network/__Cubic__.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+Cubic: Generate lattice-like networks
+===============================================================================
+
+"""
+import numpy as np
+import scipy as sp
+import OpenPNM.Utilities.misc as misc
+from OpenPNM.Network import GenericNetwork
+from OpenPNM.Base import logging
+logger = logging.getLogger(__name__)
+
+class Cubic(GenericNetwork):
+    r"""
+    This class generates a cubic network of the specified size and shape.
+    Alternatively, an arbitrary domain shape defined by a supplied template.
+
+    Parameters
+    ----------
+    name : string
+        A unique name for the network
+
+    shape : tuple of ints
+        The (i,j,k) size and shape of the network.
+        
+    connectivity : int
+        The number of connections to neighboring pores.  Connections are made 
+        symmetrically to any combination of face, edge or corners neighbors.  
+        
+        Options are:
+        
+        - 6: Faces only
+        - 8: Corners only
+        - 12: Edges Only
+        - 14: Faces and Corners
+        - 18: Faces and Edges
+        - 20: Edges and Corners
+        - 26: Faces, Edges and Corners
+
+    template : array of booleans
+        An (i,j,k) array with True where the Network should be defiend and
+        False elsewhere.  This approach is useful for creating networks of non-
+        cuboid shape like spheres or cylinders, but still with a cubic lattice
+        topology.
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.Cubic(shape=[3,4,5])
+    >>> pn.Np
+    60
+      
+    It is also possible to create Networks with cubic connectivity but 
+    non-Cubic shape by provding an array with True values where the network 
+    should exist to the ``template`` argument.  The example below produces a sphere:
+    
+    >>> img = sp.ones([11,11,11])
+    >>> img[5,5,5] = 0
+    >>> from scipy.ndimage import distance_transform_bf as dt
+    >>> img = dt(img) < 5  # Create a sphere of True
+    >>> pn = OpenPNM.Network.Cubic(template=img)
+    >>> pn.Np
+    485
+    
+    If random distributions of coordination number is desired, one option is
+    to create a Cubic network with many connections and the trim some:
+    
+    >>> pn = OpenPNM.Network.Cubic(shape=[5,5,5],connectivity=26)
+    >>> Nt_original = pn.Nt
+    >>> mod = OpenPNM.Network.models.pore_topology.reduce_coordination
+    >>> pn.add_model(propname='throat.to_drop',model=mod,z=10,mode='random')
+    >>> pn.trim(throats=pn['throat.to_drop'])
+    >>> pn.Nt < Nt_original
+    True
+    """
+    def __init__(self, shape=None, template=None, spacing=1, connectivity=6, **kwargs):
+        super(Cubic, self).__init__(**kwargs)
+
+        if shape is not None:
+            arr = np.atleast_3d(np.empty(shape))
+        elif template is not None:
+            arr = sp.array(template,ndmin=3,dtype=bool)
+        else:
+            arr = np.atleast_3d(np.empty([1,1,1]))
+
+        self._shape = sp.shape(arr)  # Store original network shape
+        self._spacing = spacing  # Store network spacing instead of calculating it
+
+        points = np.array([i for i,v in np.ndenumerate(arr)], dtype=float)
+        points += 0.5
+        points *= spacing
+
+        I = np.arange(arr.size).reshape(arr.shape)
+
+        face_joints = [
+            (I[:,:,:-1], I[:,:,1:]),
+            (I[:,:-1], I[:,1:]),
+            (I[:-1], I[1:]),
+            ]
+
+        corner_joints = [
+            (I[:-1,:-1,:-1], I[1:,1:,1:]),
+            (I[:-1,:-1,1:], I[1:,1:,:-1]),
+            (I[:-1,1:,:-1], I[1:,:-1,1:]),
+            (I[1:,:-1,:-1], I[:-1,1:,1:]),
+            ]
+
+        edge_joints = [
+            (I[:,:-1,:-1], I[:,1:,1:]),
+            (I[:,:-1,1:], I[:,1:,:-1]),
+            (I[:-1,:,:-1], I[1:,:,1:]),
+            (I[1:,:,:-1], I[:-1,:,1:]),
+            (I[1:,1:,:], I[:-1,:-1,:]),
+            (I[1:,:-1,:], I[:-1,1:,:]),
+            ]
+        
+        if connectivity == 6:
+            joints = face_joints
+        elif connectivity == 8:
+            joints = corner_joints
+        elif connectivity == 12:
+            joints = corner_joints
+        elif connectivity == 14:
+            joints = face_joints + corner_joints
+        elif connectivity == 18:
+            joints = face_joints + edge_joints
+        elif connectivity == 20:
+            joints = edge_joints + corner_joints
+        elif connectivity == 26:
+            joints = face_joints + corner_joints + edge_joints
+        else:
+            raise Exception('Invalid connectivity receieved. Must be 6, 8, 12, 14, 18, 20 or 26')
+
+        I = np.arange(arr.size).reshape(arr.shape)
+        tails, heads = [], []
+        for T,H in joints:
+            tails.extend(T.flat)
+            heads.extend(H.flat)
+        pairs = np.vstack([tails, heads]).T
+
+        self['pore.coords']  = points
+        self['throat.conns'] = pairs
+        self['pore.all']     = np.ones(len(self['pore.coords']), dtype=bool)
+        self['throat.all']   = np.ones(len(self['throat.conns']), dtype=bool)
+        self['pore.index']   = sp.arange(0,len(self['pore.coords']))
+
+        x,y,z = self['pore.coords'].T
+        self['pore.internal'] = self['pore.all']
+        self['pore.front']    = x <= x.min()
+        self['pore.back']     = x >= x.max()
+        self['pore.left']     = y <= y.min()
+        self['pore.right']    = y >= y.max()
+        self['pore.bottom']   = z <= z.min()
+        self['pore.top']      = z >= z.max()
+
+        #If an image was sent as 'template', then trim network to image shape
+        if template is not None:
+            self.trim(~arr.flatten())
+
+    def add_boundaries(self):
+        r'''
+        This method uses ``clone_pores`` to clone the surface pores (labeled
+        'left','right', etc), then shifts them to the periphery of the domain,
+        and gives them the label 'right_face', 'left_face', etc.
+        '''
+        x,y,z = self['pore.coords'].T
+
+        Lc = sp.amax(sp.diff(x)) #this currently works but is very fragile
+
+        offset = {}
+        offset['front'] = offset['left'] = offset['bottom'] = [0,0,0]
+        offset['back']  = [x.max()+Lc/2,0,0]
+        offset['right'] = [0,y.max()+Lc/2,0]
+        offset['top']   = [0,0,z.max()+Lc/2]
+
+        scale = {}
+        scale['front']  = scale['back']  = [0,1,1]
+        scale['left']   = scale['right'] = [1,0,1]
+        scale['bottom'] = scale['top']   = [1,1,0]
+
+        for label in ['front','back','left','right','bottom','top']:
+            ps = self.pores(label)
+            self.clone_pores(pores=ps,apply_label=[label+'_boundary','boundary'])
+            #Translate cloned pores
+            ind = self.pores(label+'_boundary')
+            coords = self['pore.coords'][ind]
+            coords = coords*scale[label] + offset[label]
+            self['pore.coords'][ind] = coords
+
+    def asarray(self,values):
+        r'''
+        Retreive values as a rectangular array, rather than the OpenPNM list format
+
+        Parameters
+        ----------
+        values : array_like
+            The values from the network (in a list) to insert into the array
+
+        Notes
+        -----
+        This method can break on networks that have had boundaries added.  It
+        will usually work IF the list of values came only from 'internal' pores.
+        '''
+        if sp.shape(values)[0] > self.num_pores('internal'):
+            raise Exception('The received values are bigger than the original network')
+        Ps = sp.array(self['pore.index'][self.pores('internal')],dtype=int)
+        arr = sp.ones(self._shape)*sp.nan
+        ind = sp.unravel_index(Ps,self._shape)
+        arr[ind[0],ind[1],ind[2]] = values
+        return arr
+
+    def fromarray(self,array,propname):
+        r'''
+        Apply data to the network based on a rectangular array filled with
+        values.  Each array location corresponds to a pore in the network.
+
+        Parameters
+        ----------
+        array : array_like
+            The rectangular array containing the values to be added to the
+            network. This array must be the same shape as the original network.
+
+        propname : string
+            The name of the pore property being added.
+        '''
+        array = sp.atleast_3d(array)
+        if sp.shape(array) != self._shape:
+            raise Exception('The received array does not match the original network')
+        temp = array.flatten()
+        Ps = sp.array(self['pore.index'][self.pores('internal')],dtype=int)
+        propname = 'pore.' + propname.split('.')[-1]
+        self[propname] = sp.nan
+        self[propname][self.pores('internal')] = temp[Ps]
+
+    def domain_length(self,face_1,face_2):
+        r'''
+        Calculate the distance between two faces of the network
+
+        Parameters
+        ----------
+        face_1 and face_2 : array_like
+            Lists of pores belonging to opposite faces of the network
+
+        Returns
+        -------
+        The length of the domain in the specified direction
+
+        Notes
+        -----
+        - Does not yet check if input faces are perpendicular to each other
+        '''
+        #Ensure given points are coplanar before proceeding
+        if misc.iscoplanar(self['pore.coords'][face_1]) and misc.iscoplanar(self['pore.coords'][face_2]):
+            #Find distance between given faces
+            x = self['pore.coords'][face_1]
+            y = self['pore.coords'][face_2]
+            Ds = misc.dist(x,y)
+            L = sp.median(sp.amin(Ds,axis=0))
+        else:
+            logger.warning('The supplied pores are not coplanar. Length will be approximate.')
+            f1 = self['pore.coords'][face_1]
+            f2 = self['pore.coords'][face_2]
+            distavg = [0,0,0]
+            distavg[0] = sp.absolute(sp.average(f1[:,0]) - sp.average(f2[:,0]))
+            distavg[1] = sp.absolute(sp.average(f1[:,1]) - sp.average(f2[:,1]))
+            distavg[2] = sp.absolute(sp.average(f1[:,2]) - sp.average(f2[:,2]))
+            L = max(distavg)
+        return L
+
+
+    def domain_area(self,face):
+        r'''
+        Calculate the area of a given network face
+
+        Parameters
+        ----------
+        face : array_like
+            List of pores of pore defining the face of interest
+
+        Returns
+        -------
+        The area of the specified face
+        '''
+        coords = self['pore.coords'][face]
+        rads = self['pore.diameter'][face]/2.
+        # calculate the area of the 3 principle faces of the bounding cuboid
+        dx = max(coords[:,0]+rads) - min(coords[:,0]-rads)
+        dy = max(coords[:,1]+rads) - min(coords[:,1]-rads)
+        dz = max(coords[:,2]+rads) - min(coords[:,2]-rads)
+        yz = dy*dz # x normal
+        xz = dx*dz # y normal
+        xy = dx*dy # z normal
+        # find the directions parallel to the plane
+        directions = sp.where([yz,xz,xy]!=max([yz,xz,xy]))[0]
+        try:
+            # now, use the whole network to do the area calculation
+            coords = self['pore.coords']
+            rads = self['pore.diameter']/2.
+            d0 = (max(coords[:,directions[0]]+rads) - min(coords[:,directions[0]]-rads))
+            d1 = (max(coords[:,directions[1]]+rads) - min(coords[:,directions[1]]-rads))
+            A = d0*d1
+        except:
+            # if that fails, use the max face area of the bounding cuboid
+            A = max([yz,xz,xy])
+        if not misc.iscoplanar(self['pore.coords'][face]):
+            logger.warning('The supplied pores are not coplanar. Area will be approximate')
+            pass
+        return A
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=True)
+

OpenPNM-1.1/OpenPNM/Network/__DelaunayCubic__.py

@@ -0,0 +1,127 @@
+"""
+===============================================================================
+DelaunayCubic: Generate semi-random networks based on Delaunay Tessellations and perturbed cubic lattices
+===============================================================================
+
+"""
+import OpenPNM
+import scipy as sp
+import sys
+import numpy as np
+from OpenPNM.Network.__Delaunay__ import Delaunay
+from OpenPNM.Base import logging
+logger = logging.getLogger(__name__)
+
+class DelaunayCubic(Delaunay):
+    r"""
+    This class contains the methods for creating a *Delaunay* network topology
+    based connecting pores with a Delaunay tessellation.
+
+    This Subclass of Delaunay generates points on a cubic lattice and then perturbs them to prevent degeneracy
+
+
+    Parameters
+    ----------
+    name : string
+        A unique name for the network
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.DelaunayCubic(shape=[5,5,5], spacing=[4e-5,4e-5,4e-5],jiggle_factor=0.01)
+    >>> pn.num_pores()
+    125
+
+    """
+
+    def __init__(self,shape=None, template=None, spacing=[1,1,1],jiggle_factor=0.1,arrangement='SC',**kwargs):
+        '''
+        Create Delauny network object
+        '''
+        if shape is not None:
+            self._arr = np.atleast_3d(np.empty(shape))
+        elif template is not None:
+            self._arr = sp.array(template,ndmin=3,dtype=bool)
+        else:
+            self._arr = np.atleast_3d(np.empty([3,3,3]))
+
+        self._shape = sp.shape(self._arr)  # Store original network shape
+        self._spacing = sp.asarray(spacing)  # Store network spacing instead of calculating it
+        self._num_pores = np.prod(np.asarray(self._shape))
+        self._domain_size = np.asarray(self._shape)*self._spacing
+        self._jiggle_factor = jiggle_factor
+        self._arrangement = arrangement
+        super(DelaunayCubic,self).__init__(num_pores=self._num_pores,domain_size=self._domain_size,**kwargs)
+
+
+    def _generate_pores(self):
+        r"""
+        Generate the pores with numbering scheme.
+        """
+
+        points = np.array([i for i,v in np.ndenumerate(self._arr)], dtype=float)
+        points += 0.5
+
+        "-----------------------------------------------------------------------------------"
+        "2D Orthorhombic adjustment - shift even rows back a bit and odd rows forward a bit"
+        "   0   0   0   "
+        " 0   0   0   0 "
+        "   0   0   0   "
+        if self._arrangement == 'O':
+            shift_y=np.array([0,0.25,0])
+            shift_x=np.array([0.25,0,0])
+            points[(points[:,0] % 2 == 0)] -= shift_y
+            points[(points[:,2] % 2 != 0)] -= shift_x
+            points[(points[:,0] % 2 != 0)] += shift_y
+            points[(points[:,2] % 2 == 0)] += shift_x
+        "-----------------------------------------------------------------------------------"
+        "BCC = Body Centre Cubic "
+        if self._arrangement == 'BCC':
+            body_points=[]
+            for i in range(1,self._shape[0]):
+                for j in range(1,self._shape[1]):
+                    for k in range(1,self._shape[2]):
+                        body_points.append([i,j,k])
+            body_points = np.asarray(body_points)
+            points = np.concatenate((points,body_points))
+        "-----------------------------------------------------------------------------------"
+        "FCC = Face Centre Cubic "
+        if self._arrangement == 'FCC':
+            face_points=[]
+            for i in range(1,self._shape[0]):
+                for j in range(1,self._shape[1]):
+                    for k in range(1,self._shape[2]):
+                        left = [i-0.5,j,k]
+                        right = [i+0.5,j,k]
+                        back = [i,j-0.5,k]
+                        front = [i,j+0.5,k]
+                        bottom = [i,j,k-0.5]
+                        top = [i,j,k+0.5]
+                        if left not in face_points:
+                            face_points.append(left)
+                        if right not in face_points:
+                            face_points.append(right)
+                        if back not in face_points:
+                            face_points.append(back)
+                        if front not in face_points:
+                            face_points.append(front)
+                        if bottom not in face_points:
+                            face_points.append(bottom)
+                        if top not in face_points:
+                            face_points.append(top)
+            face_points = np.asarray(face_points)
+            points = np.concatenate((points,face_points))
+
+        jiggle = (np.random.rand(len(points),3)-0.5)*self._jiggle_factor
+        points += jiggle
+        points *= self._spacing
+
+        self['pore.coords']  = points
+        logger.debug(sys._getframe().f_code.co_name+": End of method")
+
+
+
+if __name__ == '__main__':
+    #Run doc tests
+    import doctest
+    doctest.testmod(verbose=True)