openpnm 1.0.0__zip

OpenPNM-1.1/OpenPNM/Postprocessing/Plots.py

@@ -0,0 +1,369 @@
+import scipy as _sp
+import matplotlib.pylab as _plt
+
+def profiles(network,
+             fig=None,
+             values=None,
+             bins=[10,10,10]):
+    r'''
+    Compute the profiles for the property of interest and plots it in all
+    three dimensions
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+
+    values : array_like, optional
+        The pore property values to be plotted as a profile
+
+    bins : int or list of ints, optional
+        The number of bins to divide the domain into for averaging.
+
+    Notes
+    -----
+    Either propname or values can be sent, but not both
+
+    '''
+    if fig is None:
+        fig = _plt.figure()
+    ax1 = fig.add_subplot(131)
+    ax2 = fig.add_subplot(132)
+    ax3 = fig.add_subplot(133)
+    ax = [ax1,ax2,ax3]
+    xlab = ['x coordinate','y_coordinate','z_coordinate']
+    for n in [0,1,2]:
+        n_min, n_max = [_sp.amin(network['pore.coords'][:,n]), _sp.amax(network['pore.coords'][:,n])]
+        steps = _sp.linspace(n_min,n_max,bins[n]+1,endpoint=True)
+        vals = _sp.zeros_like(steps)
+        for i in range(0,len(steps)-1):
+            temp = (network['pore.coords'][:,n] > steps[i])*(network['pore.coords'][:,n] <= steps[i+1])
+            vals[i] = _sp.mean(values[temp])
+        yaxis = vals[:-1]
+        xaxis = (steps[:-1] + (steps[1]-steps[0])/2)/n_max
+        ax[n].plot(xaxis,yaxis,'bo-')
+        ax[n].set_xlabel(xlab[n])
+        ax[n].set_ylabel('Slice Value')
+    fig.show()
+
+def porosity_profile(network,
+                      fig=None, axis=2):
+
+    r'''
+    Compute and plot the porosity profile in all three dimensions
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+    axis : integer type 0 for x-axis, 1 for y-axis, 2 for z-axis
+
+    Notes
+    -----
+    the area of the porous medium at any position is calculated from the
+    maximum pore coordinates in each direction
+
+    '''
+    if fig is None:
+        fig = _plt.figure()
+    L_x = _sp.amax(network['pore.coords'][:,0]) + _sp.mean(((21/88.0)*network['pore.volume'])**(1/3.0))
+    L_y = _sp.amax(network['pore.coords'][:,1]) + _sp.mean(((21/88.0)*network['pore.volume'])**(1/3.0))
+    L_z = _sp.amax(network['pore.coords'][:,2]) + _sp.mean(((21/88.0)*network['pore.volume'])**(1/3.0))
+    if axis is 0:
+        xlab = 'x-direction'
+        area = L_y*L_z
+    elif axis is 1:
+        xlab = 'y-direction'
+        area = L_x*L_z
+    else:
+        axis = 2
+        xlab = 'z-direction'
+        area = L_x*L_y
+    n_max = _sp.amax(network['pore.coords'][:,axis]) + _sp.mean(((21/88.0)*network['pore.volume'])**(1/3.0))
+    steps = _sp.linspace(0,n_max,100,endpoint=True)
+    vals = _sp.zeros_like(steps)
+    p_area = _sp.zeros_like(steps)
+    t_area = _sp.zeros_like(steps)
+
+    rp = ((21/88.0)*network['pore.volume'])**(1/3.0)
+    p_upper = network['pore.coords'][:,axis] + rp
+    p_lower = network['pore.coords'][:,axis] - rp
+    TC1 = network['throat.conns'][:,0]
+    TC2 = network['throat.conns'][:,1]
+    t_upper = network['pore.coords'][:,axis][TC1]
+    t_lower = network['pore.coords'][:,axis][TC2]
+
+    for i in range(0,len(steps)):
+        p_temp = (p_upper > steps[i])*(p_lower < steps[i])
+        t_temp = (t_upper > steps[i])*(t_lower < steps[i])
+        p_area[i] = sum((22/7.0)*(rp[p_temp]**2 - (network['pore.coords'][:,axis][p_temp]-steps[i])**2))
+        t_area[i] = sum(network['throat.area'][t_temp])
+        vals[i] = (p_area[i]+t_area[i])/area
+    yaxis = vals
+    xaxis = steps/n_max
+    _plt.plot(xaxis,yaxis,'bo-')
+    _plt.xlabel(xlab)
+    _plt.ylabel('Porosity')
+    fig.show()
+
+def saturation_profile(network, phase, fig=None, axis=2):
+
+    r'''
+    Compute and plot the saturation profile in all three dimensions
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+    phase : the invading or defending phase to plot its saturation distribution
+    axis : integer type 0 for x-axis, 1 for y-axis, 2 for z-axis
+
+    '''
+    if fig is None:
+        fig = _plt.figure()
+    if phase is None:
+        raise Exception('The phase for saturation profile plot is not given' )
+    if axis is 0:
+        xlab = 'x-direction'
+    elif axis is 1:
+        xlab = 'y-direction'
+    else:
+        axis = 2
+        xlab = 'z-direction'
+    n_max = _sp.amax(network['pore.coords'][:,axis]) + _sp.mean(((21/88.0)*network['pore.volume'])**(1/3.0))
+    steps = _sp.linspace(0,n_max,100,endpoint=True)
+    p_area = _sp.zeros_like(steps)
+    op_area = _sp.zeros_like(steps)
+    t_area = _sp.zeros_like(steps)
+    ot_area = _sp.zeros_like(steps)
+    vals = _sp.zeros_like(steps)
+    PO = phase['pore.occupancy']
+    TO = phase['throat.occupancy']
+    rp = ((21/88.0)*network['pore.volume'])**(1/3.0)
+    p_upper = network['pore.coords'][:,axis] + rp
+    p_lower = network['pore.coords'][:,axis] - rp
+
+    TC1 = network['throat.conns'][:,0]
+    TC2 = network['throat.conns'][:,1]
+    t_upper = network['pore.coords'][:,axis][TC1]
+    t_lower = network['pore.coords'][:,axis][TC2]
+
+    for i in range(0,len(steps)):
+        op_temp = (p_upper > steps[i])*(p_lower < steps[i])*PO
+        ot_temp = (t_upper > steps[i])*(t_lower < steps[i])*TO
+        op_temp = _sp.array(op_temp, dtype='bool')
+        ot_temp = _sp.array(op_temp, dtype='bool')
+        p_temp = (p_upper > steps[i])*(p_lower < steps[i])
+        t_temp = (t_upper > steps[i])*(t_lower < steps[i])
+        op_area[i] = sum((22/7.0)*(rp[op_temp]**2 - (network['pore.coords'][:,axis][op_temp]-steps[i])**2))
+        ot_area[i] = sum(network['throat.area'][ot_temp])
+        p_area[i] = sum((22/7.0)*(rp[p_temp]**2 - (network['pore.coords'][:,axis][p_temp]-steps[i])**2))
+        t_area[i] = sum(network['throat.area'][t_temp])
+        vals[i] = (op_area[i]+ot_area[i])/(p_area[i]+t_area[i])
+        if vals[i]>1:
+            vals[i]=1.
+        if _sp.isnan(vals[i]):
+            vals[i]=1.
+
+    if vals[-1]==1.:
+        vals = vals[::-1]
+    
+    yaxis = vals
+    xaxis = steps/n_max
+    _plt.plot(xaxis,yaxis,'bo-')
+    _plt.xlabel(xlab)
+    _plt.ylabel('Saturation')
+    fig.show()
+    
+def distributions(net,
+                  fig = None,
+                  throat_diameter='throat.diameter',
+                  pore_diameter='pore.diameter',
+                 throat_length='throat.length',
+                 exclude_boundaries=True,
+                 geom_list=None):
+    r"""
+    Plot a montage of key network size distribution histograms
+
+    Parameters
+    ----------
+    net : OpenPNM Network Object
+    The network for which the graphs are desired
+
+    """
+    if fig is None:
+        fig = _plt.figure()
+        
+    fig.subplots_adjust(hspace = 0.4)
+    fig.subplots_adjust(wspace = 0.4)
+    
+    if geom_list is not None:
+        include_pores = [False]*net.num_pores()
+        include_throats = [False]*net.num_throats()
+        for geom in geom_list:
+            include_pores = include_pores | net["pore."+geom]
+            include_throats = include_throats | net["throat."+geom]
+    else:
+        include_pores = net["pore.all"]
+        include_throats = net["throat.all"]
+    pores = net.pores()[include_pores]
+    throats = net.throats()[include_throats]
+
+
+    ax1 = fig.add_subplot(221)
+    ax1.hist(net[pore_diameter][pores],25,facecolor='green')
+    ax1.set_xlabel('Pore Diameter')
+    ax1.set_ylabel('Frequency')
+    ax1.ticklabel_format(style='sci', axis='x', scilimits=(0,0))
+
+    ax2 = fig.add_subplot(222)
+    x = net.num_neighbors(pores,flatten=False)
+    ax2.hist(x,25,facecolor='yellow')
+    ax2.set_xlabel('Coordination Number')
+    ax2.set_ylabel('Frequency')
+
+    ax3 = fig.add_subplot(223)
+    ax3.hist(net[throat_diameter][throats],25,facecolor='blue')
+    ax3.set_xlabel('Throat Diameter')
+    ax3.set_ylabel('Frequency')
+    ax3.ticklabel_format(style='sci', axis='x', scilimits=(0,0))
+
+    ax4 = fig.add_subplot(224)
+    ax4.hist(net[throat_length][throats],25,facecolor='red')
+    ax4.set_xlabel('Throat Length')
+    ax4.set_ylabel('Frequency')
+    ax4.ticklabel_format(style='sci', axis='x', scilimits=(0,0))
+    fig.show()
+
+def pore_size_distribution(network, fig=None,):
+
+    r'''
+    Plot the pore and throat size distribution which is the accumulated 
+    volume vs. the diameter in a semilog plot
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+    
+    '''
+    if fig is None:
+        fig = _plt.figure()
+    dp = network['pore.diameter']
+    Vp = network['pore.volume']
+    dt = network['throat.diameter']
+    Vt = network['throat.volume']
+    dmax = max(max(dp),max(dt))
+    steps = _sp.linspace(0,dmax,100,endpoint=True)
+    vals = _sp.zeros_like(steps)
+    for i in range(0,len(steps)-1):
+        temp1 = dp > steps[i]
+        temp2 = dt > steps[i]
+        vals[i] = sum(Vp[temp1]) + sum(Vt[temp2])
+    yaxis = vals
+    xaxis = steps
+    _plt.semilogx(xaxis,yaxis,'b.-')
+    _plt.xlabel('Pore & Throat Diameter (m)')
+    _plt.ylabel('Cumulative Volume (m^3)')
+    fig.show()
+    
+def drainage_curves(inv_alg,
+                    fig=None,
+                    Pc='inv_Pc',
+                    sat='inv_sat',
+                    seq='inv_seq',
+                    timing=None):
+    r"""
+    Plot a montage of key saturation plots
+
+    Parameters
+    ----------
+    inv_alg : OpenPNM Algorithm Object
+    The invasion algorithm for which the graphs are desired
+
+    timing : string
+    if algorithm keeps track of simulated time, insert string here.
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.TestNet()
+    >>> geo = OpenPNM.Geometry.TestGeometry(network=pn,pores=pn.pores(),throats=pn.throats())
+    >>> phase1 = OpenPNM.Phases.TestPhase(network=pn)
+    >>> phase2 = OpenPNM.Phases.TestPhase(network=pn)
+    >>> phys1 = OpenPNM.Physics.TestPhysics(network=pn, phase=phase1,pores=pn.pores(),throats=pn.throats())
+    >>> phys2 = OpenPNM.Physics.TestPhysics(network=pn, phase=phase2,pores=pn.pores(),throats=pn.throats())
+    >>> IP = OpenPNM.Algorithms.InvasionPercolationTimed(network=pn)
+    >>> IP.run(invading_phase=phase1, defending_phase=phase2, inlets=pn.pores('top'), outlets=pn.pores('bottom'))
+         IP algorithm at 0 % completion at 0.0 seconds
+         IP algorithm at 20 % completion at 0.0 seconds
+         IP algorithm at 40 % completion at 0.0 seconds
+         IP algorithm at 60 % completion at 0.0 seconds
+         IP algorithm at 100% completion at  0.0  seconds
+    >>> OpenPNM.Postprocessing.Plots.drainage_curves(IP,timing='inv_time')
+    """
+    inv_throats = inv_alg.toindices(inv_alg['throat.'+seq]>0)
+    sort_seq = _sp.argsort(inv_alg['throat.'+seq][inv_throats])
+    inv_throats = inv_throats[sort_seq]
+
+    if fig is None:
+        fig = _plt.figure(num=1, figsize=(13, 10), dpi=80, facecolor='w', edgecolor='k')
+    ax1 = fig.add_subplot(231)   #left
+    ax2 = fig.add_subplot(232)   #middle
+    ax3 = fig.add_subplot(233)   #right
+    ax4 = fig.add_subplot(234)   #left
+    ax5 = fig.add_subplot(235)   #middle
+    ax6 = fig.add_subplot(236)   #right
+
+    ax1.plot(inv_alg['throat.'+Pc][inv_throats],inv_alg['throat.'+sat][inv_throats])
+    ax1.set_xlabel('Capillary Pressure (Pa)')
+    ax1.set_ylabel('Saturation')
+    ax1.set_ylim([0,1])
+    ax1.set_xlim([0.99*min(inv_alg['throat.'+Pc][inv_throats]),1.01*max(inv_alg['throat.'+Pc][inv_throats])])
+
+    ax2.plot(inv_alg['throat.'+seq][inv_throats],inv_alg['throat.'+sat][inv_throats])
+    ax2.set_xlabel('Simulation Step')
+    ax2.set_ylabel('Saturation')
+    ax2.set_ylim([0,1])
+    ax2.set_xlim([0,1.01*max(inv_alg['throat.'+seq][inv_throats])])
+
+    if timing==None:
+        ax3.plot(0,0)
+        ax3.set_xlabel('No Time Data Available')
+    else:
+        ax3.plot(inv_alg['throat.'+timing][inv_throats],inv_alg['throat.'+sat][inv_throats])
+        ax3.set_xlabel('Time (s)')
+        ax3.set_ylabel('Saturation')
+        ax3.set_ylim([0,1])
+        ax3.set_xlim([0,1.01*max(inv_alg['throat.'+timing][inv_throats])])
+
+    ax4.plot(inv_alg['throat.'+sat][inv_throats],inv_alg['throat.'+Pc][inv_throats])
+    ax4.set_ylabel('Capillary Pressure (Pa)')
+    ax4.set_xlabel('Saturation')
+    ax4.set_xlim([0,1])
+    ax4.set_ylim([0.99*min(inv_alg['throat.'+Pc][inv_throats]),1.01*max(inv_alg['throat.'+Pc][inv_throats])])
+
+    ax5.plot(inv_alg['throat.'+seq][inv_throats],inv_alg['throat.'+Pc][inv_throats])
+    ax5.set_xlabel('Simulation Step')
+    ax5.set_ylabel('Capillary Pressure (Pa)')
+    ax5.set_ylim([0.99*min(inv_alg['throat.'+Pc][inv_throats]),1.01*max(inv_alg['throat.'+Pc][inv_throats])])
+    ax5.set_xlim([0,1.01*max(inv_alg['throat.'+seq][inv_throats])])
+
+    if timing==None:
+        ax6.plot(0,0)
+        ax6.set_xlabel('No Time Data Available')
+    else:
+        ax6.plot(inv_alg['throat.'+timing][inv_throats],inv_alg['throat.'+Pc][inv_throats])
+        ax6.set_xlabel('Time (s)')
+        ax6.set_ylabel('Capillary Pressure (Pa)')
+        ax6.set_ylim([0.99*min(inv_alg['throat.'+Pc][inv_throats]),1.01*max(inv_alg['throat.'+Pc][inv_throats])])
+        ax6.set_xlim([0,1.01*max(inv_alg['throat.'+timing][inv_throats])])
+
+    fig.subplots_adjust(left=0.08, right=0.99, top=0.95, bottom=0.1)
+    ax1.grid(True)
+    ax2.grid(True)
+    ax3.grid(True)
+    ax4.grid(True)
+    ax5.grid(True)
+    ax6.grid(True)
+    fig.show()
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=True)

OpenPNM-1.1/OpenPNM/Postprocessing/__init__.py

@@ -0,0 +1,10 @@
+r"""
+###############################################################################
+:mod:`OpenPNM.Postprocessing` -- Analysis, Plotting and some Visualization
+###############################################################################
+
+
+"""
+
+from . import Plots
+from . import Graphics

OpenPNM-1.1/OpenPNM/Utilities/IO.py

@@ -0,0 +1,277 @@
+from OpenPNM.Utilities import misc
+import scipy as _sp
+import numpy as _np
+import os as _os
+import pickle as _pickle
+from xml.etree import ElementTree as _ET
+
+
+
+class VTK():
+    r"""
+    Class for writing a Vtp file to be read by ParaView
+
+    """
+
+    _TEMPLATE = '''
+    <?xml version="1.0" ?>
+    <VTKFile byte_order="LittleEndian" type="PolyData" version="0.1">
+        <PolyData>
+            <Piece NumberOfLines="0" NumberOfPoints="0">
+                <Points>
+                </Points>
+                <Lines>
+                </Lines>
+                <PointData>
+                </PointData>
+                <CellData>
+                </CellData>
+            </Piece>
+        </PolyData>
+    </VTKFile>
+    '''.strip()
+
+
+    def __init__(self,**kwargs):
+        r"""
+        Initialize
+        """
+        super().__init__(**kwargs)
+
+    @staticmethod
+    def save(network,filename='',phases=[]):
+        r'''
+        Save network and phase data to a single vtp file for visualizing in
+        Paraview
+
+        Parameters
+        ----------
+        network : OpenPNM Network Object
+            The Network containing the data to be written
+
+        filename : string, optional
+            Filename to write data.  If no name is given the file is named after
+            ther network
+
+        phases : list, optional
+            A list contain OpenPNM Phase object(s) containing data to be written
+
+        Examples
+        --------
+        >>> import OpenPNM
+        >>> pn = OpenPNM.Network.Cubic(shape=[3,3,3])
+        >>> geo = OpenPNM.Geometry.Stick_and_Ball(network=pn,pores=pn.pores(),throats=pn.throats())
+        >>> air = OpenPNM.Phases.Air(network=pn)
+        >>> phys = OpenPNM.Physics.Standard(network=pn,phase=air,pores=pn.pores(),throats=pn.throats())
+
+        >>> import OpenPNM.Utilities.IO as io
+        >>> io.VTK.save(pn,'test_pn.vtp',[air])
+
+        >>> # Delete the new file
+        >>> import os
+        >>> os.remove('test_pn.vtp')
+        '''
+
+        if filename == '':
+            filename = network.name
+        filename = filename.split('.')[0]+'.vtp'
+
+        root = _ET.fromstring(VTK._TEMPLATE)
+        objs = []
+        if type(phases) != list:
+            phases = [phases]
+        for phase in phases:
+            objs.append(phase)
+        objs.append(network)
+        am = misc.amalgamate_data(objs=objs)
+        key_list = list(sorted(am.keys()))
+        points = network['pore.coords']
+        pairs = network['throat.conns']
+
+        num_points = len(points)
+        num_throats = len(pairs)
+
+        piece_node = root.find('PolyData').find('Piece')
+        piece_node.set("NumberOfPoints", str(num_points))
+        piece_node.set("NumberOfLines", str(num_throats))
+
+        points_node = piece_node.find('Points')
+        coords = VTK._array_to_element("coords", points.T.ravel('F'), n=3)
+        points_node.append(coords)
+
+        lines_node = piece_node.find('Lines')
+        connectivity = VTK._array_to_element("connectivity", pairs)
+        lines_node.append(connectivity)
+        offsets = VTK._array_to_element("offsets", 2*_np.arange(len(pairs))+2)
+        lines_node.append(offsets)
+
+        point_data_node = piece_node.find('PointData')
+        for key in key_list:
+            array = am[key]
+            if array.dtype == _np.bool: array = array.astype(int)
+            if array.size != num_points: continue
+            element = VTK._array_to_element(key, array)
+            point_data_node.append(element)
+
+        cell_data_node = piece_node.find('CellData')
+        for key in key_list:
+            array = am[key]
+            if array.dtype == _np.bool: array = array.astype(int)
+            if array.size != num_throats: continue
+            element = VTK._array_to_element(key, array)
+            cell_data_node.append(element)
+
+        tree = _ET.ElementTree(root)
+        tree.write(filename)
+
+        #Make pretty
+        with open(filename, "r+") as f:
+            string = f.read()
+            string = string.replace("</DataArray>", "</DataArray>\n\t\t\t")
+            f.seek(0)
+            # consider adding header: '<?xml version="1.0"?>\n'+
+            f.write(string)
+
+    @staticmethod
+    def load(filename):
+        r'''
+        Read in pore and throat data from a saved VTK file.
+
+        Notes
+        -----
+        This will NOT reproduce original simulation, since all models and object
+        relationships are lost.  Use IO.Save and IO.Load for that.'''
+        network = OpenPNM.Network.GenericNetwork()
+        tree = _ET.parse(filename)
+        piece_node = tree.find('PolyData').find('Piece')
+
+        # extract connectivity
+        conn_element = piece_node.find('Lines').find('DataArray')
+        array = VTK._element_to_array(conn_element, 2)
+        network['throat.conns'] = array.T
+
+        for element in piece_node.find('PointData').iter('DataArray'):
+            key = element.get('Name')
+            array = VTK._element_to_array(element)
+            netname = key.split('.')[0]
+            propname = key.strip(netname+'.')
+            network[propname] = array
+
+        return network
+
+    @staticmethod
+    def _array_to_element(name, array, n=1):
+        dtype_map = {
+            'int8'   : 'Int8',
+            'int16'  : 'Int16',
+            'int32'  : 'Int32',
+            'int64'  : 'Int64',
+            'uint8'  : 'UInt8',
+            'uint16' : 'UInt16',
+            'uint32' : 'UInt32',
+            'uint64' : 'UInt64',
+            'float32': 'Float32',
+            'float64': 'Float64',
+            'str'    : 'String',
+        }
+        element = _ET.Element('DataArray')
+        element.set("Name", name)
+        element.set("NumberOfComponents", str(n))
+        element.set("type", dtype_map[str(array.dtype)])
+        element.text = '\t'.join(map(str,array.ravel()))
+        return element
+
+    @staticmethod
+    def _element_to_array(element, n=1):
+        string = element.text
+        dtype = element.get("type")
+        array = _np.fromstring(string, sep='\t')
+        array = array.astype(dtype)
+        if n is not 1:
+            array = array.reshape(array.size//n, n)
+        return array
+
+class MAT():
+    r'''
+    Class for reading and writing OpenPNM data to a Matlab 'mat' file
+    '''
+
+    def __init__(self,**kwargs):
+        r"""
+        Initialize
+        """
+        super().__init__(**kwargs)
+
+    @staticmethod
+    def save(network, filename='', phases=[]):
+        r"""
+        Write Network to a Mat file for exporting to Matlab. This method will be
+        enhanced in a future update, and it's functionality may change!
+
+        Parameters
+        ----------
+
+        network : OpenPNM Network Object
+
+        filename : string
+            Desired file name, defaults to network name if not given
+
+        phases : list of phase objects ([])
+            Phases that have properties we want to write to file
+
+        Examples
+        --------
+        >>> import OpenPNM
+        >>> pn = OpenPNM.Network.TestNet()
+        >>> geo = OpenPNM.Geometry.TestGeometry(network=pn,pores=pn.pores(),throats=pn.throats())
+        >>> air = OpenPNM.Phases.TestPhase()
+        >>> import OpenPNM.Utilities.IO as io
+        >>> io.MAT.save(network=pn,filename='test_pn.mat',phases=air)
+
+        >>> #Remove newly created file
+        >>> import os
+        >>> os.remove('test_pn.mat')
+
+        """
+        if filename == '':
+            filename = network.name
+        filename = filename.split('.')[0]+'.mat'
+
+        pnMatlab = {}
+        new = []
+        old = []
+        for keys in network.keys():
+            old.append(keys)
+            new.append(keys.replace('.','_'))
+
+        for i in range(len(network)):
+            pnMatlab[new[i]] = network[old[i]]
+
+        if type(phases) != list:
+            phases = [phases]
+        if len(phases) != 0:
+            for j in range(len(phases)):
+                new = []
+                old = []
+
+                for keys in phases[j].keys():
+                    old.append(keys)
+                    new.append(phases[j].name+'_'+keys.replace('.','_'))
+
+                for i in range(len(phases[j])):
+                    pnMatlab[new[i]] = phases[j][old[i]]
+
+        _sp.io.savemat(file_name=filename,mdict=pnMatlab)
+
+    @staticmethod
+    def load():
+        r'''
+        This method is not implemented yet.
+        '''
+        raise NotImplemented()
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=True)
+

OpenPNM-1.1/OpenPNM/Utilities/Shortcuts.py

@@ -0,0 +1,17 @@
+import string, random
+import OpenPNM.Phases
+
+def solve_linear(pn, ics):
+    # circumvent bug with naming by creating random names
+    name = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
+    pseudo = OpenPNM.Phases.GenericPhase(network=pn, name=name)
+    pseudo['throat.electrical_conductance']=1
+
+    alg = OpenPNM.Algorithms.OhmicConduction(network=pn)
+    alg['pore.BCval']=ics
+    alg['pore.Dirichlet']=ics!=0
+    alg.run(active_phase=pseudo)
+    alg.return_results()
+
+    out = pseudo['pore.voltage']
+    return out

OpenPNM-1.1/OpenPNM/Utilities/__init__.py

@@ -0,0 +1,16 @@
+r"""
+###############################################################################
+:mod:`OpenPNM.Utilities` -- IO, geometry tools and other functions
+###############################################################################
+
+.. automodule:: OpenPNM.Utilities.IO
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+"""
+
+from . import IO
+from . import transformations
+from . import misc
+from . import vertexops