A new way to trim throats from a network?

[jgostick]

I have been trying to think of a way to drop pores from the network more easily/robustly. The problem is that when you drop a pore 2 things need to happen. (1) all throats pointing to that pore must be deleted and (2) the throat conns array must be renumbered since pores have new indices on account of some being removed.

The code snippet below handles this using a class with several interdependent methosd on it. I normally don't like defining a class that I have no intension of reusing in future but this case seems to make sense since the class holds all the data and methods together.

So the idea is this: You call op.topotools.trim(network, pores=Ps) and inside that function the following class is instantiated. It is then used to drop the pores by updating the site_mask attribute to put False values in pores to be removed. You then overwrite the throat.conns array of the network with the conns attribute of this new class. There is also a bond_mask attribute that can be used to trim all the other throat properties.

import numpy as np


class NetworkTrimmer:
    r"""
    Class for managing the deletion of pores and throats from a network

    Parameters
    ----------
    coords : ndarray
        An N-by-ND array of site spatial coordinates where N is the
        number of sites and ND is the number of dimensions
    conns : ndarray
        An N-by-2 array of bond connectivity where N is the number of
        bonds

    """
    def __init__(self, coords, conns):
        self.site_mask = np.ones(coords.shape[0], dtype=bool)
        self.conns = conns
        self.coords = coords

    @property
    def site_id(self):
        return np.cumsum(self.site_mask) - 1

    @property
    def bond_id(self):
        return np.cumsum(self.bond_mask) - 1

    @property
    def bond_mask(self):
        return np.all(self.site_mask[self._conns], axis=1)

    def _set_coords(self, coords):
        self._coords = coords

    def _get_coords(self):
        return self._coords[self.site_mask]

    coords = property(fget=_get_coords, fset=_set_coords)

    def _set_conns(self, conns):
        self._conns = conns

    def _get_conns(self):
        return self.site_id[self._conns[self.bond_mask]]

    conns = property(fget=_get_conns, fset=_set_conns)


# Initialize data structures
p_coords = np.array([[0, 0],
                     [0, 1],
                     [0, 2],
                     [1, 0],
                     [1, 1],
                     [1, 2]])

t_conns = np.array([[0, 1],
                    [0, 2],
                    [1, 2],
                    [1, 4],
                    [2, 5],
                    [3, 4],
                    [4, 5]])

n = NetworkTrimmer(coords=p_coords, conns=t_conns)

print(n.conns)
n.site_mask[[2, 3]] = False
print(n.conns)

[jgostick]

I answered my own question: The answer, as always, is no don't do a class if you don't need it. I distilled it down to a stupid simple function:

def drop_sites(conns, site_mask):
    r"""
    Find new conns array after dropping sites

    Parameters
    ----------
    conns : ndarray
        The [head, tail] indices for each bond
    site_mask : ndarray
        A boolean array with ``False`` values indicating which sites to
        remove

    Returns
    -------
    conns : ndarray
        An update conns array with headless throats removed and site indices
        updated
    bond_mask : ndarray
        A boolean array with ``False`` values indicating which throats
        were headless and should be dropped for other throat arrays.

    """
    site_id = np.cumsum(site_mask) - 1
    bond_mask = np.all(site_mask[conns], axis=1)
    conns = site_id[conns[bond_mask]]
    return conns, bond_mask

This returns the new conns, as well as a mask that is used for dropping elements from all other throat arrays, like:

for arr in obj.keys():
    if arr.startswith('throat'):
        obj[arr] = obj[arr][bond_mask]