openpnm 1.0.0__zip

OpenPNM-1.1/OpenPNM/Phases/__GenericPhase__.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+module __GenericPhase__: Base class for building Phase objects
+===============================================================================
+
+"""
+from OpenPNM.Base import Core, Tools, logging
+logger = logging.getLogger(__name__)
+from OpenPNM.Network import GenericNetwork
+import OpenPNM.Phases.models
+import scipy as sp
+
+class GenericPhase(Core):
+    r"""
+    Base class to generate a generic phase object.  The user must specify models
+    and parameters for all the properties they require. Classes for several
+    common phases are included with OpenPNM and can be found under OpenPNM.Phases.
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The network to which this Phase should be attached
+
+    components : list of OpenPNM Phase objects
+        These Phase objects are ficticious or virtual phases that are the pure
+        components from which the mixture is made.  They are used to calculate
+        and store any pure component data.  If none are supplied then this
+        object will act like either a pure component, a mixture whose properties
+        are well known (like air) and need not to be found from consideration of
+        the pure component properties.
+
+    name : str, optional
+        A unique string name to identify the Phase object, typically same as
+        instance name but can be anything.
+
+    """
+    def __init__(self,network=None,components=[],**kwargs):
+        super(GenericPhase,self).__init__(**kwargs)
+        logger.name = self.name
+
+        if network is None:
+            self._net = GenericNetwork()
+        else:
+            self._net = network
+
+        # Initialize label 'all' in the object's own info dictionaries
+        self['pore.all'] = self._net['pore.all']
+        self['throat.all'] = self._net['throat.all']
+
+        #Set standard conditions on the fluid to get started
+        self['pore.temperature'] = 298.0
+        self['pore.pressure'] = 101325.0
+
+        # Register Ohase object in Network dictionary
+        self._net['pore.'+self.name] = True
+        self._net['throat.'+self.name] = True
+
+        if components != []:
+            for comp in components:
+                self.set_component(phase=comp)
+        self._net._phases.append(self)  # Append this Phase to the Network
+
+    def __setitem__(self,prop,value):
+        for phys in self._physics:
+            if (prop in phys.keys()) and ('all' not in prop.split('.')):
+                    logger.error(prop+' is already defined in at least one associated Physics object')
+                    return
+        super(GenericPhase,self).__setitem__(prop,value)
+
+    def __getitem__(self,key):
+        if key.split('.')[-1] == self.name:
+            element = key.split('.')[0]
+            return self[element+'.all']
+        if key not in self.keys():
+            logger.debug(key+' not on Phase, constructing data from Physics')
+            return self._interleave_data(key,sources=self._physics)
+        else:
+            return super(GenericPhase,self).__getitem__(key)
+
+    def set_component(self,phase,mode='add'):
+        r'''
+        This method is used to add or remove a ficticious phase object to this
+        object.
+
+        Parameters
+        ----------
+        phase : OpenPNM Phase object
+            This is the ficticious phase object defining a pure component.
+
+        mode : string
+            Indicates whether to 'add' or 'remove' the supplied Phase object
+        '''
+        if mode == 'add':
+            if phase.name in self.phases():
+                logger.error('Phase already present')
+                pass
+            else:
+                self._phases.append(phase) # Associate any sub-phases with self
+                phase._phases.append(self)  # Associate self with sub-phases
+                #Add models for components to inherit mixture T and P
+                phase.models.add(propname='pore.temperature',model=OpenPNM.Phases.models.misc.mixture_value)
+                phase.models.add(propname='pore.pressure',model=OpenPNM.Phases.models.misc.mixture_value)
+                #Move T and P models to beginning of regeneration order
+                phase.models.reorder({'pore.temperature':0,'pore.pressure':1})
+        elif mode == 'remove':
+            if phase.name in self.phases():
+                self._phases.remove(phase)
+                phase._phases = []
+            else:
+                logger.error('Phase not found')
+                pass
+
+    def check_mixture_health(self):
+        r'''
+        Query the properties of the 'virtual phases' that make up a mixture
+        to ensure they all add up
+        '''
+        mole_sum = sp.zeros((self.Np,))
+        for comp in self._phases:
+            try:
+                mole_sum = mole_sum + comp['pore.mole_fraction']
+            except:
+                pass
+        return mole_sum
+
+    def check_physics_health(self):
+        r'''
+        Perform a check to find pores which have overlapping or undefined Physics
+        '''
+        phys = self.physics()
+        Ptemp = sp.zeros((self.Np,))
+        Ttemp = sp.zeros((self.Nt,))
+        for item in phys:
+                Pind = self['pore.'+item]
+                Tind = self['throat.'+item]
+                Ptemp[Pind] = Ptemp[Pind] + 1
+                Ttemp[Tind] = Ttemp[Tind] + 1
+        health = Tools.HealthDict()
+        health['overlapping_pores'] = sp.where(Ptemp>1)[0].tolist()
+        health['undefined_pores'] = sp.where(Ptemp==0)[0].tolist()
+        health['overlapping_throats'] = sp.where(Ttemp>1)[0].tolist()
+        health['undefined_throats'] = sp.where(Ttemp==0)[0].tolist()
+        return health
+
+

OpenPNM-1.1/OpenPNM/Phases/__Mercury__.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+from OpenPNM.Phases import GenericPhase
+from OpenPNM.Phases import models as fm
+
+class Mercury(GenericPhase):
+    r"""
+    Creates Phase object with a default name 'Hg' and preset values for
+    mercury.
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The network to which this phase object will be attached.
+
+    Notes
+    -----
+    This explicit association is necessary so the Phase object can initialize
+    data arrays of the correct size to store network data.
+    The initial properties are all at std conditions of T = 298 K and P = 1 atm.
+
+    References
+    ----------
+    [1] Thermophysical Properties of Materials for Nuclear Engineering: IAEA, Vienna, 2008. ISBN 978-92-0-106508-7:
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.TestNet()
+    >>> hg = OpenPNM.Phases.Mercury(network=pn)
+
+    """
+    def __init__(self,name=None,**kwargs):
+        super(Mercury,self).__init__(name=name,**kwargs)
+        self._generate()
+
+    def _generate(self):
+        self['pore.molecular_weight'] = 0.2006                         # kg/mol
+        self['pore.critical_pressure'] = 1.662E8                       # Pa
+        self['pore.critical_temperature'] = 1733                       # K
+        self['pore.critical_volume'] = 0.000189                        # kg/m3
+        self['pore.contact_angle'] = 140                               # Degree
+        self.models.add(propname='pore.vapor_pressure',                 # Pa
+                       model=fm.vapor_pressure.antoine,
+                       A=9.85767,
+                       B=3007.129,
+                       C=-10.001)
+        self.models.add(propname='pore.density',                        # kg/m3
+                       model=fm.misc.linear,
+                       poreprop='pore.temperature',
+                       b=14280.9,
+                       m=-2.47004)
+        self.models.add(propname='pore.molar_density',
+                       model=fm.molar_density.standard)                # mol/m3
+        self.models.add(propname='pore.surface_tension',                # N/m
+                       model=fm.misc.linear,
+                       poreprop='pore.temperature',
+                       b=0.56254,
+                       m=-0.00028)
+        self.models.add(propname='pore.thermal_conductivity',           # W/m.K
+                       model=fm.misc.polynomial,
+                       poreprop='pore.temperature',
+                       a = [3.98691,0.0170967, -0.0000063862])
+        self.models.add(propname='pore.viscosity',                      # kg/m.s
+                       model=fm.misc.polynomial,
+                       poreprop='pore.temperature',
+                       a = [0.00355837,-0.0000100131,1.23684E-08,-5.16836E-12])
+
+if __name__ =="__main__":
+    import OpenPNM
+    pn = OpenPNM.Network.TestNet()
+    air = OpenPNM.Phases.Air(network=pn)

OpenPNM-1.1/OpenPNM/Phases/__TestPhase__.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+from OpenPNM.Phases import GenericPhase
+
+class TestPhase(GenericPhase):
+    r'''
+    Creates Phase object with a default name 'testphase' and preset values for an air-like
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The network to which this phase object will be attached.
+
+    Notes
+    -----
+    This explicit association is necessary so the Phase object can initialize
+    data arrays of the correct size to store network data.
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.TestNet()
+    >>> water = OpenPNM.Phases.Water(network=pn)
+    '''
+    def __init__(self,name=None,**kwargs):
+        super(TestPhase,self).__init__(name=name,**kwargs)
+        self._generate()
+
+    def _generate(self):
+        self['pore.temperature'] = 298.0
+        self['pore.surface_tension'] = 0.072
+        self['pore.pressure'] = 101325.0
+        self['pore.diffusivity'] = 5.4785e-06
+        self['pore.molar_density'] = 40.89
+        self['pore.viscosity'] = 1.8443e-05
+        self['pore.molecular_weight'] = 28.97
+        self['pore.critical_temperature'] = 132.5
+        self['pore.critical_volume'] = 0.0883
+        self['pore.contact_angle'] = 120
+        self['pore.thermal_conductivity'] = 1
+        self['throat.thermal_conductivity'] = self.interpolate_data(data=self['pore.thermal_conductivity'])
+
+
+if __name__ =="__main__":
+    import OpenPNM
+    pn = OpenPNM.Network.TestNet()
+    water = OpenPNM.Phases.Water(network=pn)

OpenPNM-1.1/OpenPNM/Phases/__Water__.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+from OpenPNM.Phases import GenericPhase
+from OpenPNM.Phases import models as fm
+
+class Water(GenericPhase):
+    r'''
+    Creates Phase object with preset values for Water
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The Network to which this phase object will be associated.
+
+    Notes
+    -----
+    This explicit association is necessary so the Phase object can initialize
+    data arrays of the correct size to store network data.
+    The initial properties are all at std conditions of T = 298 K and P = 1 atm.
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.TestNet()
+    >>> water = OpenPNM.Phases.Water(network=pn)
+    '''
+    def __init__(self,name=None,**kwargs):
+        super(Water,self).__init__(name=name,**kwargs)
+        self._generate()
+
+    def _generate(self):
+        self['pore.molecular_weight'] = 0.01802             # kg/mol
+        self['pore.critical_pressure'] = 2.2064E7           # Pa
+        self['pore.critical_temperature'] = 647.1           # K
+        self['pore.critical_volume'] = 0.003106             # kg/m3
+        self['pore.contact_angle'] = 110.0                  # Degree
+        self.models.add(propname='pore.density',
+                       model=fm.density.water)              # kg/m3
+        self.models.add(propname='pore.molar_density',
+                       model=fm.molar_density.standard)     # mol/m3
+        self['pore.diffusivity'] = 1e-9                     # m2/s
+        self.models.add(propname='pore.surface_tension',
+                       model=fm.surface_tension.water)      # N/m
+        self.models.add(propname='pore.thermal_conductivity',
+                       model=fm.thermal_conductivity.water) # W/m.K
+        self.models.add(propname='pore.vapor_pressure',      # Pa
+                       model=fm.vapor_pressure.antoine,
+                       A=10.1965,
+                       B=1730.63,
+                       C=-39.720)
+        self.models.add(propname='pore.viscosity',
+                       model=fm.viscosity.water)   # kg/m.s
+
+if __name__ =="__main__":
+    import OpenPNM
+    pn = OpenPNM.Network.TestNet()
+    water = OpenPNM.Phases.Water(network=pn)

OpenPNM-1.1/OpenPNM/Phases/__init__.py

@@ -0,0 +1,38 @@
+r"""
+###############################################################################
+:mod:`OpenPNM.Phases` -- Phase Property Estimation Methods
+###############################################################################
+
+Contents
+--------
+GenericPhase: The basic class which defines how a Phase is instantiated.  It
+also has a few specific method for querying the health of mixtures or physics
+objects.
+
+Subclasses: OpenPNM includes a few pre-written subclasses that describe the 
+most commonly used materials, like Air, Water and Mercury.  Creating a custom
+Phase subclass simply requires placing a file in the Phases directory and it 
+will be automatically loaded.  
+
+Classes
+-------
+
+.. autoclass:: GenericPhase
+   :members:
+
+.. autoclass:: Air
+   :members:
+
+.. autoclass:: Water
+   :members:
+   
+.. autoclass:: Mercury
+   :members:
+
+"""
+from .__GenericPhase__ import GenericPhase
+from .__Air__ import Air
+from .__Water__ import Water
+from .__Mercury__ import Mercury
+from .__TestPhase__ import TestPhase
+from . import models

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

@@ -0,0 +1,22 @@
+r"""
+*******************************************************************************
+models -- Functions for calculating thermofluid properties
+*******************************************************************************
+
+Contents
+--------
+This module contains methods for estimating phase properties
+
+"""
+
+from . import contact_angle
+from . import density
+from . import diffusivity
+from . import electrical_conductivity
+from . import misc
+from . import molar_density
+from . import molar_mass
+from . import surface_tension
+from . import thermal_conductivity
+from . import vapor_pressure
+from . import viscosity

OpenPNM-1.1/OpenPNM/Phases/models/contact_angle.py

@@ -0,0 +1,34 @@
+r"""
+===============================================================================
+Submodule -- contact_angle
+===============================================================================
+
+"""
+import scipy as sp
+
+def young(phase,
+          sigma_sg,
+          sigma_sl,
+          surface_tension='pore.surface_tension',
+          **kwargs):
+    r'''
+    Calculate contact angle using Young's equation
+    
+    Notes
+    -----
+    Young's equation is: sigma_lg*Cos(theta)=sigma_sg - sigma_sl
+    where
+    sigma_lg is the liquid-gas surface tension [N/m]
+    sigma_sg is the solid-gas surface tension [N/m]
+    sigma_sl is the solid-liquid interfacial tension [J/m^2]
+    theta is the Young contact angle [rad]
+           
+    '''
+    if surface_tension.split('.')[0] == 'pore':
+        sigma = phase[surface_tension]
+        sigma = phase.interpolate_data(data=sigma)
+    else:
+        sigma = phase[surface_tension]
+    theta = sp.arccos((sigma_sg - sigma_sl)/phase[surface_tension])
+    theta = sp.rad2deg(theta)
+    return theta

OpenPNM-1.1/OpenPNM/Phases/models/density.py

@@ -0,0 +1,81 @@
+r"""
+===============================================================================
+Submodule -- density
+===============================================================================
+
+"""
+import scipy as _sp
+
+def standard(phase,**kwargs):
+    r'''
+    Calculates the mass density from the molecular weight and molar density
+    '''
+    MW = phase['pore.molecular_weight']
+    rho = phase['pore.molar_density']
+    value = rho*MW
+    return value
+
+def ideal_gas(phase,**kwargs):
+    r"""
+    Uses ideal gas law to calculate the mass density of an ideal gas
+ 
+    Parameters
+    ----------
+    P, T, MW: float, array_like
+        P pressure of the gas in [Pa]
+        T temperature of the gas in [K]
+        MW molecular weight of the gas in [kg/kmole]
+            
+    Returns
+    -------
+    rho, the density in [mol/m3]
+    
+    """
+   
+    P = phase['pore.pressure']
+    T = phase['pore.temperature']
+    MW = phase['pore.molecular_weight']
+    R = 8.31447
+    value = P/(R*T)*MW
+    return value
+
+def water(phase,**kwargs):
+    r"""
+    Calculates density of pure water or seawater at atmospheric pressure
+    using Eq. (8) given by Sharqawy et. al [1]_. Values at temperature higher 
+    than the normal boiling temperature are calculated at the saturation pressure.
+
+    Parameters
+    ----------
+    T, S: strings
+        Property names where phase temperature and salinity are located.
+    
+    Returns
+    -------
+    rho_sw, the density of water/seawater in [kg/m3]
+    
+    Notes
+    -----
+     T must be in K, and S in g of salt per kg of phase, or ppt (parts per
+        thousand)
+    VALIDITY: 273 < T < 453 K; 0 < S < 160 g/kg;
+    ACCURACY: 0.1 %
+    
+    References
+    ----------
+    [1] Sharqawy M. H., Lienhard J. H., and Zubair, S. M., Desalination and Water Treatment, 2010.
+
+    """
+    T = phase['pore.temperature']
+    try:
+        S = phase['pore.salinity']
+    except:
+        S = 0
+    a1=9.9992293295E+02; a2=2.0341179217E-02; a3=-6.1624591598E-03; a4=2.2614664708E-05; a5=-4.6570659168E-08
+    b1=8.0200240891E-01; b2=-2.0005183488E-03; b3=1.6771024982E-05; b4=-3.0600536746E-08; b5=-1.6132224742E-11
+    TC = T-273.15
+    rho_w = a1 + a2*TC + a3*TC**2 + a4*TC**3 + a5*TC**4;
+    D_rho = b1*S + b2*S*TC + b3*S*(TC**2) + b4*S*(TC**3) + b5*(S**2)*(TC**2);
+    rho_sw = rho_w + D_rho
+    value = rho_sw
+    return value

OpenPNM-1.1/OpenPNM/Phases/models/diffusivity.py

@@ -0,0 +1,95 @@
+r"""
+===============================================================================
+Submodule -- diffusivity
+===============================================================================
+
+"""
+import scipy as sp
+
+def fuller(phase,MA,MB,vA,vB,**kwargs): 
+    r"""
+    Uses Fuller model to estimate diffusion coefficient for gases from first 
+    principles at conditions of interest
+
+    Parameters
+    ----------
+    MA : float, array_like
+        Molecular weight of component A [kg/mol]
+    MB : float, array_like
+        Molecular weight of component B [kg/mol]
+    vA:  float, array_like
+        Sum of atomic diffusion volumes for component A
+    vB:  float, array_like
+        Sum of atomic diffusion volumes for component B
+    """
+
+    T = phase['pore.temperature']
+    P = phase['pore.pressure']
+    MAB = 2*(1.0/MA+1.0/MB)**(-1)
+    MAB = MAB*1e3
+    P = P*1e-5
+    value = 0.00143*T**1.75/(P*(MAB**0.5)*(vA**(1./3)+vB**(1./3))**2)*1e-4
+    return value
+
+def fuller_scaling(phase,DABo,To,Po,**kwargs):
+    r"""
+    Uses Fuller model to adjust a diffusion coefficient for gases from reference conditions to conditions of interest
+
+    Parameters
+    ----------
+    phase : OpenPNM Phase Object
+
+    DABo : float, array_like
+        Diffusion coefficient at reference conditions
+
+    Po, To : float, array_like
+        Pressure & temperature at reference conditions, respectively
+    """
+    Ti = phase['pore.temperature']
+    Pi = phase['pore.pressure']
+    value = DABo*(Ti/To)**1.75*(Po/Pi)
+    return value
+
+def tyn_calus(phase,VA,VB,sigma_A,sigma_B,**kwargs):
+    r"""
+    Uses Tyn_Calus model to estimate diffusion coefficient in a dilute liquid solution of A in B from first principles at conditions of interest
+
+    Parameters
+    ----------
+    T :  float, array_like
+        Temperature of interest (K)
+    viscosity :  float, array_like
+        Viscosity of solvent (Pa.s)
+    VA : float, array_like
+        Molar volume of component A at boiling temperature (m3/mol)
+    VB : float, array_like
+        Molar volume of component B at boiling temperature (m3/mol)
+    sigmaA:  float, array_like
+        Surface tension of component A at boiling temperature (N/m)
+    sigmaB:  float, array_like
+        Surface tension of component B at boiling temperature (N/m)
+
+    """
+    T = phase['pore.temperature']
+    mu = phase['pore.viscosity']
+    value = 8.93e-8*(VB*1e6)**0.267/(VA*1e6)**0.433*T*(sigma_B/sigma_A)**0.15/(mu*1e3)
+    return value
+
+def tyn_calus_Scaling(phase,DABo,To,mu_o,**kwargs):
+    r"""
+    Uses Tyn_Calus model to adjust a diffusion coeffciient for liquids from reference conditions to conditions of interest
+
+    Parameters
+    ----------
+    phase : OpenPNM Phase Object
+
+    DABo : float, array_like
+        Diffusion coefficient at reference conditions
+
+    mu_o, To : float, array_like
+        Viscosity & temperature at reference conditions, respectively
+    """
+    Ti = phase['pore.temperature']
+    mu_i = phase['pore.viscosity']
+    value = DABo*(Ti/To)*(mu_o/mu_i)
+    return value

OpenPNM-1.1/OpenPNM/Phases/models/electrical_conductivity.py

@@ -0,0 +1,10 @@
+r"""
+===============================================================================
+Submodule -- electrical_conductance
+===============================================================================
+
+"""
+import scipy as sp
+
+def na(**kwargs):
+    print('Not Implemented Yet')