openpnm 1.0.0__zip

OpenPNM-1.1/OpenPNM/Physics/__GenericPhysics__.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+module __Physics__: Base class for mananging pore-scale Physics properties
+===============================================================================
+
+"""
+from OpenPNM.Base import logging
+logger = logging.getLogger(__name__)
+from OpenPNM.Network import GenericNetwork
+from OpenPNM.Phases import GenericPhase
+import OpenPNM.Physics.models
+import scipy as sp
+
+class GenericPhysics(OpenPNM.Base.Core):
+    r"""
+    Generic class to generate Physics objects
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The network to which this Physics should be attached
+
+    phase : OpenPNM Phase object
+        The Phase object to which this Physics applies
+        
+    geometry : OpenPNM Geometry object
+        The Geometry object that defines the pores/throats where this Physics
+        should be applied.  If this argument is supplied, then pores and 
+        throats cannot be specified.
+
+    pores and/or throats : array_like
+        The list of pores and throats where this physics applies. If either are
+        left blank this will apply the physics nowhere.  The locations can be
+        change after instantiation using ``set_locations()``.  If pores and
+        throats are supplied, than a geometry cannot be specified.
+
+    name : str, optional
+        A unique string name to identify the Physics object, typically same as
+        instance name but can be anything.  If left blank, and name will be
+        generated that include the class name and a random string.
+        
+    
+
+    """
+
+    def __init__(self,network=None,phase=None,geometry=None,pores=[],throats=[],**kwargs):
+        super(GenericPhysics,self).__init__(**kwargs)
+        logger.name = self.name
+
+        #Associate with Network
+        if network is None:
+            self._net = GenericNetwork()
+        else:
+            self._net = network  # Attach network to self
+            self._net._physics.append(self)  # Register self with network
+
+        #Associate with Phase
+        if phase is None:
+            self._phases.append(GenericPhase())
+        else:
+            phase._physics.append(self)  # Register self with phase
+            self._phases.append(phase)  # Register phase with self
+            
+        if geometry is not None:
+            if (pores != []) or (throats != []):
+                raise Exception('Cannot specify a Geometry AND pores or throats')
+            pores = self._net.toindices(self._net['pore.'+geometry.name])
+            throats = self._net.toindices(self._net['throat.'+geometry.name])
+
+        #Initialize a label dictionary in the associated fluid
+        self._phases[0]['pore.'+self.name] = False
+        self._phases[0]['throat.'+self.name] = False
+        self._net['pore.'+self.name] = False
+        self._net['throat.'+self.name] = False
+        self.set_locations(pores=pores,throats=throats)
+
+    def __getitem__(self,key):
+        element = key.split('.')[0]
+        # Convert self.name into 'all'
+        if key.split('.')[-1] == self.name:
+            key = element + '.all'
+
+        if key in self.keys():  # Look for data on self...
+            return super(GenericPhysics,self).__getitem__(key)
+        else:  # ...Then check Network
+            return self._phases[0][key][self._phases[0][element+'.'+self.name]]
+
+    def set_locations(self,pores=[],throats=[],mode='add'):
+        r'''
+        Set the pore and throat locations of the Physics object
+
+        Parameters
+        ----------
+        pores and throats : array_like
+            The list of pores and/or throats where the object should be applied.
+        mode : string
+            Indicates whether list of pores or throats is to be added or removed
+            from the object.  Options are 'add' (default) or 'remove'.
+        '''
+        if len(pores) > 0:
+            pores = sp.array(pores,ndmin=1)
+            self._set_locations(element='pore',locations=pores,mode=mode)
+        if len(throats) > 0:
+            throats = sp.array(throats,ndmin=1)
+            self._set_locations(element='throat',locations=throats,mode=mode)
+            
+if __name__ == '__main__':
+    print('none yet')
+
+

OpenPNM-1.1/OpenPNM/Physics/__Standard__.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+module Physics
+===============================================================================
+
+"""
+
+from OpenPNM.Physics import models as pm
+from OpenPNM.Physics.__GenericPhysics__ import GenericPhysics
+
+class Standard(GenericPhysics):
+    r"""
+    Base class to generate a generic Physics object.  The user must specify models
+    and parameters for the all the properties they require. Classes for several
+    common Physics are included with OpenPNM and can be found under OpenPNM.Physics.
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The network to which this Physics should be attached
+
+    phase : OpenPNM Phase object
+        The Phase object to which this Physics applies
+
+    pores and throats : array_like
+        The pores and throats where this Physics object applies
+
+    """
+
+    def __init__(self,**kwargs):
+        super(Standard,self).__init__(**kwargs)
+        self._generate()
+
+    def _generate(self):
+        for phase in self._phases:
+            temp = [item.split('.')[1] for item in phase.props()]
+            if 'viscosity' in temp:
+                self.models.add(propname='throat.hydraulic_conductance',
+                               model=pm.hydraulic_conductance.hagen_poiseuille)
+            if 'diffusivity' in temp:
+                self.models.add(propname='throat.diffusive_conductance',
+                               model=pm.diffusive_conductance.bulk_diffusion)
+            if 'surface_tension' in temp:
+                self.models.add(propname='throat.capillary_pressure',
+                               model=pm.capillary_pressure.washburn)
+
+if __name__ == '__main__':
+    print('none yet')
+
+

OpenPNM-1.1/OpenPNM/Physics/__TestPhysics__.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+module Physics
+===============================================================================
+
+"""
+
+from OpenPNM.Physics import models as pm
+from OpenPNM.Physics import GenericPhysics
+
+class TestPhysics(GenericPhysics):
+    r"""
+    Base class to generate a generic Physics object.  The user must specify models
+    and parameters for the all the properties they require. Classes for several
+    common Physics are included with OpenPNM and can be found under OpenPNM.Physics.
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The network to which this Physics should be attached
+
+    phase : OpenPNM Phase object
+        The Phase object to which this Physics applies
+
+    pores and throats : array_like
+        The pores and throats where this Physics object applies
+
+    """
+
+    def __init__(self,**kwargs):
+        super(TestPhysics,self).__init__(**kwargs)
+        self._generate()
+
+    def _generate(self):
+        for phase in self._phases:
+            temp = [item.split('.')[1] for item in phase.props()]
+            if 'viscosity' in temp:
+                self['throat.hydraulic_conductance'] = 1
+            if 'diffusivity' in temp:
+                self['throat.diffusive_conductance'] = 1
+            if 'surface_tension' in temp:
+                self['throat.capillary_pressure'] = 1/self._net['throat.diameter']
+            if 'thermal_conductivity' in temp:
+                self['throat.thermal_conductance'] = phase['throat.thermal_conductivity']*self._net['throat.diameter']/self._net['throat.length']
+
+if __name__ == '__main__':
+    print('none yet')
+
+

OpenPNM-1.1/OpenPNM/Physics/__init__.py

@@ -0,0 +1,30 @@
+r"""
+###############################################################################
+:mod:`OpenPNM.Physics` -- Pore Scale Physics Models
+###############################################################################
+
+Contents
+--------
+GenericPhysics: This base class is essentially an init statement that ensures
+the Physics object registers itself with Phase and Network objects correctly.
+
+Subclasses: OpenPNM includes one subclass called Standard which invokes the
+typical pore scale physics models such as the Hagen-Poiseiulle model for 
+hydraulic conductance through a tube.  Customized Physics classes can be 
+created by adding a file to the Physics directory, which will be imported
+automatically.  
+
+Classes
+-------
+.. autoclass:: GenericPhysics
+   :members:
+
+.. autoclass:: Standard
+   :members:
+
+"""
+
+from .__GenericPhysics__ import GenericPhysics
+from .__Standard__ import Standard
+from .__TestPhysics__ import TestPhysics
+from . import models

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

@@ -0,0 +1,18 @@
+r"""
+*******************************************************************************
+models -- Functions for calculating pore-scale Physics models
+*******************************************************************************
+
+Contents
+--------
+This submodule contains all pore scale physics models applied to a pore network.
+   
+"""
+
+from . import capillary_pressure
+from . import diffusive_conductance
+from . import electrical_conductance
+from . import thermal_conductance
+from . import hydraulic_conductance
+from . import multiphase
+from . import generic_source_term

OpenPNM-1.1/OpenPNM/Physics/models/capillary_pressure.py

@@ -0,0 +1,122 @@
+r"""
+===============================================================================
+Submodule -- capillary_pressure
+===============================================================================
+
+"""
+
+import scipy as _sp
+
+def washburn(physics,
+             phase,
+             network,
+             surface_tension='pore.surface_tension',
+             contact_angle='pore.contact_angle',
+             throat_diameter='throat.diameter',
+             **kwargs):
+    r"""
+    Computes the capillary entry pressure assuming the throat is a cylindrical tube.
+
+    Parameters
+    ----------
+    network : OpenPNM Network Object
+        The Network object is 
+    phase : OpenPNM Phase Object
+        Phase object for the invading phases containing the surface tension and
+        contact angle values.
+    sigma : dict key (string)
+        The dictionary key containing the surface tension values to be used. If
+        a pore property is given, it is interpolated to a throat list.
+    theta : dict key (string)
+        The dictionary key containing the contact angle values to be used. If
+        a pore property is given, it is interpolated to a throat list.
+    throat_diameter : dict key (string)
+        The dictionary key containing the throat diameter values to be used.
+
+    Notes
+    -----
+    The Washburn equation is:
+
+    .. math::
+        P_c = -\frac{2\sigma(cos(\theta))}{r}
+
+    This is the most basic approach to calculating entry pressure and is 
+    suitable for highly non-wetting invading phases in most materials.
+
+    """
+    if surface_tension.split('.')[0] == 'pore':
+        sigma = phase[surface_tension]
+        sigma = phase.interpolate_data(data=sigma)
+    else:
+        sigma = phase[surface_tension]
+    if contact_angle.split('.')[0] == 'pore':
+        theta = phase[contact_angle]
+        theta = phase.interpolate_data(data=theta)
+    else:
+        theta = phase[contact_angle]
+    r = network[throat_diameter]/2
+    value = -2*sigma*_sp.cos(_sp.radians(theta))/r
+    value = value[phase.throats(physics.name)]
+    return value
+
+def purcell(physics,
+            phase,
+            network,
+            r_toroid,
+            surface_tension='pore.surface_tension',
+            contact_angle='pore.contact_angle',
+            throat_diameter='throat.diameter',
+            **kwargs):
+    r"""
+    Computes the throat capillary entry pressure assuming the throat is a toroid.
+
+    Parameters
+    ----------
+    network : OpenPNM Network Object
+        The Network on which to apply the calculation
+    sigma : dict key (string)
+        The dictionary key containing the surface tension values to be used. If
+        a pore property is given, it is interpolated to a throat list.
+    theta : dict key (string)
+        The dictionary key containing the contact angle values to be used. If
+        a pore property is given, it is interpolated to a throat list.
+    throat_diameter : dict key (string)
+        The dictionary key containing the throat diameter values to be used.
+    r_toroid : float or array_like
+        The radius of the toroid surrounding the pore
+
+    Notes
+    -----
+    This approach accounts for the converging-diverging nature of many throat 
+    types.  Advancing the meniscus beyond the apex of the toroid requires an 
+    increase in capillary pressure beyond that for a cylindical tube of the 
+    same radius. The details of this equation are described by Mason and 
+    Morrow [1]_, and explored by Gostick [2]_ in the context of a pore network 
+    model.
+
+    References
+    ----------
+
+    .. [1] G. Mason, N. R. Morrow, Effect of contact angle on capillary displacement curvatures in pore throats formed by spheres. J. Colloid Interface Sci. 168, 130 (1994).
+    .. [2] J. Gostick, Random pore network modeling of fibrous PEMFC gas diffusion media using Voronoi and Delaunay tessellations. J. Electrochem. Soc. 160, F731 (2013).
+
+    TODO: Triple check the accuracy of this equation
+    """
+
+    if surface_tension.split('.')[0] == 'pore':
+        sigma = phase[surface_tension]
+        sigma = phase.interpolate_data(data=sigma)
+    else:
+        sigma = phase[surface_tension]
+    if contact_angle.split('.')[0] == 'pore':
+        theta = phase[contact_angle]
+        theta = phase.interpolate_data(data=theta)
+    else:
+        theta = phase[contact_angle]
+    r = network[throat_diameter]/2
+    R = r_toroid
+    alpha = theta - 180 + _sp.arcsin(_sp.sin(_sp.radians(theta)/(1+r/R)))
+    value = (-2*sigma/r)*(_sp.cos(_sp.radians(theta - alpha))/(1 + R/r*(1-_sp.cos(_sp.radians(alpha)))))
+    value = value[phase.throats(physics.name)]
+    return value
+

OpenPNM-1.1/OpenPNM/Physics/models/diffusive_conductance.py

@@ -0,0 +1,82 @@
+r"""
+===============================================================================
+Submodule -- diffusive_conductance
+===============================================================================
+
+"""
+
+import scipy as _sp
+import OpenPNM.Utilities.misc as misc
+
+def bulk_diffusion(physics,
+                   phase,
+                   network,
+                   pore_molar_density='pore.molar_density',
+                   pore_diffusivity='pore.diffusivity',
+                   pore_area='pore.area',
+                   pore_diameter='pore.diameter',
+                   throat_area='throat.area',
+                   throat_length='throat.length',
+                   throat_diameter='throat.diameter',
+                   calc_pore_len=True,
+                   **kwargs):
+    r"""
+    Calculate the diffusive conductance of conduits in network, where a 
+    conduit is ( 1/2 pore - full throat - 1/2 pore ) based on the areas
+
+    Parameters
+    ----------
+    network : OpenPNM Network Object
+
+    phase : OpenPNM Phase Object
+        The phase of interest
+
+    Notes
+    -----
+    (1) This function requires that all the necessary phase properties already 
+    be calculated.
+    
+    (2) This function calculates the specified property for the *entire* 
+    network then extracts the values for the appropriate throats at the end.
+    
+    """    
+    #Get Nt-by-2 list of pores connected to each throat
+    Ps = network['throat.conns']
+    #Get properties in every pore in the network
+    parea = network[pore_area]
+    pdia = network[pore_diameter]
+    #Get the properties of every throat
+    tarea = network[throat_area]
+    tlen = network[throat_length]
+    #Interpolate pore phase property values to throats
+    cp = phase[pore_molar_density]
+    ct = phase.interpolate_data(data=cp)
+    DABp = phase[pore_diffusivity]
+    DABt = phase.interpolate_data(data=DABp)
+    if calc_pore_len:
+        lengths = misc.conduit_lengths(network,mode='centroid')
+        plen1 = lengths[:,0]
+        plen2 = lengths[:,2]
+    else:        
+        plen1 = (0.5*pdia[Ps[:,0]])
+        plen2 = (0.5*pdia[Ps[:,1]])
+    #remove any non-positive lengths
+    plen1[plen1<=0]=1e-12
+    plen2[plen2<=0]=1e-12
+    #Find g for half of pore 1
+    gp1 = ct*DABt*parea[Ps[:,0]]/plen1
+    gp1[_sp.isnan(gp1)] = _sp.inf
+    gp1[~(gp1>0)] = _sp.inf  # Set 0 conductance pores (boundaries) to inf
+    #Find g for half of pore 2
+    gp2 = ct*DABt*parea[Ps[:,1]]/plen2
+    gp2[_sp.isnan(gp2)] = _sp.inf
+    gp2[~(gp2>0)] = _sp.inf  # Set 0 conductance pores (boundaries) to inf
+    #Find g for full throat
+    #remove any non-positive lengths
+    tlen[tlen<=0] = 1e-12
+    gt = ct*DABt*tarea/tlen
+    value = (1/gt + 1/gp1 + 1/gp2)**(-1)
+    value = value[phase.throats(physics.name)]
+    return value
+
+

OpenPNM-1.1/OpenPNM/Physics/models/electrical_conductance.py

@@ -0,0 +1,59 @@
+r"""
+===============================================================================
+Submodule -- electrical_conductance
+===============================================================================
+
+"""
+
+import scipy as _sp
+
+def series_resistors(physics,
+                     phase,
+                     network,
+                     pore_conductivity='pore.electrical_conductivity',
+                     pore_area='pore.area',
+                     pore_diameter='pore.diameter',
+                     throat_area='throat.area',
+                     throat_length='throat.length',
+                     **kwargs):
+    r"""
+    Calculates the electrical conductance of throat assuming cylindrical geometry
+
+    Parameters
+    ----------
+    network : OpenPNM Network Object
+
+    phase : OpenPNM Phase Object
+    
+    Notes
+    -----
+    (1) This function requires that all the necessary phase properties already 
+    be calculated.
+    
+    (2) This function calculates the specified property for the *entire* 
+    network then extracts the values for the appropriate throats at the end.
+    
+    """    
+    #Get Nt-by-2 list of pores connected to each throat
+    Ps = network['throat.conns']
+    #Get properties in every pore in the network
+    sigmap = phase[pore_conductivity]
+    sigmat = phase.interpolate_data(sigmap)
+    #Find g for half of pore 1
+    parea = network[pore_area]
+    pdia = network[pore_diameter]
+    #remove any non-positive lengths
+    pdia[pdia<=0] = 0
+    gp1 = sigmap[Ps[:,0]]*parea[Ps[:,0]]/(0.5*pdia[Ps[:,0]])
+    #Find g for half of pore 2
+    gp2 = sigmap[Ps[:,1]]*parea[Ps[:,1]]/(0.5*pdia[Ps[:,1]])
+    #Find g for full throat
+    tarea = network[throat_area]
+    tlen = network[throat_length]
+    #remove any non-positive lengths
+    tlen[tlen<=0] = 0
+    gt = sigmat*tarea/tlen
+    value = (1/gt + 1/gp1 + 1/gp2)**(-1)
+    value = value[phase.throats(physics.name)]
+    return value
+