openpnm 1.0.0__zip

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

@@ -0,0 +1,80 @@
+r"""
+===============================================================================
+Submodule -- throat_centroid
+===============================================================================
+
+"""
+import scipy as _sp
+from OpenPNM.Utilities import transformations as tr
+from OpenPNM.Utilities import vertexops as vo
+from scipy.spatial import ConvexHull
+
+def voronoi(geometry,
+            **kwargs):
+    r"""
+    Calculate the geometrical centroid of the throat from the voronoi vertices.
+    """
+    verts = geometry['throat.vertices']    
+    offset_verts = geometry['throat.offset_vertices']
+    value = _sp.ndarray([len(verts),3])
+    for i in range(len(verts)):
+        if len(offset_verts[i]) > 2:
+            value[i] = _sp.array([offset_verts[i][:,0].mean(),offset_verts[i][:,1].mean(),offset_verts[i][:,2].mean()])
+        elif len(verts[i]) > 2:
+            value[i] = _sp.array([verts[i][:,0].mean(),verts[i][:,1].mean(),verts[i][:,2].mean()])
+        else:
+            value[i] = _sp.array([0,0,0])
+        
+    return value
+
+def centre_of_mass(geometry,
+            **kwargs):
+    r"""
+    Calculate the centre of mass of the throat from the voronoi vertices.
+    """
+    Nt = geometry.num_throats()
+    outer_verts = geometry['throat.vertices']    
+    offset_verts = geometry['throat.offset_vertices']
+    normal = geometry['throat.normal']
+    z_axis = [0,0,1]
+    value = _sp.ndarray([Nt,3])
+    for i in range(Nt):
+        if len(offset_verts[i]) > 2:
+            verts = offset_verts[i]
+        elif len(outer_verts[i]) > 2:
+            verts = outer_verts[i]
+        else:
+            verts = []
+        if len(verts) > 0:
+            " For boundaries some facets will already be aligned with the axis - if this is the case a rotation is unnecessary and could also cause problems "
+            angle = tr.angle_between_vectors(normal[i],z_axis)
+            if (angle==0.0)or(angle==_sp.pi):
+                "We are already aligned"
+                rotate_input = False
+                facet = verts
+            else:
+                rotate_input = True
+                M = tr.rotation_matrix(tr.angle_between_vectors(normal[i],z_axis),tr.vector_product(normal[i],z_axis))
+                facet = _sp.dot(verts,M[:3,:3].T)
+            "Now we have a rotated facet aligned with the z axis - make 2D"
+            facet_2D = _sp.column_stack((facet[:,0],facet[:,1]))
+            z = _sp.unique(_sp.around(facet[:,2],10))
+            if len(z) == 1:
+                "We need the vertices arranged in order so perform a convex hull"
+                hull = ConvexHull(facet_2D)
+                ordered_facet_2D = facet_2D[hull.vertices]
+                "Call the routine to calculate an area wighted centroid from the 2D polygon"
+                COM_2D = vo.PolyWeightedCentroid2D(ordered_facet_2D)
+                COM_3D = _sp.hstack((COM_2D,z))
+                "If we performed a rotation we need to rotate back"
+                if (rotate_input):
+                    MI = tr.inverse_matrix(M)
+                    " Unrotate the offset coordinates using the inverse of the original rotation matrix"
+                    value[i] = _sp.dot(COM_3D,MI[:3,:3].T)
+                else:
+                    value[i] = COM_3D
+            else:
+                print("Rotation Failed: "+str(_sp.unique(facet[:,2])))
+            
+        
+    return value

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

@@ -0,0 +1,106 @@
+r"""
+===============================================================================
+Submodule -- throat_diameter
+===============================================================================
+
+"""
+import scipy as _sp
+import numpy as np
+
+import OpenPNM.Utilities.transformations as tr
+from scipy.spatial import ConvexHull
+import time
+
+
+def cylinder(geometry,
+             tsd_name,tsd_shape,tsd_loc,tsd_scale,
+             throat_seed='throat.seed',
+             tsd_offset=0,
+             **kwargs):
+    r"""
+    Calculate throat diameter from seeds for a cylindrical throat
+    """
+    import scipy.stats as spst
+    prob_fn = getattr(spst,tsd_name)
+    P = prob_fn(tsd_shape,loc=tsd_loc,scale=tsd_scale)
+    value=P.ppf(geometry[throat_seed])+tsd_offset
+    return value
+    
+def voronoi(geometry,
+            throat_area='throat.area',
+            **kwargs):
+    r"""
+    Calculate throat diameter from analysis of Voronoi facets
+    Equivalent circular diameter from voronoi area
+    Could do better here and work out minimum diameter from verts
+    """
+    areas = geometry[throat_area]
+    value = 2*_sp.sqrt(areas/_sp.pi)#64 bit sqrt doesn't work!
+    return value
+
+def incircle(geometry,
+             **kwargs):
+    r"""
+    Calculate the incircle diameter by linear programming and the simplex search algorithm using the offset vertices
+    generated by the voronoi diagram offsetting routine
+    """
+    import warnings
+    try:
+        import pulp as pu
+        Nt = geometry.num_throats()    
+        verts = geometry['throat.offset_vertices']
+        normals = geometry['throat.normal']
+        value = _sp.zeros(Nt)
+        for i in range(Nt):
+            if len(verts[i]) > 2:
+                pts = tr.rotate_and_chop(verts[i],normals[i],[0,0,1])
+                "Work out central point to use as initial guess"
+                C = 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.vertices]
+                B = pts[np.roll(hull.vertices,-1)]
+                I = np.array([[0,1],[-1,0]])
+                "Normal of the simplices"
+                N = np.dot((B-A),I)
+                #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)).T
+                N /= F
+                "Mid-points of the simplex"
+                M = (B+A)/2
+                #C = np.mean(A)
+                "If normals point out of hull change sign to point in"
+                pointing_out = (np.sum((M-C)*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)
+                "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 j in range(len(A)):
+                    " Ni.(C-Ai)-Si = 0"
+                    prob += N[j][0]*(C[0]+cx) + N[j][1]*(C[1]+cy) - N[j][0]*A[j][0] - N[j][1]*A[j][1] - S[j] == 0
+                    "Si >= R"
+                    prob += S[j] >= 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()"
+                value[i] = 2*R.value()
+            else:
+                value[i] = 0.0
+        
+        return value
+    except ImportError:
+        print("Cannot use incircle method without installing pulp package")

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

@@ -0,0 +1,95 @@
+r"""
+===============================================================================
+Submodule -- throat_length
+===============================================================================
+
+"""
+import scipy as _sp
+
+def straight(network,
+             geometry,
+             pore_diameter='pore.diameter',
+             L_negative = 1e-9,
+             **kwargs):
+    r"""
+    Calculate throat length
+    
+    Parameters
+    ----------
+    L_negative : float
+        The default throat length to use when negative lengths are found.  The
+        default is 1 nm.  To accept negative throat lengths, set this value to 
+        ``None``.
+    """
+    #Initialize throat_property['length']
+    throats = network.throats(geometry.name)
+    pore1 = network['throat.conns'][:,0]
+    pore2 = network['throat.conns'][:,1]
+    C1 = network['pore.coords'][pore1]
+    C2 = network['pore.coords'][pore2]
+    E = _sp.sqrt(_sp.sum((C1-C2)**2,axis=1))  #Euclidean distance between pores
+    D1 = network[pore_diameter][pore1]
+    D2 = network[pore_diameter][pore2]
+    value = E-(D1+D2)/2.
+    value = value[throats]
+    if _sp.any(value<0) and (L_negative is not None):
+        print('Negative throat lengths are calculated. Arbitrary positive length assigned: '+str(L_negative))
+        Ts = _sp.where(value<0)[0]
+        value[Ts] = L_negative
+    return value
+        
+def voronoi(network,
+            geometry,
+            **kwargs):
+    r"""
+    Calculate the centre to centre distance from centroid of pore1 to centroid of throat to centroid of pore2
+    This is tricky as connections are defined at network level but centroids are stored on geometry.
+    The pore and throat map relates the geometry index to the network index but we must look up the index of the map
+    to go back to geometry index of the connected pores.
+    This will probably break down when a throat connects two different geometries 
+    """
+    throats = geometry.map_throats(network,geometry.throats())
+    connections = network['throat.conns'][throats]
+    net_pore1 = connections[:,0]
+    net_pore2 = connections[:,1]    
+    pore_centroids = network['pore.centroid']
+    throat_centroids = network['throat.centroid'][throats]
+    v1 = throat_centroids-pore_centroids[net_pore1]
+    v2 = throat_centroids-pore_centroids[net_pore2]
+    value = _sp.ndarray(len(connections))
+    for i in range(len(connections)):
+        value[i] = _sp.linalg.norm(v1[i])+_sp.linalg.norm(v2[i])
+    return value
+
+def c2c(network,
+             geometry,
+             **kwargs):
+    r"""
+    Calculate throat length 
+    """
+    #Initialize throat_property['length']
+    throats = network.throats(geometry.name)
+    pore1 = network['throat.conns'][:,0]
+    pore2 = network['throat.conns'][:,1]
+    C1 = network['pore.coords'][pore1]
+    C2 = network['pore.coords'][pore2]
+    E = _sp.sqrt(_sp.sum((C1-C2)**2,axis=1))  #Euclidean distance between pores
+    value = E
+    value = value[throats]
+    if _sp.any(value<0):
+        geometry._logger.warning('Negative throat lengths are calculated. Arbitrary positive length assigned (1e9 meters)')
+        Ts = _sp.where(value<0)[0]
+        value[Ts] = 1e-9
+    return value
+    
+def constant(network,
+             geometry,
+             const,
+             **kwargs):
+    r"""
+    Calculate throat length 
+    """
+    #Initialize throat_property['length']
+    throats = network.throats(geometry.name)
+    value = _sp.ones(len(throats))*const
+    return value

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

@@ -0,0 +1,42 @@
+r"""
+===============================================================================
+throat_misc --  Miscillaneous and generic functions to apply to throats
+===============================================================================
+
+"""
+import scipy as _sp
+
+def random(geometry,
+           seed=None,
+           num_range=[0,1],
+           **kwargs):
+    r"""
+    Assign random number to throats
+    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_throats(),)
+    value = value*range_size + range_min
+    return value
+    
+
+def neighbor(geometry,
+             network,
+             pore_prop='pore.seed',
+             mode='min',
+             **kwargs):
+    r"""
+    Adopt a value based on the neighboring pores
+    """
+    throats = network.throats(geometry.name)
+    P12 = network.find_connected_pores(throats)
+    pvalues = network[pore_prop][P12]
+    if mode == 'min':
+        value = _sp.amin(pvalues,axis=1)
+    if mode == 'max':
+        value = _sp.amax(pvalues,axis=1)
+    if mode == 'mean':
+        value = _sp.mean(pvalues,axis=1)
+    return value

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

@@ -0,0 +1,31 @@
+r"""
+===============================================================================
+throat_normal -- calculate from the normal vector to the throat vertices
+===============================================================================
+
+"""
+import scipy as sp
+from scipy.spatial import ConvexHull
+
+def voronoi(network,
+            geometry,
+              **kwargs):
+    r"""
+    Update the throat normals from the voronoi vertices
+    """    
+    verts = geometry["throat.vertices"]    
+    value = sp.ndarray([len(verts),3])    
+    for i in range(len(verts)):
+        if len(sp.unique(verts[i][:,0]))==1:
+            verts_2d = sp.vstack((verts[i][:,1],verts[i][:,2])).T
+        elif len(sp.unique(verts[i][:,1]))==1:
+            verts_2d = sp.vstack((verts[i][:,0],verts[i][:,2])).T
+        else:
+            verts_2d = sp.vstack((verts[i][:,0],verts[i][:,1])).T
+        hull = ConvexHull(verts_2d, qhull_options='QJ Pp')
+        sorted_verts = verts[i][hull.vertices]
+        v1 = sorted_verts[1]-sorted_verts[0]
+        v2 = sorted_verts[-1]-sorted_verts[0]
+        value[i] = sp.cross(v1,v2)
+    
+    return value

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

@@ -0,0 +1,191 @@
+r"""
+===============================================================================
+throat_offset_vertices -- Offeset throat vertices using a fibre radius parameter
+===============================================================================
+
+"""
+import scipy as sp
+import OpenPNM.Utilities.vertexops as vo
+import OpenPNM.Utilities.transformations as tr
+
+def voronoi(network,
+            geometry,
+            offset,
+              **kwargs):
+    r"""
+    Offset the throat vertices effectively erroding the facet by the offset distance supplied
+    """    
+    Nt = geometry.num_throats()
+    area = sp.ndarray(Nt)
+    perimeter = sp.ndarray(Nt)
+    offset_verts = sp.ndarray(Nt,dtype=object)
+    offset_error = sp.ndarray(Nt)
+    throat_COM = sp.ndarray([Nt,3])
+    for i in range(Nt):
+        offset_rand = (sp.random.rand(1)-0.5)*offset            
+        throat_verts=geometry["throat.vertices"][i]
+        throat_normal=geometry["throat.normal"][i]
+        area[i],perimeter[i],offset_verts[i],throat_COM[i],offset_error[i] = vo.get_throat_geom(throat_verts,throat_normal,offset)
+    
+    for i in range(Nt):
+        if offset_error[i] > 0 and len(offset_verts[i]) > 0:
+            offset_verts[i]=[]
+    "Properties that depend on the offset vertices are the area, perimeter and the centroid or COM"
+    "To speed things up we could save them all now rather than processing them individually"
+    if kwargs["set_dependent"]==True:
+        geometry["throat.area"]=area
+        geometry["throat.perimeter"]=perimeter
+        geometry["throat.centroid"]=throat_COM
+    
+    return offset_verts
+
+def distance_transform(network,
+               geometry,
+               offset,
+               **kwargs):
+    r"""
+    Use the Voronoi vertices and perform image analysis to obtain throat properties
+    """
+
+    import math
+    import numpy as np
+    from skimage.morphology import convex_hull_image
+    from skimage.measure import regionprops
+    from scipy import ndimage
+    
+    Nt = geometry.num_throats()
+    area = sp.zeros(Nt)
+    perimeter = sp.zeros(Nt)
+    centroid = sp.zeros([Nt,3])
+    incentre = sp.zeros([Nt,3])
+    inradius = sp.zeros(Nt)
+    equiv_diameter = sp.zeros(Nt)
+    eroded_verts = sp.ndarray(Nt,dtype=object)
+
+    res=200
+    vertices = geometry["throat.vertices"]
+    normals = geometry["throat.normal"]
+    z_axis = [0,0,1]
+    
+    for i in range(Nt):
+        " For boundaries some facets will already be aligned with the axis - if this is the case a rotation is unnecessary and could also cause problems "
+        angle = tr.angle_between_vectors(normals[i],z_axis)
+        if (angle==0.0)or(angle==np.pi):
+            "We are already aligned"
+            rotate_facet = False
+            facet = vertices[i]
+        else:
+            rotate_facet = True
+            M = tr.rotation_matrix(tr.angle_between_vectors(normals[i],z_axis),tr.vector_product(normals[i],z_axis))
+            facet = np.dot(vertices[i],M[:3,:3].T)
+        x = facet[:,0]
+        y = facet[:,1]
+        z = facet[:,2]
+        "Get points in 2d for image analysis"
+        pts = np.column_stack((x,y))
+        "translate points so min sits at the origin"
+        translation = [pts[:,0].min(),pts[:,1].min()]
+        pts -= translation
+        order = np.int(math.ceil(-np.log10(np.max(pts))))
+        "Normalise and scale the points so that largest span equals the resolution to save on memory and create clear image"
+        max_factor = np.max([pts[:,0].max(),pts[:,1].max()])
+        f = res/max_factor
+        "Scale the offset and define a circular structuring element with radius"
+        r = f*offset
+        "Only proceed if r is less than half the span of the image"
+        if r <= res/2:
+            pts *= f
+            minp1 = pts[:,0].min()
+            minp2 = pts[:,1].min()
+            maxp1 = pts[:,0].max()
+            maxp2 = pts[:,1].max()
+            img = np.zeros([np.int(math.ceil(maxp1-minp1)+1),np.int(math.ceil(maxp2-minp2)+1)])
+            int_pts = np.around(pts,0).astype(int)
+            for pt in int_pts:
+                img[pt[0]][pt[1]]=1
+            "Pad with zeros all the way around the edges"
+            img_pad = np.zeros([np.shape(img)[0]+2,np.shape(img)[1]+2])
+            img_pad[1:np.shape(img)[0]+1,1:np.shape(img)[1]+1]=img
+    
+            "All points should lie on this plane but could be some rounding errors so use the order parameter"
+            z_plane = sp.unique(np.around(z,order+2))
+            if len(z_plane) > 1:
+                print("rotation for image analysis failed")
+            "Fill in the convex hull polygon"
+            convhullimg = convex_hull_image(img_pad)
+            "Perform a Distance Transform and black out points less than r to create binary erosion"
+            "This is faster than performing an erosion and dt can also be used later to find incircle"
+            eroded = ndimage.distance_transform_edt(convhullimg)
+            #eroded = dt.copy()
+            eroded[eroded<=r]=0
+            eroded[eroded>r]=1
+            "If we are left with less than 3 non-zero points then the throat is fully occluded"
+            if np.sum(eroded)>=3:
+                "Do some image analysis to extract the key properties"
+                regions = regionprops(eroded[1:np.shape(img)[0]+1,1:np.shape(img)[1]+1].astype(int))
+                if len(regions) == 1: # Change this to cope with genuine multi-region throats
+                    for props in regions:
+                        x0,y0 = props.centroid
+                        equiv_diameter[i] = props.equivalent_diameter
+                        area[i] = props.area
+                        perimeter[i] = props.perimeter
+                        coords = props.coords
+                    "Undo the translation, scaling and truncation on the centroif"
+                    centroid2d = [x0,y0]/f
+                    centroid2d += (translation)
+                    centroid3d = np.concatenate((centroid2d,z_plane))
+                    "Distance transform the eroded facet to find the incentre and inradius"
+                    #dt[dt>r] -= r
+                    dt = ndimage.distance_transform_edt(eroded)
+                    inx0,iny0 = np.asarray(np.unravel_index(dt.argmax(), dt.shape)).astype(float)
+                    incentre2d=[inx0,iny0]
+                    "Undo the translation, scaling and truncation on the incentre"
+                    incentre2d /= f
+                    incentre2d += (translation)
+                    incentre3d = np.concatenate((incentre2d,z_plane))
+                    "The offset vertices will be those in the coords that are closest to the originals"
+                    offset_verts = []
+                    for pt in int_pts:
+                        vert = np.argmin(np.sum(np.square(coords-pt),axis=1))
+                        if vert not in offset_verts:
+                            offset_verts.append(vert)
+                    "If we are left with less than 3 different vertices then the throat is fully occluded as we can't make a shape with non-zero area"
+                    if len(offset_verts) >= 3:
+                        offset_coords = coords[offset_verts].astype(float)
+                        "Undo the translation, scaling and truncation on the offset_verts"
+                        offset_coords /= f
+                        offset_coords_3d = np.vstack((offset_coords[:,0]+translation[0],offset_coords[:,1]+translation[1],np.ones(len(offset_verts))*z_plane)).T
+                        
+                        " Get matrix to un-rotate the co-ordinates back to the original orientation if we rotated in the first place"
+                        if (rotate_facet):
+                            MI = tr.inverse_matrix(M)
+                            " Unrotate the offset coordinates "
+                            incentre[i] = np.dot(incentre3d,MI[:3,:3].T)
+                            centroid[i] = np.dot(centroid3d,MI[:3,:3].T)
+                            eroded_verts[i] = np.dot(offset_coords_3d,MI[:3,:3].T)
+                            
+                        else:
+                            incentre[i] = incentre3d
+                            centroid[i] = centroid3d
+                            eroded_verts[i] = offset_coords_3d
+                        
+                        inradius[i] = dt.max()
+                        "Undo scaling on other parameters"
+                        area[i] /= f*f
+                        perimeter[i] /= f
+                        equiv_diameter[i] /= f
+                        inradius[i] /= f
+                    else:
+                        area[i]=0
+                        perimeter[i]=0
+                        equiv_diameter[i]=0
+    
+    if kwargs["set_dependent"]==True:
+        geometry["throat.area"] = area
+        geometry["throat.perimeter"] = perimeter
+        geometry["throat.centroid"] = centroid
+        geometry["throat.diameter"] = equiv_diameter
+        geometry["throat.indiameter"] = inradius*2
+        geometry["throat.incentre"] = incentre
+    
+    return eroded_verts

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

@@ -0,0 +1,26 @@
+r"""
+===============================================================================
+Submodule -- throat_perimeter
+===============================================================================
+
+"""
+import scipy as _sp
+import OpenPNM.Utilities.transformations as tr
+import OpenPNM.Utilities.vertexops as vo
+
+def voronoi(geometry,
+            **kwargs):
+    r"""
+    Use the Voronoi verts and throat normals to work out the perimeter
+    """
+    Nt = geometry.num_throats()    
+    verts = geometry['throat.offset_vertices']
+    normals = geometry['throat.normal']
+    perimeter = _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])
+            perimeter[i] = vo.PolyPerimeter2D(verts_2D)
+        else:
+            perimeter[i] = 0.0
+    return perimeter

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

@@ -0,0 +1,12 @@
+r"""
+===============================================================================
+Submodule -- throat_seeds
+===============================================================================
+
+"""
+import scipy as _sp
+
+
+def na():
+    pass
+

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

@@ -0,0 +1,37 @@
+r"""
+===============================================================================
+Submodule -- throat_shape_factor
+===============================================================================
+
+"""
+import scipy as _sp
+
+def compactness(geometry,
+              throat_perimeter='throat.perimeter',
+              throat_area='throat.area',
+              **kwargs):
+    r"""
+    Mortensen et al. have shown that the Hagen-Poiseuille hydraluic resistance is linearly dependent on the compactness
+    Defined as perimeter^2/area.
+    The dependence is not universal as shapes with sharp corners provide more resistance than those that are more elliptical
+    Count the number of vertices and apply the right correction
+    """
+    "Only apply to throats with an area"
+    ts = geometry.throats()[geometry[throat_area]>0]
+    P = geometry[throat_perimeter]
+    A = geometry[throat_area]
+    C = _sp.ones(geometry.num_throats())
+    C[ts] = P[ts]**2/A[ts]
+    verts = geometry["throat.offset_vertices"]
+    for i in range(len(verts)):
+        if len(verts[i]) == 3:
+            "Triangular Correction"
+            C[i] = C[i]*(25/17) + (40*_sp.sqrt(3)/17)
+        elif len(verts[i]) == 4:
+            "Rectangular Correction"
+            C[i] = C[i]*(22/7) + (65/3)
+        elif len(verts[i]) > 4:
+            "Approximate Elliptical Correction"
+            C[i] = C[i]*(8/3) + (8*_sp.pi/3)
+    
+    return C

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

@@ -0,0 +1,44 @@
+r"""
+===============================================================================
+Submodule -- throat_surface_area
+===============================================================================
+
+"""
+import scipy as _sp
+
+def cylinder(geometry,
+             throat_diameter='throat.diameter',
+             throat_length='throat.length',
+             **kwargs):
+    r"""
+    Calculate throat area for a cylindrical throat
+    """
+    D = geometry[throat_diameter]
+    L = geometry[throat_length]
+    value = _sp.constants.pi*D*L
+    return value
+
+def cuboid(geometry,
+           throat_diameter='throat.diameter',
+           throat_length='throat.length',
+           **kwargs):
+    r"""
+    Calculate throat area for a cuboid throat
+    """
+    D = geometry[throat_diameter]
+    L = geometry[throat_length]
+    value = 4*D*L
+    return value
+
+def extrusion(geometry,
+              throat_perimeter='throat.perimeter',
+              throat_length='throat.length',
+              **kwargs):
+    r"""
+    Calculate surface area from perimeter and length - 
+    perimeter calculated when throat area is calculated so must be run in correct order
+    """
+    P = geometry[throat_perimeter]
+    L = geometry[throat_length]
+    value = P*L
+    return value