openpnm 1.0.0__zip

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

@@ -0,0 +1,133 @@
+r"""
+===============================================================================
+Submodule -- diffusive_conductance
+===============================================================================
+
+"""
+
+import scipy as sp
+
+def conduit_conductance(physics,
+                        phase,
+                        network,
+                        throat_conductance,
+                        throat_occupancy='throat.occupancy',
+                        pore_occupancy='pore.occupancy',
+                        mode='strict',
+                        factor=1e-6,
+                        **kwargs):
+    r"""
+    Add a new multiphase conductance property to the conduits of network, where a 
+    conduit is ( 1/2 pore - full throat - 1/2 pore ) based on the areas. 
+    
+    This method "closes" conduits that are not sufficiently filled with the 
+    specified phase by multiplying the original conductance by a very small *factor*.
+
+    Parameters
+    ----------
+    network : OpenPNM Network Object
+
+    phase : OpenPNM Phase Object
+        The phase of interest
+        
+    occupied_condition : 'occupancy'
+        The name of the pore and throat property that dictates whether conduit is "closed" or not
+        
+    mode : 'strict' or 'medium' or 'loose'
+        How agressive the method should be in "closing" conduits. 
+        'strict' implies that if any pore or throat in the conduit is unoccupied by the given phase, the conduit is closed.
+        'medium' implies that if either the throat or both pores are unoccupied, the conduit is closed
+        'loose' will only close the conduit if the throat is unoccupied.
+        
+    factor : 1/1e3
+        The "closing factor" which becomes multiplied to the original conduit's conductance to severely limit transport.
+
+    Notes
+    -----
+    This function requires that all the necessary phase properties already be 
+    calculated.
+
+    """
+    throats = phase.throats(physics.name)
+    if (mode == 'loose'):
+        closed_conduits = -sp.array(phase[throat_occupancy],dtype=bool)
+    else:
+        throats_closed = -sp.array(phase[throat_occupancy],dtype=bool)
+        connected_pores = network.find_connected_pores(throats)
+        pores_1 = connected_pores[:,0]
+        pores_2 = connected_pores[:,1]
+        pores_1_closed = -sp.array(phase[pore_occupancy][pores_1],dtype=bool)
+        pores_2_closed = -sp.array(phase[pore_occupancy][pores_2],dtype=bool)
+        if(mode == 'medium'):
+            closed_conduits = throats_closed | (pores_1_closed & pores_2_closed)
+            
+        if(mode == 'strict'):
+            closed_conduits = pores_1_closed | throats_closed | pores_2_closed
+    open_conduits = -closed_conduits
+    throat_value = phase[throat_conductance]
+    value = throat_value*open_conduits + throat_value*closed_conduits*factor
+    return value
+
+def late_throat_filling(network,phase,Pc_star,eta):
+    pass
+
+def late_pore_filling(physics,
+                      phase,
+                      network,
+                      Pc,
+                      Swp_star=0.2,
+                      eta=3,
+                      wetting_phase=False,
+                      pore_occupancy='pore.occupancy',
+                      throat_capillary_pressure='throat.capillary_pressure',
+                      **kwargs):
+    r'''
+    Applies a late pore filling model to calculate fractional pore filling as 
+    a function of applied capillary pressure.
+    
+    Parameters
+    ----------
+    Pc : float
+        The capillary pressure in the non-wetting phase (Pc > 0)
+    Swp_star : float
+        The residual wetting phase in an invaded pore immediately after
+        nonwetting phase invasion
+    eta : float
+        Exponent to control the rate at which wetting phase is displaced
+    wetting_phase : boolean
+        Indicates whether supplied phase is the wetting or non-wetting phase
+    
+    
+    '''
+    pores = phase.pores(physics.name)
+    prop = phase[throat_capillary_pressure]
+    neighborTs = network.find_neighbor_throats(pores,flatten=False)
+    Pc_star = sp.array([sp.amin(prop[row]) for row in neighborTs])
+    Swp = Swp_star*(Pc_star/Pc)**eta
+    if wetting_phase:
+        values = Swp*phase[pore_occupancy]*(Pc_star<Pc)
+    else:
+        values = (1-Swp)*(1-phase[pore_occupancy])*(Pc_star<Pc)
+    return values
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    

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

@@ -0,0 +1,67 @@
+r"""
+===============================================================================
+Submodule -- thermal_conductance
+===============================================================================
+
+"""
+
+import scipy as _sp
+
+def series_resistors(physics,
+                     phase,
+                     network,
+                     thermal_conductivity = 'pore.thermal_conductivity',
+                     pore_diameter = 'pore.diameter',
+                     pore_area = 'pore.area',
+                     throat_area = 'throat.area',
+                     throat_length = 'throat.length',
+                     **kwargs):
+    r"""
+    Calculate the thermal conductance of void conduits in network ( 1/2 pore - full throat - 1/2 pore ) based on size (assuming cylindrical geometry)
+
+    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
+    kp = phase[thermal_conductivity]
+    kt = phase.interpolate_data(kp)
+    #Find g for half of pore 1
+    pdia = network[pore_diameter]
+    parea = network[pore_area]
+    pdia1 = pdia[Ps[:,0]]
+    pdia2 = pdia[Ps[:,1]]
+    #remove any non-positive lengths
+    pdia1[pdia1<=0] = 1e-12
+    pdia2[pdia2<=0] = 1e-12
+    gp1 = kt*parea[Ps[:,0]]/(0.5*pdia1)
+    gp1[~(gp1>0)] = _sp.inf #Set 0 conductance pores (boundaries) to inf
+    #Find g for half of pore 2
+    gp2 = kt*parea[Ps[:,1]]/(0.5*pdia2)
+    gp2[~(gp2>0)] = _sp.inf #Set 0 conductance pores (boundaries) to inf
+    #Find g for full throat
+    tarea = network[throat_area]
+    tlen = network[throat_length]
+    #remove any non-positive lengths
+    tlen[tlen<=0] = 1e-12
+    gt = kt*tarea/tlen
+    value = (1/gt + 1/gp1 + 1/gp2)**(-1)
+    value = value[phase.throats(physics.name)]
+    return value
+    
+
+

OpenPNM-1.1/OpenPNM/Postprocessing/Graphics.py

@@ -0,0 +1,251 @@
+from tempfile import NamedTemporaryFile
+from subprocess import call
+from itertools import count
+import numpy as np
+from matplotlib import cm
+
+try:
+    import vtk
+except ImportError:
+    vtk = type("", (), {'vtkActor': object})
+
+class Actor(vtk.vtkActor):
+
+    def __init__(self):
+        raise NotImplementedError()
+
+    def pointArray(self, _points):
+        points = vtk.vtkPoints()
+        for x,y,z in _points:
+            points.InsertNextPoint(x, y, z)
+        return points
+
+    def lineArray(self, _lines):
+        lines = vtk.vtkCellArray()
+        for id_set in _lines:
+            l = vtk.vtkIdList()
+            for i in id_set:
+                l.InsertNextId(i)
+            lines.InsertNextCell(l)
+        return lines
+
+    def faceArray(self, faces):
+        lines = vtk.vtkCellArray()
+        for face in faces:
+            l = vtk.vtkIdList()
+            for i in face:
+                l.InsertNextId(i)
+            lines.InsertNextCell(l)
+        return lines
+
+    def floatArray(self, array):
+        floats = vtk.vtkFloatArray()
+        for n in array:
+            floats.InsertNextValue(n)
+        return floats
+
+    def colorArray(self, array, cmap=None):
+        colors = vtk.vtkUnsignedCharArray()
+        colors.SetNumberOfComponents(3)
+        if cmap is None:
+            cmap = 'coolwarm'
+        colormap = cm.get_cmap(cmap)
+        mapped = colormap(array)
+        for r,g,b,a in 255*mapped:
+            colors.InsertNextTuple3(r,g,b)
+        return colors
+
+    def update(self, t=0):
+        pass
+
+
+class Wires(Actor):
+
+    def __init__(self, vertex_coords, edge_pairs, vertex_weights=None, alpha=1, cmap=None):
+        self.polydata = vtk.vtkPolyData()
+        self.polydata.SetPoints(self.pointArray(vertex_coords))
+        self.polydata.SetLines(self.lineArray(edge_pairs))
+        self.mapper = vtk.vtkPolyDataMapper()
+        self.mapper.SetInput(self.polydata)
+        self.SetMapper(self.mapper)
+
+        if vertex_weights is None:
+            weights = np.atleast_2d([128 for _ in vertex_coords])
+        else:
+            weights = np.atleast_2d(vertex_weights)
+            weights = np.subtract(weights, weights.min())
+            weights = np.true_divide(weights, weights.max())
+        self.weights = weights
+        self.cmap = cmap
+        self.update()
+
+        self.GetProperty().SetOpacity(alpha)
+
+    def update(self, t=0):
+        i = t % len(self.weights)
+        self.polydata.GetPointData().SetScalars(self.colorArray(self.weights[i], self.cmap))
+
+
+class Surface(Actor):
+
+    def __init__(self, vertex_coords, edge_pairs, vertex_weights=None, alpha=1,
+                 cmap=None, offset=0):
+        self.offset = offset
+        self.polydata = vtk.vtkPolyData()
+        self.polydata.SetPoints(self.pointArray(vertex_coords))
+        self.polydata.SetLines(self.lineArray(edge_pairs))
+        self.mapper = vtk.vtkPolyDataMapper()
+        self.mapper.SetInput(self.polydata)
+        self.SetMapper(self.mapper)
+
+        if vertex_weights is None:
+            weights = np.atleast_2d([128 for _ in vertex_coords])
+        else:
+            weights = np.atleast_2d(vertex_weights)
+        self.weights = weights
+        self.cmap = cmap
+        self.update()
+
+        self.GetProperty().SetOpacity(alpha)
+
+    def update(self, t=0):
+        i = t % len(self.weights)
+        values = self.weights[i]
+        # update z-positions
+        points = self.polydata.GetPoints()
+        for i, v in enumerate(values):
+            x,y,_ = points.GetPoint(i)
+            points.SetPoint(i, x, y, v+self.offset)
+        # update colors
+        normalized = np.true_divide(values, np.abs(self.weights).max())
+        normalized = np.subtract(normalized, self.weights.min())
+        colors = self.colorArray(normalized, self.cmap)
+        self.polydata.GetPointData().SetScalars(colors)
+
+
+class Tubes(Actor):
+
+    def __init__(self, centers, vectors, radii, alpha=1, cmap=None):
+        tails = centers - vectors/2.
+        heads = centers + vectors/2.
+        points = np.vstack(zip(tails, heads))
+        pairs = np.arange(len(centers)*2).reshape(-1, 2)
+        radii = radii.repeat(2)
+
+        assert (points.size/3. == pairs.size)
+        assert (pairs.size == radii.size)
+
+        self.polydata = vtk.vtkPolyData()
+        self.polydata.SetPoints(self.pointArray(points))
+        self.polydata.SetLines(self.lineArray(pairs))
+        self.polydata.GetPointData().SetScalars(self.floatArray(radii))
+
+        self.tubeFilter = vtk.vtkTubeFilter()
+        self.tubeFilter.SetInput(self.polydata)
+        self.tubeFilter.SetVaryRadiusToVaryRadiusByAbsoluteScalar()
+        self.tubeFilter.SetNumberOfSides(10)
+        self.tubeFilter.CappingOn()
+
+        self.mapper = vtk.vtkPolyDataMapper()
+        self.mapper.SetInputConnection(self.tubeFilter.GetOutputPort())
+        self.mapper.ScalarVisibilityOff()
+        self.SetMapper(self.mapper)
+
+        self.GetProperty().SetOpacity(alpha)
+
+
+class Spheres(Actor):
+
+    def __init__(self, centers, radii, alpha=1, color=(1,1,1)):
+        self.polydata = vtk.vtkPolyData()
+        self.polydata.SetPoints(self.pointArray(centers))
+        self.radii = np.atleast_2d(radii)
+        self.update()
+
+        self.sphere_source = vtk.vtkSphereSource()
+        self.glypher = vtk.vtkProgrammableGlyphFilter()
+        self.glypher.SetInput(self.polydata)
+        self.glypher.SetSource(self.sphere_source.GetOutput())
+        self.glypher.SetGlyphMethod(self.glyph_method)
+
+        self.mapper = vtk.vtkPolyDataMapper()
+        self.mapper.SetInputConnection(self.glypher.GetOutputPort())
+        self.SetMapper(self.mapper)
+
+        self.GetProperty().SetOpacity(alpha)
+        r,g,b = color
+        self.mapper.SetScalarVisibility(False)
+        self.GetProperty().SetColor(r,g,b)
+
+    def glyph_method(self):
+        pid = self.glypher.GetPointId()
+        self.sphere_source.SetCenter(self.glypher.GetPoint())
+        radius = self.glypher.GetPointData().GetScalars().GetValue(pid)
+        self.sphere_source.SetRadius(radius)
+
+    def update(self, t=0):
+        i = t % len(self.radii)
+        self.polydata.GetPointData().SetScalars(self.floatArray(self.radii[i]))
+
+
+class Scene(object):
+    ticks = count(0)
+
+    def __init__(self, parent=None, fix_camera=True):
+        '''
+        fix_camera : more sensible default
+        '''
+        if parent is not None:
+            self.renWin = parent.GetRenderWindow()
+            self.iren = self.renWin.GetInteractor()
+        else:
+            self.renWin = vtk.vtkRenderWindow()
+            self.iren = vtk.vtkRenderWindowInteractor()
+            self.iren.SetRenderWindow(self.renWin)
+
+        self.ren = vtk.vtkRenderer()
+        self.renWin.AddRenderer(self.ren)
+
+        if fix_camera:
+            camera = vtk.vtkInteractorStyleTrackballCamera()
+            self.iren.SetInteractorStyle(camera)
+
+    def update_all(self, object=None, event=None, t=None):
+        if t is None:   t = next(self.ticks)
+        for aid in range(self.ren.VisibleActorCount()):
+            actor = self.ren.GetActors().GetItemAsObject(aid)
+            actor.update(t)
+        self.renWin.Render()
+
+    def save(self, frames, outfile='animated.gif'):
+        '''
+        takes a snapshot of the frames at given t, and returns the paths
+        '''
+        windowToImage = vtk.vtkWindowToImageFilter()
+        windowToImage.SetInput(self.renWin)
+        writer = vtk.vtkPNGWriter()
+        writer.SetInput(windowToImage.GetOutput())
+
+        slide_paths = []
+        for t in frames:
+            f = NamedTemporaryFile(suffix='.png', delete=False)
+            self.update_all(t=t)
+            windowToImage.Modified()
+            writer.SetFileName(f.name)
+            writer.Write()
+            slide_paths.append( f.name )
+
+        call(["convert"] + slide_paths + [outfile])
+        call(["rm"] + slide_paths)
+
+    def play(self, timeout=1):
+        self.iren.Initialize()
+        if timeout is not None:
+            self.iren.AddObserver('TimerEvent', self.update_all)
+            self.timer = self.iren.CreateRepeatingTimer(timeout)
+        self.update_all()
+        self.iren.Start()
+
+    def add_actors(self, list_of_actors):
+        for actor in list_of_actors:
+            self.ren.AddActor(actor)