openpnm 1.0.0__zip

OpenPNM-1.1/OpenPNM/Base/__ModelsDict__.py

@@ -0,0 +1,345 @@
+'''
+###############################################################################
+ModelsDict:  Abstract Class for Containing Models
+###############################################################################
+'''
+import inspect
+import scipy as sp
+from collections import OrderedDict
+from OpenPNM.Base import logging, Controller
+logger = logging.getLogger()
+
+class ModelWrapper(dict):
+    r"""
+    Accepts a model from the OpenPNM model library, as well as all required 
+    and optional argumnents, then wraps it in a custom dictionary with 
+    various methods for working with the models.
+
+    """
+    def __init__(self,**kwargs):
+        self.update(**kwargs)
+
+    def __call__(self):
+        return self['model'](**self)
+        
+    def __str__(self):
+        header = '-'*60
+        print(header)
+        print(self['model'].__module__+'.'+self['model'].__name__)
+        print(header)
+        print("{a:<20s} {b}".format(a='Argument Name',b='Value / (Default)'))
+        print(header)
+        # Scan default argument names and values of model
+        defs = {}
+        if self['model'].__defaults__ != None:
+            vals = list(inspect.getargspec(self['model']).defaults)
+            keys = inspect.getargspec(self['model']).args[-len(vals):]
+            # Put defaults into the dict
+            defs.update(zip(keys,vals))
+        keys = list(self.keys())
+        keys.sort()
+        for item in keys:
+            if item not in ['model','network','geometry','phase','physics','propname']:
+                if item not in defs.keys():
+                    defs[item] = '---'
+                print("{a:<20s} {b} / ({c})".format(a=item, b=self[item], c=defs[item]))
+        print(header)
+        return ' '
+        
+    def regenerate(self):
+        r'''
+        Regenerate the model
+        '''
+        master = self._find_master()
+        #Determine object type, and assign associated objects
+        self_type = [item.__name__ for item in master.__class__.__mro__]
+        kwargs = {}
+        if 'GenericGeometry' in self_type:
+            kwargs['network'] = master._net
+            kwargs['geometry'] = master
+        elif 'GenericPhase' in self_type:
+            kwargs['network'] = master._net
+            kwargs['phase'] = master
+        elif 'GenericPhysics' in self_type:
+            kwargs['network'] = master._net
+            kwargs['phase'] = master._phases[0]
+            kwargs['physics'] = master
+        else:
+            kwargs['network'] = master
+        kwargs.update(self)
+        return self['model'](**kwargs)
+        
+    def _find_master(self):
+        ctrl = Controller()
+        master = []
+        for item in ctrl.keys():
+            if ctrl[item].models is not None:
+                for model in ctrl[item].models.keys():
+                    if ctrl[item].models[model] is self:
+                        master.append(ctrl[item])
+        if len(master) > 1:
+            raise Exception('More than one master found! This model dictionary has been associated with multiple objects. To use the same dictionary multiple times use the copy method.')
+        return master[0]
+
+class ModelsDict(OrderedDict):
+    r"""
+    This custom dictionary stores the models that are associated with each 
+    OpenPNM object.  This is an ordered dict with a few additional methods.
+    This ModelsDict class can be created as a standalone object, then 
+    associated with an OpenPNM object, and ModelsDicts from one object can 
+    be copied and attached to another.  
+    
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.TestNet()
+    >>> Ps = pn.pores(labels='top',mode='not')
+    >>> geom = OpenPNM.Geometry.TestGeometry(network=pn,pores=Ps,throats=pn.Ts)
+    >>> print(geom.models)  # Show models included on TestGeometry
+    ------------------------------------------------------------
+    #     Property Name                  Regeneration Mode   
+    ------------------------------------------------------------
+    0     pore.seed                      normal              
+    1     throat.length                  normal              
+    2     throat.seed                    normal              
+    ------------------------------------------------------------
+    
+    It is possible to use the ModelsDict from one object with another object:
+    
+    >>> Ps = pn.pores('top')
+    >>> boun = OpenPNM.Geometry.GenericGeometry(network=pn,pores=Ps)
+    >>> boun.models  # The boun object has no models in its Models dict
+    ModelsDict()
+    >>> mod = geom.models.copy()  # Create a copy of geom's models
+    >>> boun.models = mod  # Use the same set of models on boun as geom
+    >>> print(boun.models)
+    ------------------------------------------------------------
+    #     Property Name                  Regeneration Mode   
+    ------------------------------------------------------------
+    0     pore.seed                      normal              
+    1     throat.length                  normal              
+    2     throat.seed                    normal              
+    ------------------------------------------------------------
+    
+
+    """
+    
+    def __setitem__(self,propname,model):
+        temp = ModelWrapper(propname=propname,model=None)
+        temp.update(**model)
+        super(ModelsDict,self).__setitem__(propname,temp)
+        
+    def __str__(self):
+        header = '-'*60
+        print(header)
+        print("{n:<5s} {a:<30s} {b:<20s}".format(n='#', a='Property Name', b='Regeneration Mode'))
+        print(header)
+        count = 0
+        for item in self.keys():
+            print("{n:<5d} {a:<30s} {b:<20s}".format(n=count, a=item, b=self[item]['regen_mode']))
+            count += 1
+        print(header)
+        return ' '
+        
+    def keys(self):
+        return list(super(ModelsDict,self).keys())
+            
+    def regenerate(self, props='', mode='inclusive'):
+        r'''
+        This updates properties using any models on the object that were
+        assigned using ``add_model``
+
+        Parameters
+        ----------
+        props : string or list of strings
+            The names of the properties that should be updated, defaults to 'all'
+        mode : string
+            This controls which props are regenerated and how.  Options are:
+
+            * 'inclusive': (default) This regenerates all given properties
+            * 'exclude': This generates all given properties EXCEPT the given ones
+
+        Examples
+        --------
+        >>> import OpenPNM
+        >>> pn = OpenPNM.Network.TestNet()
+        >>> geom = OpenPNM.Geometry.GenericGeometry(network=pn,pores=pn.pores(),throats=pn.throats())
+        >>> geom['pore.diameter'] = 1
+        >>> import OpenPNM.Geometry.models as gm  # Import Geometry model library
+        >>> f = gm.pore_area.cubic
+        >>> geom.add_model(propname='pore.area',model=f)  # Add model to Geometry object
+        >>> geom['pore.area'][0]  # Look at area value in pore 0
+        1
+        >>> geom['pore.diameter'] = 2
+        >>> geom.models.regenerate()  # Regenerate all models
+        >>> geom['pore.area'][0]  # Look at pore area calculated with new diameter
+        4
+
+        '''
+        master = self._find_master()
+        if props == '':  # If empty, assume all models are to be regenerated
+            props = list(self.keys())
+            for item in props:  # Remove models if they are meant to be regenerated 'on_demand' only
+                if self[item]['regen_mode'] == 'on_demand':
+                    props.remove(item)
+        elif type(props) == str:
+            props = [props]
+        if mode == 'exclude':
+            temp = list(self.keys())
+            for item in props:
+                temp.remove(item)
+            props = temp
+        for item in self.keys():
+            if self[item]['regen_mode'] == 'constant':
+                props.remove(item)
+        logger.info('Models are being recalculated in the following order: ')
+        count = 0
+        for item in props:
+            if item in list(self.keys()):
+                master[item] = self[item].regenerate()
+                logger.info(str(count)+' : '+item)
+                count += 1
+            else:
+                logger.warning('Requested proptery is not a dynamic model: '+item)
+            
+    def add(self,propname,model,regen_mode='normal',**kwargs):
+        r'''
+        Add specified property estimation model to the object.
+
+        Parameters
+        ----------
+        propname : string
+            The name of the property to use as dictionary key, such as
+            'pore.diameter' or 'throat.length'
+
+        model : function
+            The property estimation function to use
+
+        regen_mode : string
+            Controls when and if the property is regenerated. Options are:
+
+            * 'normal' : The property is stored as static data and is only regenerated when the object's ``regenerate`` is called
+
+            * 'constant' : The property is calculated once when this method is first run, but always maintains the same value
+
+            * 'deferred' : The model is stored on the object but not run until ``regenerate`` is called
+
+            * 'on_demand' : The model is stored on the object but not run, AND will only run if specifically requested in ``regenerate``
+
+        Notes
+        -----
+        This method is inherited by all net/geom/phys/phase objects.  It takes
+        the received model and stores it on the object under private dictionary
+        called _models.  This dict is an 'OrderedDict', so that the models can
+        be run in the same order they are added.
+
+        Examples
+        --------
+        >>> import OpenPNM
+        >>> pn = OpenPNM.Network.TestNet()
+        >>> geom = OpenPNM.Geometry.GenericGeometry(network=pn)
+        >>> import OpenPNM.Geometry.models as gm
+        >>> f = gm.pore_misc.random  # Get model from Geometry library
+        >>> geom.add_model(propname='pore.seed',model=f)
+        >>> geom.models.keys()  # Look in dict to verify model was added
+        ['pore.seed']
+        >>> print(geom.models['pore.seed'])  # Look at arguments for model
+        ------------------------------------------------------------
+        OpenPNM.Geometry.models.pore_misc.random
+        ------------------------------------------------------------
+        Argument Name        Value / (Default)
+        ------------------------------------------------------------
+        num_range            [0, 1] / ([0, 1])
+        regen_mode           normal / (---)
+        seed                 None / (None)
+        ------------------------------------------------------------
+
+        '''
+        master = self._find_master()
+        if master == None:
+            logger.warning('ModelsDict has no master, changing regen_mode to deferred')
+            regen_mode = 'deferred'
+        #Build dictionary containing default model values, plus other required info
+        f = {'model':model,'regen_mode':regen_mode}
+        # Scan default argument names and values of model
+        if model.__defaults__ != None:
+            vals = list(inspect.getargspec(model).defaults)
+            keys = inspect.getargspec(model).args[-len(vals):]
+            # Put defaults into the dict
+            f.update(zip(keys,vals))
+        # Update dictionary with supplied arguments, overwriting defaults
+        f.update(**kwargs)
+        # Add model to ModelsDict
+        self[propname] = f
+        # Now generate data as necessary
+        if regen_mode in ['normal','constant']:
+            master[propname] = self[propname].regenerate()
+        if regen_mode in ['deferred','on_demand']:
+            pass
+        
+    def remove(self,propname):
+        r'''
+        Removes selected model from the dictionary, as well as removing its
+        associated data from the master Core object.
+        
+        Parameters
+        ----------
+        propname : string
+            The name of the model to remove
+        '''
+        master = self._find_master()
+        temp = master.pop(propname,None)
+        del self[propname]
+
+    def reorder(self,new_order):
+        r'''
+        Reorders the models on the object to change the order in which they
+        are regenerated, where item 0 is calculated first.
+
+        Parameters
+        ----------
+        new_order : dict
+            A dictionary containing the model name(s) as the key, and the
+            location(s) in the new order as the value
+
+        Examples
+        --------
+        >>> import OpenPNM
+        >>> pn = OpenPNM.Network.TestNet()
+        >>> geom = OpenPNM.Geometry.TestGeometry(network=pn,pores=pn.Ps,throats=pn.Ts)
+        >>> geom.models.keys()
+        ['pore.seed', 'throat.seed', 'throat.length']
+        >>> geom.models.reorder({'pore.seed':1,'throat.length':0})
+        >>> geom.models.keys()
+        ['throat.length', 'pore.seed', 'throat.seed']
+
+        '''
+        #Generate numbered list of current models
+        order = [item for item in list(self.keys())]
+        #Remove supplied models from list
+        for item in new_order:
+            order.remove(item)
+        #Add models back to list in new order
+        inv_dict = {v: k for k, v in new_order.items()}
+        for item in inv_dict:
+            order.insert(item,inv_dict[item])
+        #Now rebuild models OrderedDict in new order
+        for item in order:
+            self.move_to_end(item)
+        
+    def _find_master(self):
+        ctrl = Controller()
+        master = []
+        for item in ctrl.keys():
+            if ctrl[item].models is self:
+                master.append(ctrl[item])
+        if len(master) > 1:
+            raise Exception('More than one master found! This model dictionary has been associated with multiple objects. To use the same dictionary multiple times use the copy method.')
+        return master[0]
+
+if __name__ == '__main__':
+    pn = OpenPNM.Network.TestNet()
+    a = ModelsDict()
+
+
+

OpenPNM-1.1/OpenPNM/Base/__Tools__.py

@@ -0,0 +1,72 @@
+'''
+###############################################################################
+Tools:  Useful classes for use throughout the project
+###############################################################################
+'''
+import scipy as _sp
+from collections import OrderedDict as _odict
+
+class PrintableList(list):
+    def __str__(self):
+        count = 0
+        header = '-'*60
+        print('\n')
+        print(header)
+        self.sort()
+        for item in self:
+            count = count + 1
+            print(count,'\t: ',item)
+        return header
+
+class PrintableDict(_odict):
+    def __repr__(self):
+        text = dict(self).__str__()
+        return text
+
+    def __str__(self):
+        header = '-'*60
+        print(header)
+        print("{a:<25s} {b:<25s}".format(a='key', b='value'))
+        print(header)
+        for item in self.keys():
+            print("{a:<25s} {b}".format(a=item, b=self[item]))
+        print(header)
+        return ''
+        
+class AttributVeiew(object):
+    def __init__(self, d):
+        temp = {}
+        for item in d:
+            if type(d[item][0]) == _sp.bool_:
+                key = 'label_'+item.replace('.','_')
+            else:
+                key = 'prop_'+item.replace('.','_')
+            temp[key] =d[item]
+        self.__dict__ = temp
+
+class ClonedCore(dict):
+    def __init__(self,obj):
+        self.update(obj)
+        self.name = obj.name
+
+class HealthDict(PrintableDict):
+    r'''
+    This class adds a 'health' check to a standard dictionary.  This check 
+    looks into the dict values, and considers empty lists as healthy and all 
+    else as unhealthy.  If one or more entries is 'unhealthy' the health method
+    returns False.
+    '''            
+    def _get_health(self):
+        health = True
+        for item in self.keys():
+            if self[item] != []:
+                health = False
+        return health
+    
+    health = property(fget=_get_health)
+        
+        
+        
+        
+        
+        

OpenPNM-1.1/OpenPNM/Base/__init__.py

@@ -0,0 +1,32 @@
+r"""
+###############################################################################
+:mod:`OpenPNM.Base` -- Abstract Base Class, and Core Data Class
+###############################################################################
+
+.. autoclass:: OpenPNM.Base.Controller
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. autoclass:: OpenPNM.Base.Core
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   
+.. autoclass:: OpenPNM.Base.Tools
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+"""
+
+import logging as logging
+# set up logging to file - see previous section for more details
+logging.basicConfig(level=logging.WARNING,
+                    format='%(asctime)s | %(levelname)-8s | %(name)s.%(funcName)s | %(message)s',
+                    )
+
+from .__Controller__ import Controller
+from .__ModelsDict__ import ModelsDict
+from . import __Tools__ as Tools
+from .__Core__ import Core

OpenPNM-1.1/OpenPNM/Geometry/__Boundary__.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+Boundary -- Subclass of GenericGeometry for Boundary Pores
+===============================================================================
+
+"""
+
+from OpenPNM.Geometry import models as gm
+from OpenPNM.Geometry import GenericGeometry
+
+class Boundary(GenericGeometry):
+    r"""
+    Boundary subclass of GenericGeometry.
+
+    Parameters
+    ----------
+    network : OpenPNM Network object
+        The Network to which the Geometry object should be associated
+    pores, throats : array_like
+        The pores and/or throats where the Geometry should be applied
+    shape: str
+        Stick and Ball or Cube and Cuboid? ('spheres','cubes')
+
+    Examples
+    --------
+    >>> import OpenPNM
+    >>> pn = OpenPNM.Network.TestNet()
+    >>> Ps_int = pn.pores(labels=['top','bottom'],mode='not')
+    >>> Ps_boun = pn.pores(labels=['top','bottom'],mode='union')
+    >>> Ts_int = pn.throats(labels=['top','bottom'],mode='not')
+    >>> Ts_boun = pn.throats(labels=['top','bottom'],mode='union')
+    >>> geo = OpenPNM.Geometry.Cube_and_Cuboid(network=pn,pores=Ps_int,throats=Ts_int)
+    >>> boun = OpenPNM.Geometry.Boundary(network=pn,pores=Ps_boun,throats=Ts_boun)
+
+    """
+
+    def __init__(self,shape='spheres',**kwargs):
+        r"""
+        Initialize
+        """
+        super(Boundary,self).__init__(**kwargs)
+        self._generate(shape)
+
+    def _generate(self,shape):
+        r'''
+        '''
+        try:
+            self['pore.seed']
+            seeds = True
+        except:
+            seeds = False
+
+        if seeds: self.models.add(propname='pore.seed',model=gm.pore_misc.constant,value=0.9999)
+        self.models.add(propname='pore.diameter',model=gm.pore_misc.constant,value=0)
+        if seeds: self.models.add(propname='throat.seed',
+                                  model=gm.throat_misc.neighbor,
+                                  pore_prop='pore.seed',
+                                  mode='max')
+        self.models.add(propname='throat.diameter',
+                        model=gm.throat_misc.neighbor,
+                        pore_prop='pore.diameter',
+                        mode='max')
+        self['pore.volume'] = 0.0
+        self['pore.seed'] = 0.0
+        self.models.add(propname='throat.length',model=gm.throat_length.straight)
+        self['throat.volume'] = 0.0
+        self['throat.seed'] = 0.0
+        if shape == 'spheres':
+            self.models.add(propname='throat.area',model=gm.throat_area.cylinder)
+            self.models.add(propname='throat.surface_area',model=gm.throat_surface_area.cylinder)
+        elif shape == 'cubes':
+            self.models.add(propname='throat.area',model=gm.throat_area.cuboid)
+            self.models.add(propname='throat.surface_area',model=gm.throat_surface_area.cuboid)
+        self['pore.area'] = 1.0
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=True)

OpenPNM-1.1/OpenPNM/Geometry/__Cube_and_Cuboid__.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================================
+Cube_and_Cuboid -- A standard Cubic pore and Cuboic throat model
+===============================================================================
+
+"""
+
+from OpenPNM.Geometry import models as gm
+from OpenPNM.Geometry import GenericGeometry
+
+class Cube_and_Cuboid(GenericGeometry):
+    r"""
+    Toray090 subclass of GenericGeometry
+
+    """
+
+    def __init__(self, **kwargs):
+        r"""
+        Initialize
+        """
+        super(Cube_and_Cuboid,self).__init__(**kwargs)
+        self._generate()
+
+    def _generate(self):
+        r'''
+        '''
+        self.models.add(propname='pore.seed',
+                        model=gm.pore_misc.random,
+                        seed=self._seed)
+        self.models.add(propname='throat.seed',
+                        model=gm.throat_misc.neighbor,
+                        pore_prop='pore.seed',
+                        mode='min')
+        self.models.add(propname='pore.diameter',
+                        model=gm.pore_diameter.sphere,
+                        psd_name='weibull_min',
+                        psd_shape=1.5,
+                        psd_loc=14e-6,
+                        psd_scale=2e-6)
+        self.models.add(propname='pore.area',
+                        model=gm.pore_area.cubic)
+        self.models.add(propname='pore.volume',
+                        model=gm.pore_volume.cube)
+        self.models.add(propname='throat.diameter',
+                        model=gm.throat_diameter.cylinder,
+                        tsd_name='weibull_min',
+                        tsd_shape=1.5,
+                        tsd_loc=14e-6,
+                        tsd_scale=2e-6)
+        self.models.add(propname='throat.length',
+                        model=gm.throat_length.straight)
+        self.models.add(propname='throat.volume',
+                        model=gm.throat_volume.cuboid)
+        self.models.add(propname='throat.area',
+                        model=gm.throat_area.cuboid)
+        self.models.add(propname='throat.surface_area',
+                        model=gm.throat_surface_area.cuboid)
+
+if __name__ == '__main__':
+    #Run doc tests
+    import doctest
+    doctest.testmod(verbose=True)
+