openpnm 1.0.0__zip

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

@@ -0,0 +1,127 @@
+r"""
+===============================================================================
+pore_diameter -- 
+===============================================================================
+
+"""
+import scipy as _sp
+import numpy as np
+
+from scipy.spatial import ConvexHull
+
+def sphere(geometry,
+           psd_name,psd_shape,psd_loc,psd_scale,
+           pore_seed='pore.seed',
+           psd_offset=0,
+           **kwargs):
+    r"""
+    Calculate pore diameter from seed values for a spherical pore body
+    """
+    import scipy.stats as spst
+    prob_fn = getattr(spst,psd_name)
+    P = prob_fn(psd_shape,loc=psd_loc,scale=psd_scale)
+    value = P.ppf(geometry[pore_seed])+psd_offset
+    return value
+
+def voronoi(geometry,
+            pore_volume='pore.volume',
+            **kwargs):
+    r"""
+    Calculate pore diameter from equivalent sphere - volumes must be calculated first
+    """
+    from scipy.special import cbrt
+    pore_vols = geometry[pore_volume]
+    value = cbrt(6*pore_vols/_sp.pi)
+    return value
+
+def centroids(network,
+             geometry,
+             **kwargs):
+    r"""
+    Calculate the diameter representing an inclosed sphere. The maximum is very difficult to caluclate for irregular polygons with more than 4 faces
+    so an average distance from the pore centroid to the throat centroid is an approximation
+    """
+    Np = geometry.num_pores()
+    value = _sp.zeros(Np)
+    pore_map = geometry.map_pores(geometry.pores(),geometry._net)
+    for geom_pore,net_pore in pore_map:
+        net_throats = geometry._net.find_neighbor_throats(net_pore)
+        geom_throats = geometry._net.map_throats(net_throats,geometry)[:,1]
+        tcs = geometry["throat.centroid"][geom_throats]
+        pc = geometry["pore.centroid"][geom_pore]
+        value[geom_pore]=_sp.mean(_sp.sqrt(((tcs-pc)*(tcs-pc))[:,0]+((tcs-pc)*(tcs-pc))[:,1]+((tcs-pc)*(tcs-pc))[:,2]))*2
+    return value
+    
+def insphere(network,
+             geometry,
+             **kwargs):
+    r"""
+    Calculate the diameter of the insphere using linear programming
+    """
+    import warnings
+    try:
+        import pulp as pu
+        Np = geometry.num_pores()
+        value = _sp.zeros(Np)
+        pore_map = geometry.map_pores(geometry.pores(),geometry._net)
+        for geom_pore,net_pore in pore_map:
+            net_throats = geometry._net.find_neighbor_throats(net_pore)
+            geom_throats = geometry._net.map_throats(net_throats,geometry)[:,1]
+            verts = geometry['throat.offset_vertices'][geom_throats]
+            if len(verts) > 1:
+                try:
+                    pts = np.vstack((i for i in verts if len(i)>0))
+                except ValueError:
+                    pts = []
+                if len(pts) > 4:
+                    "Work out central point to use as initial guess"
+                    c0 = np.mean(pts,axis=0)
+                    "Compute convex hull to find points lying on the hull in order"
+                    hull = ConvexHull(pts, qhull_options='QJ Pp')
+                    "For each simplex making up the hull collect the end points"
+                    A = pts[hull.simplices[:,0]]
+                    B = pts[hull.simplices[:,1]]
+                    C = pts[hull.simplices[:,2]]
+                    #I = np.array([[0,1],[-1,0]])
+                    "Normal of the simplices"
+                    #N = np.dot((B-A),I)
+                    N = np.cross((B-A),(C-A),axis=1)
+                    #L = np.sqrt(np.sum(np.square(N),axis=1))
+                    "Normalize the normal vector"
+                    L = np.linalg.norm(N,axis=1)
+                    F = np.vstack((L,L,L)).T
+                    N /= F
+                    "If normals point out of hull change sign to point in"
+                    pointing_out = (np.sum((A-c0)*N,axis=1)>0)
+                    N[pointing_out]*= -1
+                    "Define Linear Program Variables"
+                    "The centre of the incircle adjustment"
+                    cx = pu.LpVariable("cx",None,None,pu.LpContinuous)
+                    cy = pu.LpVariable("cy",None,None,pu.LpContinuous)
+                    cz = pu.LpVariable("cz",None,None,pu.LpContinuous)
+                    "Radius of the incircle"
+                    R = pu.LpVariable("R",0,None,pu.LpContinuous)
+                    "Slack variables for shortest distance between centre and simplices" 
+                    S = pu.LpVariable.dict("SlackVariable",range(len(A)),0,None,pu.LpContinuous)
+                    "Set up LP problem"
+                    prob = pu.LpProblem("FindInRadius",pu.LpMaximize)
+                    "Objective Function"
+                    prob += R
+                    for i in range(len(A)):
+                        " Ni.(C-Ai)-Si = 0"
+                        prob += N[i][0]*(c0[0]+cx) + N[i][1]*(c0[1]+cy) + N[i][2]*(c0[2]+cz)- N[i][0]*A[i][0] - N[i][1]*A[i][1] - N[i][2]*A[i][2]- S[i] == 0
+                        "Si >= R"
+                        prob += S[i] >= R
+                    "Solve the LP"
+                    with warnings.catch_warnings():
+                        warnings.simplefilter("ignore")
+                        prob.solve()
+                    "As the radius is the objective function we can get it from the objective or as R.value()"
+                    rad = prob.objective.value()
+                    #cen = c0 + np.array([cx.value(),cy.value(),cz.value()])
+                    value[geom_pore]=rad*2
+            
+        
+        return value
+    except ImportError:
+        print("Cannot use insphere method without installing pulp package")

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

@@ -0,0 +1,55 @@
+r"""
+===============================================================================
+pore_misc -- miscillaneous and generic functions to apply to pores
+===============================================================================
+
+"""
+import scipy as _sp
+
+def constant(geometry,
+             value,
+             **kwargs):
+    r"""
+    Assign specified constant value.  This function is redundant and could be
+    accomplished with geometry['pore.prop'] = value.
+    """
+    value = _sp.ones(geometry.num_pores(),)*value
+    return value
+
+def random(geometry,
+           seed=None,
+           num_range=[0,1],
+           **kwargs):
+    r"""
+    Assign random number to pore bodies
+    note: should this be called 'poisson'?  
+    """
+    range_size = num_range[1]-num_range[0]
+    range_min = num_range[0]
+    _sp.random.seed(seed)
+    value = _sp.random.rand(geometry.num_pores(),)
+    value = value*range_size + range_min
+    return value
+
+def neighbor(network,
+             geometry,
+             throat_prop='',
+             mode='min',
+             **kwargs):
+    r"""
+    Adopt the minimum seed value from the neighboring throats
+    """
+    Ps = geometry.pores()
+    data = geometry[throat_prop]
+    neighborTs = network.find_neighbor_throats(pores=Ps,flatten=False,mode='intersection')
+    values = _sp.ones((_sp.shape(Ps)[0],))*_sp.nan
+    if mode == 'min':
+        for pore in Ps:
+            values[pore] = _sp.amin(data[neighborTs[pore]])
+    if mode == 'max':
+        for pore in Ps:
+            values[pore] = _sp.amax(data[neighborTs[pore]])
+    if mode == 'mean':
+        for pore in Ps:
+            values[pore] = _sp.mean(data[neighborTs[pore]])
+    return values

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

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+r"""
+===============================================================================
+pore_seeds -- Methods for generating fields of values for use as seeds in
+statistical pore size distributions
+===============================================================================
+
+"""
+import scipy as _sp
+
+def perlin_noise(geometry,freq=1,octaves=4,mode='classic',**kwargs):
+    r'''
+    Generate pore seed values using the Perlin noise algorithm.  This approach
+    imparts some spatial clumpiness to the pore seeds.
+
+    Parameters
+    ----------
+    freq, octaves : int
+        Parameters that control the qualities of the noise.  Lower frequency
+        results in more smaller clumps.  Higher octaves gives a more textured
+        noise.
+    mode : {'classic','simplex'}
+        The algorithm to use when generating the noise.
+
+        * 'classic' : (default) The original algorithm developed by Perlin
+        * 'simplex' : A newer algorithm that is supposedly faster and results
+        in a more natural texture.
+
+    Returns
+    -------
+    A list of pore seeds values between 0:1 that are spatially correlated (i.e.
+    similar values are clumped together)
+
+    Notes
+    -----
+    - This method uses image analysis type tools, so only works on Cubic
+    networks
+    - This method requires the 'noise' module is installed
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.Cubic(shape=[50,50,50])
+    >>> geom = OpenPNM.Geometry.GenericGeometry(network=pn,pores=pn.Ps,throats=pn.Ts)
+    >>> geom.add_model(propname='pore.seed',model=OpenPNM.Geometry.models.pore_seed.perlin_noise)
+    >>> im = pn.asarray(geom['pore.seed'])
+
+    Visualizing the end result can be done with:
+
+    ``matplotlib.pyplot.imshow(im[:,25,:],interpolation='none')``
+
+    '''
+    from noise import pnoise3, snoise3
+    import scipy.stats as spst
+
+    net = geometry._net
+    if mode == 'classic':
+        model = pnoise3
+    elif mode == 'simplex':
+        model = snoise3
+    freq = freq * octaves
+    #The following will only work on Cubic networks
+    x = net._shape[0]
+    y = net._shape[1]
+    z = net._shape[2]
+    temp = _sp.ndarray((x,y,z))
+    for k in range(z):
+        for j in range(y):
+            for i in range(x):
+                temp[i,j,k] = model(i / freq, j / freq, k / freq, octaves) + 0.5
+    #Assuming that the noise is normally distributed, find seeds of that dist
+    temp = _sp.reshape(temp,(temp.size,))
+    x_mean = _sp.mean(temp)
+    x_sigma = _sp.sqrt(1/(temp.size-1)*_sp.sum((temp - x_mean)**2))
+    fn1 = spst.norm(loc=x_mean,scale=x_sigma)
+    values = fn1.cdf(temp)
+    values = values[geometry.map_pores(target=net,pores=geometry.Ps)]
+    return values.flatten()
+
+def distance_from_inclusion(geometry,p,**kwargs):
+    r'''
+    Genrate spatially correlated pore seeds by calculating distance from random
+    locations (inclusions) in the domain
+
+    Parameters
+    ----------
+    p : float
+        The fraction of pores in the domain that are set as 'seeds' for the
+        distance calculation
+
+    Returns
+    -------
+    A list of distance values (in voxels) between each pore and it nearest
+    seed pore.  A list of voxel distances is returned rather than normalized
+    seeds between 0:1 so that the user can manipulate the map as desired, by
+    applying desired thresholds and/or scaling to get 0:1 seeds.
+
+    Notes
+    -----
+    - This method uses image analysis tools, so only works on Cubic networks
+    - At present the result contains edge artifacts since no inclusions are present beyond the image boundary
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.Cubic(shape=[50,50,50])
+    >>> geom = OpenPNM.Geometry.GenericGeometry(network=pn,pores=pn.Ps,throats=pn.Ts)
+    >>> geom.add_model(propname='pore.seed',model=OpenPNM.Geometry.models.pore_seed.distance_from_inclusion,p = 0.001)
+    >>> im = pn.asarray(geom['pore.seed'])
+
+    Visualizing the end result can be done with:
+
+    ``matplotlib.pyplot.imshow(im[:,25,:],interpolation='none')``
+
+    '''
+    import scipy.ndimage as _spim
+    net = geometry._net
+    #The following will only work on Cubic networks
+    x = net._shape[0]
+    y = net._shape[1]
+    z = net._shape[2]
+    img = _sp.rand(x,y,z)>p
+    #Pad image by tiling
+    a = _sp.tile(img,[3,3,3])
+    b = a[x:-x,y:-y,z:-z]
+    #Perform distance transform
+    img = _spim.distance_transform_bf(b)
+    #Convert back to pore-list
+    values = img.flatten()
+    values = values[geometry.map_pores(target=net,pores=geometry.Ps)]
+    return values
+
+def spatially_correlated(geometry,network,weights=None,strel=None,**kwargs):
+    r'''
+    Generates pore seeds that are spatailly correlated with their neighbors.
+
+    Parameters
+    ----------
+    weights : list of ints, optional
+        The [Nx,Ny,Nz] distances (in number of pores) in each direction that
+        should be correlated.
+
+    strel : array_like, optional (in place of weights)
+        The option allows full control over the spatial correlation pattern by
+        specifying the structuring element to be used in the convolution.
+
+        The array should be a 3D array containing the strength of correlations
+        in each direction.  Nonzero values indicate the strength, direction
+        and extent of correlations.  The following would achieve a basic
+        correlation in the z-direction:
+
+        strel = sp.array([[[0, 0, 0], [0, 0, 0], [0, 0, 0]],\
+                            [[0, 0, 0], [1, 1, 1], [0, 0, 0]],\
+                            [[0, 0, 0], [0, 0, 0], [0, 0, 0]]])
+
+    Notes
+    -----
+    This approach uses image convolution to replace each pore seed in the
+    geoemtry with a weighted average of those around it.  It then converts the
+    new seeds back to a random distribution by assuming they new seeds are
+    normally distributed.
+
+    Because is uses image analysis tools, it only works on Cubic networks.
+
+    This is the appproached used by Gostick et al [2]_ to create an anistropic
+    gas diffusion layer for fuel cell electrodes.
+
+    References
+    ----------
+    .. [2] J. Gostick et al, Pore network modeling of fibrous gas diffusion layers for polymer electrolyte membrane fuel cells. J Power Sources 173 (2007) 277–290
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.Cubic(shape=[50,50,50])
+    >>> geom = OpenPNM.Geometry.GenericGeometry(network=pn,pores=pn.Ps,throats=pn.Ts)
+    >>> geom.add_model(propname='pore.seed',model=OpenPNM.Geometry.models.pore_seed.spatially_correlated,weights=[2,2,2])
+    >>> im = pn.asarray(geom['pore.seed'])
+
+    Visualizing the end result can be done with:
+
+    ``matplotlib.pyplot.imshow(im[:,25,:],interpolation='none')``
+
+    '''
+    import scipy.ndimage as spim
+    import scipy.stats as spst
+    #The following will only work on Cubic networks
+    x = network._shape[0]
+    y = network._shape[1]
+    z = network._shape[2]
+    im = _sp.rand(x,y,z)
+    if strel is None:  # Then generate a strel
+        if sum(weights) == 0:
+            # If weights of 0 are sent, then skip everything and return rands.
+            return im.flatten()
+        w = _sp.array(weights)
+        strel = _sp.zeros(w*2+1)
+        strel[:,w[1],w[2]] = 1
+        strel[w[0],:,w[2]] = 1
+        strel[w[0],w[1],:] = 1
+    im = spim.convolve(im,strel)
+    #Convolution is no longer randomly distributed, so fit a gaussian and find it's seeds
+    temp = im.flatten()
+    x_mean = _sp.mean(temp)
+    x_sigma = _sp.sqrt(1/(temp.size-1)*_sp.sum((temp - x_mean)**2))
+    fn1 = spst.norm(loc=x_mean,scale=x_sigma)
+    values = fn1.cdf(temp)
+    values = values[geometry.map_pores(target=network,pores=geometry.Ps)]
+    return values
+
+
+

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

@@ -0,0 +1,28 @@
+r"""
+===============================================================================
+Submodule -- throat_surface_area
+===============================================================================
+
+"""
+import scipy as _sp
+
+def sphere(geometry,
+             pore_diameter='pore.diameter',
+             **kwargs):
+    r"""
+    Calculate internal surface area for a spherical pore
+    """
+    R = geometry[pore_diameter]/2
+    value = 4*_sp.constants.pi*R**2
+    return value
+
+def cube(geometry,
+           pore_diameter='pore.diameter',
+           **kwargs):
+    r"""
+    Calculate internal surface area for a cubic pore
+    """
+    D = geometry[pore_diameter]
+    value = 6*D**2
+    return value
+

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

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

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

@@ -0,0 +1,133 @@
+r"""
+===============================================================================
+pore_volume --
+===============================================================================
+
+"""
+import scipy as _sp
+import numpy as np
+from scipy.spatial import Delaunay
+import OpenPNM.Utilities.misc as misc
+
+def _get_hull_volume(points):
+    r"""
+    Calculate the volume of a set of points by dividing the bounding surface into triangles and working out the volume of all the pyramid elements
+    connected to the volume centroid
+    """
+    " remove any duplicate points - this messes up the triangulation "
+    points = _sp.asarray(misc.unique_list(np.around(points,10)))
+    try:
+        tri = Delaunay(points,qhull_options='QJ Pp')
+    except _sp.spatial.qhull.QhullError:
+        print(points)
+    " We only want points included in the convex hull to calculate the centroid "
+    hull_centroid = _sp.array([points[:,0].mean(),points[:,1].mean(),points[:,2].mean()])
+    hull_volume = 0.0
+    pyramid_COMs = []
+    for ia, ib, ic in tri.convex_hull:
+        " Points making each triangular face "
+        " Collection of co-ordinates of each point in this face "
+        face_x = points[[ia,ib,ic]][:,0]
+        face_y = points[[ia,ib,ic]][:,1]
+        face_z = points[[ia,ib,ic]][:,2]
+        " Average of each co-ordinate is the centroid of the face "
+        face_centroid = [face_x.mean(),face_y.mean(),face_z.mean()]
+        face_centroid_vector = face_centroid - hull_centroid
+        " Vectors of the sides of the face used to find normal vector and area "
+        vab = points[ib] - points[ia]
+        vac = points[ic] - points[ia]
+        vbc = points[ic] - points[ib] # used later for area
+        #face_COM = (vab+vac)/3
+        " As vectors are co-planar the cross-product will produce the normal vector of the face "
+        face_normal = _sp.cross(vab,vac)
+        try:
+            face_unit_normal = face_normal/_sp.linalg.norm(face_normal)
+        except RuntimeWarning:
+            print("Pore Volume Error:" +str(vab)+" "+str(vac))
+        " As triangles are orientated randomly in 3D we could either transform co-ordinates to align with a plane and perform 2D operations "
+        " to work out the area or we could work out the lengths of each side and use Heron's formula which is easier"
+        " Using Delaunay traingulation will always produce triangular faces but if dealing with other polygons co-ordinate transfer may be necessary "
+        a = _sp.linalg.norm(vab)
+        b = _sp.linalg.norm(vbc)
+        c = _sp.linalg.norm(vac)
+        " Semiperimeter "
+        s = 0.5*(a+b+c)
+        face_area = _sp.sqrt(s*(s-a)*(s-b)*(s-c))
+        " Now the volume of the pyramid section defined by the 3 face points and the hull centroid can be calculated "
+        pyramid_volume = _sp.absolute(_sp.dot(face_centroid_vector,face_unit_normal)*face_area/3)
+        " Each pyramid is summed together to calculate the total volume "
+        hull_volume += pyramid_volume
+        " The Centre of Mass will not be the same as the geometrical centroid "
+        " A weighted adjustment can be calculated from the pyramid centroid and volume "
+        vha = points[ia]-hull_centroid
+        vhb = points[ib]-hull_centroid
+        vhc = points[ic]-hull_centroid
+        pCOM = ((vha+vhb+vhc)/4)*pyramid_volume
+        pyramid_COMs.append(pCOM)
+    if _sp.isnan(hull_volume):
+        hull_volume = 0.0
+    if hull_volume>0:
+        hull_COM = hull_centroid + _sp.mean(_sp.asarray(pyramid_COMs),axis=0)/hull_volume
+    else:
+        hull_COM = hull_centroid
+
+    return hull_volume, hull_COM
+
+def sphere(geometry,
+           pore_diameter='pore.diameter',
+           **kwargs):
+    r"""
+    Calculate pore volume from diameter for a spherical pore body
+    """
+    diams = geometry[pore_diameter]
+    value=_sp.pi/6*diams**3
+    return value
+
+def cube(geometry,
+         pore_diameter='pore.diameter',
+         **kwargs):
+    r"""
+    Calculate pore volume from diameter for a cubic pore body
+    """
+    diams = geometry[pore_diameter]
+    value = diams**3
+    return value
+
+def voronoi(network,
+            geometry,
+            **kwargs):
+    r"""
+    Calculate volume from the convex hull of the offset vertices making the throats surrounding the pore
+    Also calculate the centre of mass for the volume
+    """
+    pores = geometry.map_pores(network,geometry.pores())
+    Np = len(pores)
+    volume = _sp.zeros(Np)
+    com = _sp.zeros([Np,3])
+    for i in range(Np):
+        throat_vert_list = []
+        net_throats=network.find_neighbor_throats([pores[i]])
+        geom_throats = network.map_throats(target=geometry,throats=net_throats,return_mapping=True)['target']
+        if len(geom_throats) > 1:
+            for throat in geom_throats:
+                geom_throat_verts = geometry["throat.offset_vertices"][throat]
+                if geom_throat_verts is not None:
+                    for j in range(len(geom_throat_verts)):
+                        throat_vert_list.append(geom_throat_verts[j])
+            throat_array=_sp.asarray(throat_vert_list)
+            if len(throat_array)>4:
+                volume[i],com[i] = _get_hull_volume(throat_array)
+            else:
+                volume[i]=0
+        elif len(geom_throats) == 1 and 'throat.centroid' in geometry.props():
+                com[i]=geometry['throat.centroid'][geom_throats]
+                volume[i]=0
+    "Find any pores with centroids at origin and use the mean of the pore vertices instead"
+    "Not doing this messes up hydraulic conductances using centre to centre"
+    ps = np.where(~com.any(axis=1))[0]
+    if len(ps) >0:
+        for pore in ps:
+            com[pore]=np.mean(geometry["pore.vertices"][pore],axis=0)
+    geometry["pore.centroid"]=com
+
+    return volume

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

@@ -0,0 +1,47 @@
+r"""
+===============================================================================
+Submodule -- throat_area
+===============================================================================
+
+"""
+import scipy as _sp
+import OpenPNM.Utilities.transformations as tr
+import OpenPNM.Utilities.vertexops as vo
+
+def cylinder(geometry,
+             throat_diameter='throat.diameter',
+             **kwargs):
+    r"""
+    Calculate throat area for a cylindrical throat
+    """
+    diams = geometry[throat_diameter]
+    value = _sp.constants.pi/4*(diams)**2
+    return value
+
+def cuboid(geometry,
+           throat_diameter='throat.diameter',
+           **kwargs):
+    r"""
+    Calculate throat area for a cuboid throat
+    """
+    diams = geometry[throat_diameter]
+    value = (diams)**2
+    return value
+        
+def voronoi(geometry,
+            **kwargs):
+    r"""
+    Use the Voronoi verts and throat normals to work out the area
+    """
+    Nt = geometry.num_throats()    
+    verts = geometry['throat.offset_vertices']
+    normals = geometry['throat.normal']
+    area = _sp.ndarray(Nt)
+    for i in range(Nt):
+        if len(verts[i]) > 2:
+            verts_2D = tr.rotate_and_chop(verts[i],normals[i],[0,0,1])
+            area[i] = vo.PolyArea2D(verts_2D)
+        else:
+            area[i] = 0.0
+    
+    return area