Source code for openpnm.topotools._perctools

import logging
import numpy as np
import scipy.sparse as sprs
from scipy.sparse import csgraph
from openpnm.utils import PrintableDict, Workspace
from openpnm._skgraph import simulations
from openpnm._skgraph import queries
from collections import namedtuple


logger = logging.getLogger(__name__)
ws = Workspace()
__all__ = [
    'ispercolating',
    'find_isolated_clusters',
    'trim_disconnected_clusters',
    'site_percolation',
    'bond_percolation',
    'find_clusters',
    'find_path',
]



[docs]
def find_path(network, pore_pairs, weights=None):
    return queries.find_path(network=network, pairs=pore_pairs, weights=weights)



find_path.__doc__ = queries.find_path.__doc__



[docs]
def ispercolating(network, inlets, outlets):
    if np.array(inlets).dtype == bool:
        inlets = np.where(inlets)[0]
    if np.array(outlets).dtype == bool:
        outlets = np.where(outlets)[0]
    flag = simulations.ispercolating(
        conns=network.conns,
        occupied=np.ones(network.Nt, dtype=bool),
        inlets=inlets,
        outlets=outlets
    )
    return flag



ispercolating.__doc__ = simulations.ispercolating.__doc__



[docs]
def site_percolation(network, occupied_sites):
    return simulations.site_percolation(network.conns, occupied_sites)



site_percolation.__doc__ = simulations.site_percolation.__doc__



[docs]
def bond_percolation(network, occupied_bonds):
    return simulations.bond_percolation(network.conns, occupied_bonds)



bond_percolation.__doc__ = simulations.bond_percolation.__doc__



[docs]
def trim_disconnected_clusters(**kwargs):
    return simulations.trim_disconnected_clusters(**kwargs)



trim_disconnected_clusters.__doc__ = \
    simulations.trim_disconnected_clusters.__doc__



[docs]
def find_isolated_clusters(network, mask, inlets):
    r"""
    Identifies pores and throats that are invaded but not connected to the inlets

    Parameters
    ----------
    network : dict
        The OpenPNM Network
    mask : ndarray
        A boolean mask of either Nt or Np length with ``True`` values
        indicating invaded bonds or sites. If this array is Nt-long then
        then bond percolation is used to identify clusters, whereas site
        percolation is used if it is Np-long.
    inlets : ndarray
        A array containing indices of the pores which define the inlets. Any
        clusters not connected to these sites are considered isolated.

    Returns
    -------
    sites : ndarray
        An ndarray containing the indices of invaded pores which are not
        connected to the given ``inlets``.
    """
    labels = find_clusters(network=network, mask=mask)
    isolated = np.in1d(labels.pore_labels, labels.pore_labels[inlets], invert=True)
    isolated = np.where(isolated)[0]
    return isolated




[docs]
def find_clusters(network, mask=[]):
    r"""
    Identify connected clusters of pores and throats in the network.

    Either site and bond percolation can be considered, see description of
    ``mask`` argument for details.

    Parameters
    ----------
    network : Network
        The network
    mask : array_like, boolean
        A list of open bonds or sites (throats or pores). If the mask is
        Np-long, then the method will perform a site percolation to identify
        clusters, and if the mask is Nt-long bond percolation will be
        performed.

    Returns
    -------
    p_labels, t_labels : tuple of ndarrays
        A tuple containing an Np-long array of pore cluster labels, and an
        Nt-long array of throat cluster labels. The label numbers correspond
        such that pores and throats with the same label are part of the same
        cluster. Uninvaded locations are set to -1.

    """
    # Parse the input arguments
    mask = np.array(mask, ndmin=1)
    if mask.dtype != bool:
        raise Exception('Mask must be a boolean array of Np or Nt length')
    # If pore mask was given perform site percolation
    if np.size(mask) == network.Np:
        (p_clusters, t_clusters) = \
            simulations.site_percolation(network.conns, mask)
    # If pore mask was given perform bond percolation
    elif np.size(mask) == network.Nt:
        (p_clusters, t_clusters) = \
            simulations.bond_percolation(network.conns, mask)
    else:
        raise Exception('Mask received was neither Nt nor Np long')
    result = namedtuple('result', ('pore_labels', 'throat_labels'))
    result.pore_labels = p_clusters
    result.throat_labels = t_clusters
    return result