openpnm 1.0.0__zip

OpenPNM-1.1/OpenPNM/Network/__MatFile__.py

@@ -0,0 +1,331 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+MatFile: Subclass to import Networks from a Matlab 'mat' file
+===============================================================================
+
+"""
+import scipy as sp
+import scipy.io as spio
+import os
+from OpenPNM.Network import GenericNetwork
+import OpenPNM.Geometry
+import OpenPNM.Utilities.misc as misc
+from OpenPNM.Base import logging
+logger = logging.getLogger(__name__)
+
+class MatFile(GenericNetwork):
+    r'''
+    MatFile - constructs a pore network from a perfectly formatted .mat file (MATLAB)
+    Create network from Matlab file. Returns OpenPNM.Network.GenericNetwork()
+    object. The extra data of 'type' will trigger internal and boundary pores.
+
+    Parameters
+    ----------
+    filename : string
+        filename = 'standard_cubic_5x5x5.mat' (default)
+        Name of mat file
+    path : string
+        path='' (default)
+        the full path to the mat file on your computer
+        leaving blank searches for the file in the local directory
+    xtra_pore_data : list of strings
+        xtra_pore_data = ['type','shape','material']
+        any additional props to look for in the dictionary
+    xtra_throat_data : list of strings
+        xtra_throat_data = ['type','shape','material']
+        any additional props to look for in the dictionary
+
+    Examples
+    ---------
+    >>> import OpenPNM, os
+    >>> fname = 'test_pn' # or 'test_pn.mat'
+    >>> longpath = os.path.abspath(__file__) # line needed for auto-tests
+    >>> path,file = os.path.split(longpath) #unfortunately, auto-tests fail without this. Just type in the path of your own file, or leave it blank to search in your current directory.
+    >>> pn = OpenPNM.Network.MatFile(filename=fname,path=path,xtra_pore_data='type',xtra_throat_data='type')
+
+    Notes
+    ------
+    Matfiles should include the following variables
+
+    +----------------+------------+----------------------------------+
+    | Variable Name  | Value      | Description                      |
+    +================+============+==================================+
+    | pcoords        | <Npx3>     | physical coordinates, in meters, |
+    |                | float      | of pores to be imported          |
+    +----------------+------------+----------------------------------+
+    | pdiameter      | <Npx1>     | pore diamters, in meters         |
+    |                | float      |                                  |
+    +----------------+------------+----------------------------------+
+    | pvolume        | <Npx1>     | pore volumes, in cubic meters    |
+    |                | float      |                                  |
+    +----------------+------------+----------------------------------+
+    | pnumbering     | <Npx1>     | = 0:1:Np-1                       |
+    |                | int        |                                  |
+    +----------------+------------+----------------------------------+
+    | ptype          | <Npx1>     | (optional) designates surfaces   |
+    |                | int        | of pores in network.             |
+    |                |            | (more details below)             |
+    +----------------+------------+----------------------------------+
+    | tconnections   | <Ntx2>     | pore numbers of the two pores    |
+    |                | int        | that each throat connects        |
+    +----------------+------------+----------------------------------+
+    | tdiameter      | <Ntx1>     | throat diameters, in meters      |
+    |                | float      |                                  |
+    +----------------+------------+----------------------------------+
+    | tnumbering     | <Ntx1>     | = 0:1:Nt-1                       |
+    |                | int        |                                  |
+    +----------------+------------+----------------------------------+
+    | ttype          | <Ntx1>     | (optional) designates surfaces   |
+    |                | int        | of throats in network.           |
+    |                |            | (more details below)             |
+    +----------------+------------+----------------------------------+
+
+
+    '''
+    def __init__(self,filename='', path='', xtra_pore_data=None, xtra_throat_data=None,**kwargs):
+
+        r"""
+        """
+        super(MatFile,self).__init__(**kwargs)
+        if filename == '':
+            return
+        if path == '':
+            path = os.path.abspath('.')
+        self._path = path
+        filepath = os.path.join(self._path,filename)
+        self._xtra_pore_data=xtra_pore_data
+        self._xtra_throat_data=xtra_throat_data
+        self._dictionary=spio.loadmat(filepath)
+
+        self._Np=sp.size(self._dictionary['pnumbering'])
+        self._Nt=sp.size(self._dictionary['tnumbering'])
+
+        #Run through generation steps
+        self._add_pores()
+        self._add_throats()
+        self._remove_disconnected_clusters()
+        self._add_xtra_pore_data()
+        self._add_xtra_throat_data()
+        self._add_geometry()
+
+    def _add_pores(self):
+        Pind = sp.arange(0,self._Np)
+        self['pore.all'] = sp.ones_like(Pind,dtype=bool)
+        logger.info('Writing pore data')
+        self['pore.coords']=sp.array(self._dictionary['pcoords'],float)
+
+    def _add_throats(self):
+        Tind = sp.arange(0,self._Nt)
+        self['throat.all']=sp.ones_like(Tind,dtype=bool)
+        logger.info('Writing throat data')
+        self['throat.conns']=sp.array(self._dictionary['tconnections'],int)
+
+    def _remove_disconnected_clusters(self):
+        bad_pores = sp.array([],dtype=int)
+        self._pore_map = self.pores()
+        self._throat_map = self.throats()
+        health = self.check_network_health()
+        if health['disconnected_clusters'] == []:
+            self._throat_map = self.throats()
+            self._pore_map = self.pores()
+        else:
+            Np = self.num_pores()
+            Nt = self.num_throats()
+            cluster_sizes = [sp.shape(x)[0] for x in health['disconnected_clusters']]
+            acceptable_size = min([min([50,Np/2]),max(cluster_sizes)]) # 50 or less, if it's a really small network.
+            #step through each cluster of pores. If its a small cluster, add it to the list
+            for cluster in health['disconnected_clusters']:
+                if sp.shape(cluster)[0] < acceptable_size:
+                    bad_pores = sp.append(bad_pores,sp.ravel(cluster))
+            bad_throats = sp.unique(self.find_neighbor_throats(bad_pores))
+            #Create map for pores
+            if sp.shape(bad_pores)[0] > 0:
+                i = 0
+                self._pore_map = sp.zeros((Np-sp.shape(bad_pores)[0],),dtype=int)
+                for pore in self.pores():
+                    if pore not in bad_pores:
+                        self._pore_map[i] = pore
+                        i += 1
+            #Create map for throats
+            if sp.shape(bad_throats)[0] > 0:
+                i = 0
+                self._throat_map = sp.zeros((Nt-sp.shape(bad_throats)[0],),dtype=int)
+                for throat in self.throats():
+                    if throat not in bad_throats:
+                        self._throat_map[i] = throat
+                        i += 1
+            #Fix the pore transformer
+            try:
+                if sp.shape(bad_pores)[0] > 0:
+                    i = 0
+                    old_transform = self._dictionary['pname_transform']
+                    self._dictionary['pname_transform'] = sp.zeros((Np-sp.shape(bad_pores)[0],),dtype=int)
+                    for pore in self.pores():
+                        if pore not in bad_pores:
+                            self._dictionary['pname_transform'][i] = old_transform[pore]
+                            i += 1
+            except:
+                logger.info('Could not update pname_transform. Imported network may not have had it.')
+                pass
+            self.trim(pores=bad_pores)
+
+    def _add_geometry(self):
+        try:
+            boundary_pores = sp.where(self['pore.type']!=0)[0]
+            boundary_throats = sp.where(self['throat.type']!=0)[0]
+            self['throat.top'] = sp.ravel(self['throat.type']==1)
+            self['throat.bottom'] = sp.ravel(self['throat.type']==6)
+            self['throat.left'] = sp.ravel(self['throat.type']==2)
+            self['throat.right'] = sp.ravel(self['throat.type']==5)
+            self['throat.front'] = sp.ravel(self['throat.type']==3)
+            self['throat.back'] = sp.ravel(self['throat.type']==4)
+            self['pore.top'] = self.tomask(pores=sp.ravel(self.find_connected_pores(self.throats('top'))))
+            self['pore.bottom'] = self.tomask(sp.ravel(self.find_connected_pores(self.throats('bottom'))))
+            self['pore.left'] = self.tomask(sp.ravel(self.find_connected_pores(self.throats('left'))))
+            self['pore.right'] = self.tomask(sp.ravel(self.find_connected_pores(self.throats('right'))))
+            self['pore.front'] = self.tomask(sp.ravel(self.find_connected_pores(self.throats('front'))))
+            self['pore.back'] = self.tomask(sp.ravel(self.find_connected_pores(self.throats('back'))))
+            add_boundaries = True
+        except:
+            boundary_pores = sp.array([])
+            boundary_throats = sp.array([])
+            logger.info('No boundary pores added.')
+            add_boundaries = False
+        Ps = sp.where([pore not in boundary_pores for pore in self.pores()])[0]
+        Ts = sp.where([throat not in boundary_throats for throat in self.throats()])[0]
+        geom = OpenPNM.Geometry.GenericGeometry(network=self,pores=Ps,throats=Ts,name='internal')
+        geom['pore.volume'] = sp.ravel(sp.array(self._dictionary['pvolume'][self._pore_map[Ps]],float))
+        geom['pore.diameter'] = sp.ravel(sp.array(self._dictionary['pdiameter'][self._pore_map[Ps]],float))
+        geom['throat.diameter'] = sp.ravel(sp.array(self._dictionary['tdiameter'][self._throat_map[Ts]],float))
+        geom.add_model(propname='pore.area',model=OpenPNM.Geometry.models.pore_area.spherical)
+        geom.add_model(propname='throat.area',model=OpenPNM.Geometry.models.throat_area.cylinder)
+
+        if add_boundaries:
+            boun = OpenPNM.Geometry.Boundary(network=self,pores=boundary_pores,throats=boundary_throats,name='boundary')
+            self['pore.top_boundary']=self.tomask(pores=self.pores(['top','boundary'],mode='intersection'))
+            self['pore.bottom_boundary']=self.tomask(pores=self.pores(['bottom','boundary'],mode='intersection'))
+            self['pore.left_boundary']=self.tomask(pores=self.pores(['left','boundary'],mode='intersection'))
+            self['pore.right_boundary']=self.tomask(pores=self.pores(['right','boundary'],mode='intersection'))
+            self['pore.front_boundary']=self.tomask(pores=self.pores(['front','boundary'],mode='intersection'))
+            self['pore.back_boundary']=self.tomask(pores=self.pores(['back','boundary'],mode='intersection'))
+
+            self['throat.top_boundary']=self.tomask(throats=self.throats(['top','boundary'],mode='intersection'))
+            self['throat.bottom_boundary']=self.tomask(throats=self.throats(['bottom','boundary'],mode='intersection'))
+            self['throat.left_boundary']=self.tomask(throats=self.throats(['left','boundary'],mode='intersection'))
+            self['throat.right_boundary']=self.tomask(throats=self.throats(['right','boundary'],mode='intersection'))
+            self['throat.front_boundary']=self.tomask(throats=self.throats(['front','boundary'],mode='intersection'))
+            self['throat.back_boundary']=self.tomask(throats=self.throats(['back','boundary'],mode='intersection'))
+
+    def _add_xtra_pore_data(self):
+        xpdata = self._xtra_pore_data
+        if xpdata is not None:
+            if type(xpdata) is type([]):
+                for pdata in xpdata:
+                    try:
+                        self['pore.'+pdata]=self._dictionary['p'+pdata][self._pore_map]
+                    except:
+                        logger.warning('Could not add pore data: '+pdata+' to network')
+                        pass
+            else:
+                try:
+                    self['pore.'+xpdata]=self._dictionary['p'+xpdata][self._pore_map]
+                except:
+                    logger.warning('Could not add pore data: '+xpdata+' to network')
+                    pass
+
+    def _add_xtra_throat_data(self):
+        xtdata = self._xtra_throat_data
+        if xtdata is not None:
+            if type(xtdata) is type([]):
+                for tdata in xtdata:
+                    try:
+                        self['throat.'+tdata]=self._dictionary['t'+tdata][self._throat_map]
+                    except:
+                        logger.warning('Could not add throat data: '+tdata+' to network')
+                        pass
+            else:
+                try:
+                    self['throat.'+xtdata]=self._dictionary['t'+xtdata][self._throat_map]
+                except:
+                    logger.warning('Could not add throat data: '+xtdata+' to network')
+                    pass
+
+    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/__TestNet__.py

@@ -0,0 +1,109 @@
+"""
+===============================================================================
+TestNet: Generate simple cubic network for testing purposes
+===============================================================================
+
+"""
+
+import scipy as sp
+from OpenPNM.Network import GenericNetwork
+from OpenPNM.Base import logging
+logger = logging.getLogger(__name__)
+
+class TestNet(GenericNetwork):
+    r"""
+    A small cubic network for quick testing purposes
+
+    Parameters
+    ----------
+    This class accepts no arguments
+
+    """
+
+    def __init__(self,**kwargs):
+        super(TestNet, self).__init__(**kwargs)
+        self.generate()
+
+    def generate(self):
+        '''
+        Create test network, of cubic geometry [5,5,5]
+
+        Parameters
+        ----------
+        This network type accepts no arguments
+        '''
+        self._generate_setup()
+        self._generate_pores()
+        self._generate_throats()
+        self._add_labels()
+        return self
+
+    def _generate_setup(self):
+        r"""
+        Perform applicable preliminary checks and calculations required for generation
+        """
+        self._Nx = 5
+        self._Ny = 5
+        self._Nz = 5
+        self._Lc = 1
+        self._Lx = sp.float16(self._Nx*self._Lc)
+        self._Ly = sp.float16(self._Ny*self._Lc)
+        self._Lz = sp.float16(self._Nz*self._Lc)
+
+    def _generate_pores(self):
+        r"""
+        Generate the pores (coordinates, numbering and types)
+        """
+        Nx = self._Nx
+        Ny = self._Ny
+        Nz = self._Nz
+        Lc = self._Lc
+        Np = Nx*Ny*Nz
+        ind = sp.arange(0,Np)
+        self['pore.all'] = sp.ones_like(ind,dtype=bool)
+        pore_coords = Lc/2+Lc*sp.array(sp.unravel_index(ind, dims=(Nx, Ny, Nz), order='F'),dtype=sp.float64).T
+        self['pore.coords'] = pore_coords
+
+    def _generate_throats(self):
+        r"""
+        Generate the throats (connections, numbering and types)
+        """
+        Nx = self._Nx
+        Ny = self._Ny
+        Nz = self._Nz
+        Np = Nx*Ny*Nz
+        ind = sp.arange(0,Np)
+        #Generate throats based on pattern of the adjacency matrix
+        tpore1_1 = ind[(ind%Nx)<(Nx-1)]
+        tpore2_1 = tpore1_1 + 1
+        tpore1_2 = ind[(ind%(Nx*Ny))<(Nx*(Ny-1))]
+        tpore2_2 = tpore1_2 + Nx
+        tpore1_3 = ind[(ind%Np)<(Nx*Ny*(Nz-1))]
+        tpore2_3 = tpore1_3 + Nx*Ny
+        tpore1 = sp.hstack((tpore1_1,tpore1_2,tpore1_3))
+        tpore2 = sp.hstack((tpore2_1,tpore2_2,tpore2_3))
+        connections = sp.vstack((tpore1,tpore2)).T
+        connections = connections[sp.lexsort((connections[:, 1], connections[:, 0]))]
+        self['throat.all'] = sp.ones_like(sp.arange(0,sp.shape(tpore1)[0]),dtype=bool)
+        self['throat.conns'] = connections
+
+    def _add_labels(self):
+        coords = self['pore.coords']
+        self['pore.front'] = self.tomask(coords[:,0]<=self._Lc)
+        self['pore.left'] = self.tomask(coords[:,1]<=self._Lc)
+        self['pore.bottom'] = self.tomask(coords[:,2]<=self._Lc)
+        self['pore.back'] = self.tomask(coords[:,0]>=(self._Lc*(self._Nx-1)))
+        self['pore.right'] = self.tomask(coords[:,1]>=(self._Lc*(self._Ny-1)))
+        self['pore.top'] = self.tomask(coords[:,2]>=(self._Lc*(self._Nz-1)))
+        for item in ['top','bottom','left','right','front','back']:
+            ps = self.pores(item)
+            ts = self.find_neighbor_throats(ps)
+            ps = self.find_connected_pores(ts)
+            ps0 = self['pore.'+item][ps[:,0]]
+            ps1 = self['pore.'+item][ps[:,1]]
+            ts = ts[ps1*ps0]
+            self['throat.'+item] = self.tomask(throats=ts)
+if __name__ == '__main__':
+    import OpenPNM
+    pn = OpenPNM.Network.TestNet()
+    print(pn.name)

OpenPNM-1.1/OpenPNM/Network/__init__.py

@@ -0,0 +1,40 @@
+r"""
+###############################################################################
+:mod:`OpenPNM.Network`: Classes related the creation of network topology
+###############################################################################
+
+Contents
+--------
+**GenericNetwork** -- Contains many methods ` for working with the topology of the
+networks
+
+**Subclasses** -- Inherit from GenericNetwork, and contain additional methods for
+actually generating topology.
+
+Classes
+-------
+
+.. autoclass:: GenericNetwork
+   :members:
+
+.. autoclass:: Cubic
+   :members:
+
+.. autoclass:: Delaunay
+   :members:
+
+.. autoclass:: DelaunayCubic
+   :members:
+   
+.. autoclass:: MatFile
+   :members:
+
+"""
+
+from .__GenericNetwork__ import GenericNetwork
+from .__Cubic__ import Cubic
+from .__Delaunay__ import Delaunay
+from .__DelaunayCubic__ import DelaunayCubic
+from .__MatFile__ import MatFile
+from .__TestNet__ import TestNet
+from . import models

OpenPNM-1.1/OpenPNM/Network/models/__init__.py

@@ -0,0 +1,12 @@
+r"""
+*******************************************************************************
+models -- Models for calculating additional network topology properties
+*******************************************************************************
+
+Contents
+--------
+This module contains methods for calculating extra topology information
+
+"""
+
+from . import pore_topology

OpenPNM-1.1/OpenPNM/Network/models/pore_topology.py

@@ -0,0 +1,106 @@
+r"""
+===============================================================================
+pore_topology -- functions for monitoring and adjusting topology
+===============================================================================
+
+"""
+import scipy as _sp
+
+def get_subscripts(network,
+                   shape,
+                   **kwargs):
+    r'''
+    Return the 3D subscripts (i,j,k) into the cubic network
+
+    Parameters
+    ----------
+    shape : list
+        The (i,j,k) shape of the network in number of pores in each direction
+
+    '''
+    if network.num_pores('internal') != _sp.prod(shape):
+        print('Supplied shape does not match Network size, cannot proceed')
+    else:
+        template = _sp.atleast_3d(_sp.empty(shape))
+        a = _sp.indices(_sp.shape(template))
+        i = a[0].flatten()
+        j = a[1].flatten()
+        k = a[2].flatten()
+        ind = _sp.vstack((i,j,k)).T
+        vals = _sp.ones((network.Np,3))*_sp.nan
+        vals[network.pores('internal')] = ind
+        return vals
+
+def adjust_spacing(network,
+                   new_spacing,
+                   **kwargs):
+    r'''
+    Adjust the the pore-to-pore lattice spacing on a cubic network
+
+    Parameters
+    ----------
+    new_spacing : float
+        The new lattice spacing to apply
+
+    Notes
+    -----
+    At present this method only applies a uniform spacing in all directions.
+    This is a limiation of OpenPNM Cubic Networks in general, and not of the
+    method.
+    '''
+    coords = network['pore.coords']
+    try:
+        spacing = network._spacing
+        coords = coords/spacing*new_spacing
+        network._spacing = new_spacing
+    except:
+        pass
+    return coords
+
+def reduce_coordination(network,
+                        z,
+                        mode='random',
+                        **kwargs):
+    r'''
+    Reduce the coordination number to the specified z value
+
+    Parameters
+    ----------
+    z : int
+        The coordination number or number of throats connected a pore
+
+    mode : string, optional
+        Controls the logic used to trim connections.  Options are:
+
+        - 'random': (default) Throats will be randomly removed to achieve a coordination of z
+        - 'max': All pores will be adjusted to have a maximum coordination of z (not implemented yet)
+
+    Returns
+    -------
+    A label array indicating which throats should be trimmed to achieve desired
+    coordination.
+
+    Notes
+    -----
+    Pores with only 1 throat will be ignored in all calculations since these
+    are generally boundary pores.
+
+    '''
+    T_trim = ~network['throat.all']
+    T_nums = network.num_neighbors(network.pores())
+    #Find protected throats
+    T_keep = network.find_neighbor_throats(pores=(T_nums==1))
+    if mode == 'random':
+        z_ave = _sp.average(T_nums[T_nums>1])
+        f_trim = (z_ave - z)/z_ave
+        T_trim = _sp.rand(network.Nt)<f_trim
+        T_trim = T_trim*(~network.tomask(throats=T_keep))
+    if mode == 'max':
+        pass
+    return T_trim
+
+
+
+
+
+

OpenPNM-1.1/OpenPNM/Phases/__Air__.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+from OpenPNM.Phases import GenericPhase
+from OpenPNM.Phases import models as fm
+
+class Air(GenericPhase):
+    r"""
+    Creates Phase object with preset models and values for air
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The network to which this phase object will be attached.
+
+    Notes
+    -----
+    The initial properties are all at std conditions of T = 298 K and P = 1 atm.
+
+    References
+    ----------
+    [1] E.W. Lemmon and R.T. Jacobsen, "Viscosity and Thermal Conductivity
+    Equations for Nitrogen, Oxygen, Argon, and Air", Int. J. of Thermophysics,
+    Vol. 25, No. 1, January 2004, pp. 21-69
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.TestNet()
+    >>> air = OpenPNM.Phases.Air(network=pn)
+
+    """
+    def __init__(self,name=None,**kwargs):
+        super(Air,self).__init__(name=name,**kwargs)
+        self._generate()
+
+    def _generate(self):
+        self['pore.molecular_weight'] = 0.02896                        # kg/mol
+        self['pore.critical_pressure'] = 3.786E6                           # Pa
+        self['pore.critical_temperature'] = 132.5                           # K
+        self['pore.critical_volume'] = 0.002917                         # kg/m3
+        self['pore.contact_angle'] = 110.0                             # Degree
+        self.models.add(propname='pore.density',
+                       model=fm.density.ideal_gas)                      # kg/m3
+        self.models.add(propname='pore.molar_density',
+                       model=fm.molar_density.ideal_gas)               # mol/m3
+        self.models.add(propname='pore.diffusivity',
+                        model=fm.diffusivity.fuller,
+                        MA=0.032,
+                        MB=0.028,
+                        vA=16.6,
+                        vB=17.9)
+        self.models.add(propname='pore.thermal_conductivity',           # W/m.K
+                        model=fm.misc.polynomial,
+                        poreprop='pore.temperature',
+                        a=[0.00422791,0.0000789606,-1.56383E-08])
+        self.models.add(propname='pore.viscosity',                     # kg/m.s
+                        model=fm.misc.polynomial,
+                        poreprop='pore.temperature',
+                        a=[0.00000182082,6.51815E-08,-3.48553E-11,1.11409E-14])
+
+if __name__ =="__main__":
+    import OpenPNM
+    pn = OpenPNM.Network.TestNet()
+    air = OpenPNM.Phases.Air(network=pn)