Hugging Face's logo

Datasets:
introvoyz042
/
OpenPNM

License:
Dataset card Files
xet
 Community
OpenPNM / data /tests /unit /core /BaseTest.py
introvoyz042's picture
introvoyz042
Migrated from GitHub
f421c2e verified
Raw History Blame Contribute Delete
33.1 kB
import numpy as np
import pytest
import openpnm as op
class BaseTest:
def setup_class(self):
self.net = op.network.Cubic([3, 3, 3])
self.net.set_label(throats=self.net.Ts, label='internal')
self.net.set_label(pores=self.net.Ps, label='internal')
def teardown_class(self):
ws = op.Workspace()
ws.clear()
def test_clear_model_data(self):
pn = op.network.Cubic([5, 5, 5])
phase = op.phase.Water(network=pn)
a = len(phase)
phase.clear(mode='models')
assert len(phase) == (a - len(phase.models))
# Clear non existing data
phase.clear(mode='models')
assert len(phase) == (a - len(phase.models))
def test_clear_model_data_when_model_returns_dictionary(self):
pn = op.network.Cubic([5, 5, 5])
# geo = op.geometry.SpheresAndCylinders(network=pn, pores=pn.Ps, throats=pn.Ts)
# geo.clear(mode='models')
def test_pores(self):
a = self.net.pores()
assert np.all(a == np.arange(0, self.net.Np))
def test_pores_one_label(self):
a = self.net.pores(labels='top')
assert np.all(a == [2, 5, 8, 11, 14, 17, 20, 23, 26])
def test_pores_two_labels_or(self):
a = self.net.pores(labels=['top', 'left'], mode='or')
assert np.all(a == [0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 14, 17, 20, 23, 26])
def test_pores_two_labels_xnor(self):
a = self.net.pores(labels=['top', 'left'], mode='xnor')
assert np.all(a == [2, 5, 8])
def test_pores_two_labels_not_xor(self):
a = self.net.pores(labels=['top', 'left'], mode='xor')
assert np.all(a == [0, 1, 3, 4, 6, 7, 11, 14, 17, 20, 23, 26])
def test_pores_two_labels_nor(self):
a = self.net.pores(labels=['top', 'left'], mode='nor')
assert np.all(a == [9, 10, 12, 13, 15, 16, 18, 19, 21, 22, 24, 25])
b = self.net.pores(labels=['top', 'left'], mode='or')
c = self.net.to_mask(pores=a)*self.net.to_mask(pores=b)
assert c.sum() == 0
def test_pores_two_labels_nand(self):
a = self.net.pores(labels=['top', 'left'], mode='nand')
assert np.all(a == [0, 1, 3, 4, 6, 7, 11, 14, 17, 20, 23, 26])
def test_pores_bad_mode(self):
with pytest.raises(Exception):
self.net.pores(labels=['top', 'front'], mode='bob')
def test_pores_empty_list(self):
a = self.net.pores(labels=[], mode='or')
assert a.size == 0
def test_pores_asmask(self):
a = self.net.pores(labels=['top', 'front'], mode='or', asmask=True)
assert a.sum() == 15
b = self.net.pores(labels=['top', 'front'], mode='or')
assert np.all(np.where(a)[0] == b)
# def test_pores_and_throats_with_to_global(self):
# net = op.network.Cubic(shape=[2, 2, 2])
# geo1 = op.geometry.GenericGeometry(network=net,
# pores=[1, 3, 5, 7],
# throats=range(6))
# geo2 = op.geometry.GenericGeometry(network=net,
# pores=[0, 2, 4, 6],
# throats=range(6, 12))
# assert np.all(net.throats('geo_01') == geo1.throats(to_global=True))
# assert np.all(net.throats('geo_02') == geo2.throats(to_global=True))
# assert np.all(net.pores('geo_01') == geo1.pores(to_global=True))
# assert np.all(net.pores('geo_02') == geo2.pores(to_global=True))
def test_throats(self):
a = self.net.throats()
assert np.all(a == np.arange(0, self.net.Nt))
def test_throats_asmask(self):
a = self.net.throats(labels=['all'], mode='or', asmask=True)
assert a.sum() == 54
b = self.net.throats(labels=['all'], mode='or')
assert np.all(np.where(a)[0] == b)
# def test_throats_one_label(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# a = self.net.throats(labels='label1')
# assert np.all(a == [0, 1, 2, 3, 4, 5])
# self.geo.pop('throat.label1')
# def test_throats_two_labels_or(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label2'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# self.geo['throat.label2'][[6, 7, 8]] = True
# a = self.net.throats(labels=['label1', 'label2'], mode='or')
# assert np.all(a == [0, 1, 2, 3, 4, 5, 6, 7, 8])
# self.geo.pop('throat.label1')
# self.geo.pop('throat.label2')
# def test_throats_two_labels_xnor(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label2'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# self.geo['throat.label2'][[3, 4, 5, 6, 7, 8]] = True
# a = self.net.throats(labels=['label1', 'label2'], mode='xnor')
# assert np.all(a == [3, 4, 5])
# self.geo.pop('throat.label1')
# self.geo.pop('throat.label2')
# def test_throats_two_labels_xor(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label2'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# self.geo['throat.label2'][[3, 4, 5, 6, 7, 8]] = True
# a = self.net.throats(labels=['label1', 'label2'], mode='xor')
# assert np.all(a == [0, 1, 2, 6, 7, 8])
# self.geo.pop('throat.label1')
# self.geo.pop('throat.label2')
def test_filter_by_label_pores_no_label(self):
Ps = self.net.pores(['top', 'bottom', 'front'])
with pytest.raises(Exception):
self.net.filter_by_label(pores=Ps)
def test_filter_by_label_pores_one_label_as_string(self):
Ps = self.net.pores(['top', 'bottom', 'front'])
a = self.net.filter_by_label(pores=Ps, labels='top', mode='or')
b = [2, 5, 8, 11, 14, 17, 20, 23, 26]
assert np.all(a == b)
def test_filter_by_label_pores_one_label_as_list(self):
Ps = self.net.pores(['top', 'bottom', 'front'])
a = self.net.filter_by_label(pores=Ps, labels=['top'])
b = [2, 5, 8, 11, 14, 17, 20, 23, 26]
assert np.all(a == b)
def test_filter_by_label_pores_two_labels_or(self):
Ps = self.net.pores(['top', 'bottom', 'front'])
a = self.net.filter_by_label(pores=Ps, labels=['top', 'bottom'],
mode='or')
b = [0, 2, 3, 5, 6, 8, 9, 11, 12, 14, 15, 17, 18, 20, 21, 23, 24, 26]
assert np.all(a == b)
def test_filter_by_label_pores_two_labels_xnor(self):
Ps = self.net.pores(['top', 'bottom', 'left'])
a = self.net.filter_by_label(pores=Ps, labels=['top', 'left'],
mode='xnor')
b = [2, 5, 8]
assert np.all(a == b)
def test_filter_by_label_pores_two_labels_xnor_empty(self):
Ps = self.net.pores(['top', 'bottom', 'left'])
a = self.net.filter_by_label(pores=Ps, labels=['top', 'bottom'],
mode='xnor')
b = []
assert np.all(a == b)
def test_filter_by_label_pores_two_labels_xor(self):
Ps = self.net.pores(['top', 'bottom', 'left'])
a = self.net.filter_by_label(pores=Ps, labels=['top', 'left'],
mode='xor')
b = [0, 1, 3, 4, 6, 7, 11, 14, 17, 20, 23, 26]
assert np.all(a == b)
def test_filter_by_label_pores_two_labels_nor(self):
Ps = self.net.pores(['top', 'bottom', 'left'])
a = self.net.filter_by_label(pores=Ps, labels=['top', 'left'],
mode='nor')
b = [9, 12, 15, 18, 21, 24]
assert np.all(a == b)
def test_filter_by_label_empty_locations(self):
a = self.net.filter_by_label(pores=[], labels='top')
assert np.size(a) == 0
def test_filter_by_label_pores_and_throats(self):
with pytest.raises(Exception):
self.net.filter_by_label(pores=[0, 1, 2], throats=[0, 1, 2])
def test_tomask_pores(self):
a = self.net.to_mask(pores=self.net.pores('top'))
assert np.sum(a) == 9
# def test_tomask_throats(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# a = self.net.to_mask(throats=self.net.throats('label1'))
# assert np.sum(a) == 6
# self.geo.pop('throat.label1')
# def test_tomask_pores_and_throats(self):
# with pytest.raises(Exception):
# _ = self.net.to_mask(throats=[0, 1, 2], pores=[0, 1, 2])
def test_toindices_pores(self):
mask = np.zeros((self.net.Np), dtype=bool)
Ps = [0, 3, 6]
mask[Ps] = True
a = self.net.to_indices(mask)
assert np.all(a == Ps)
def test_toindices_throats(self):
mask = np.zeros((self.net.Nt), dtype=bool)
Ts = [0, 3, 6]
mask[Ts] = True
a = self.net.to_indices(mask)
assert np.all(a == Ts)
def test_toindices_float_mask(self):
mask = (np.random.rand(self.net.Np) < 0.5)
inds_in = np.where(mask)[0]
inds_out = self.net.to_indices(mask*1.0)
assert np.all(inds_in == inds_out)
# def test_toindices_invalid_mask(self):
# mask = self.net.Np
# with pytest.raises(Exception):
# self.net.to_indices(mask)
# def test_toindices_wrong_mask(self):
# mask = np.zeros((self.net.Nt)-2, dtype=bool)
# mask[[0, 3, 6]] = True
# with pytest.raises(Exception):
# self.net.to_indices(mask)
def test_count(self):
with pytest.raises(Exception):
self.net._count()
def test_num_pores(self):
a = self.net.num_pores()
assert a == 27
def test_num_pores_one_label(self):
a = self.net.num_pores(labels='top')
assert a == 9
def test_num_pores_two_labels_or(self):
a = self.net.num_pores(labels=['top', 'front'], mode='or')
assert a == 15
def test_num_pores_two_labels_xnor(self):
a = self.net.num_pores(labels=['top', 'front'], mode='xnor')
assert a == 3
def test_num_pores_two_labels_xor(self):
a = self.net.num_pores(labels=['top', 'front'],
mode='xor')
assert a == 12
def test_num_pores_two_labels_nor(self):
a = self.net.num_pores(labels=['top', 'front'], mode='nor')
assert a == 12
def test_num_throats(self):
a = self.net.num_throats()
assert a == 54
# def test_num_throats_one_label(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# a = self.net.num_throats(labels='label1')
# assert a == 6
# self.geo.pop('throat.label1')
# def test_num_throats_two_labels_or(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label2'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# self.geo['throat.label2'][[3, 4, 5, 6, 7, 8]] = True
# a = self.net.num_throats(labels=['label1', 'label2'], mode='or')
# assert a == 9
# self.geo.pop('throat.label1')
# self.geo.pop('throat.label2')
# def test_num_throats_two_labels_xnor(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label2'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# self.geo['throat.label2'][[3, 4, 5, 6, 7, 8]] = True
# a = self.net.num_throats(labels=['label1', 'label2'],
# mode='xnor')
# assert a == 3
# self.geo.pop('throat.label1')
# self.geo.pop('throat.label2')
# def test_num_throats_two_labels_xor(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label2'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# self.geo['throat.label2'][[3, 4, 5, 6, 7, 8]] = True
# a = self.net.num_throats(labels=['label1', 'label2'],
# mode='xor')
# assert a == 6
# self.geo.pop('throat.label1')
# self.geo.pop('throat.label2')
# def test_num_throats_two_labels_nor(self):
# self.geo['throat.label1'] = False
# self.geo['throat.label2'] = False
# self.geo['throat.label1'][[0, 1, 2, 3, 4, 5]] = True
# self.geo['throat.label2'][[3, 4, 5, 6, 7, 8]] = True
# a = self.net.num_throats(labels=['label1', 'label2'],
# mode='nor')
# assert a == 45
# self.geo.pop('throat.label1')
# self.geo.pop('throat.label2')
def test_keys_mode_skip(self):
a = self.net.keys()
assert 'dict_keys' in str(type(a))
def test_keys_mode_props(self):
a = self.net.keys(mode='props')
assert 'dict_keys' not in str(type(a))
b = [i for i in a if self.net[i].dtype != bool]
assert a == b
def test_keys_mode_labels(self):
a = self.net.keys(mode='labels')
assert 'dict_keys' not in str(type(a))
b = [i for i in a if self.net[i].dtype == bool]
assert a == b
def test_keys_mode_models(self):
self.net.regenerate_models()
a = self.net.keys(mode='models')
assert 'dict_keys' not in str(type(a))
b = [i.split('@')[0] for i in self.net.models.keys() if
i.split('@')[0] in self.net.keys()]
assert set(a) == set(b)
def test_keys_mode_constants(self):
self.net.regenerate_models()
a = self.net.keys(mode='constants')
assert 'dict_keys' not in str(type(a))
mods = [i.split('@')[0] for i in self.net.models.keys()]
b = [i for i in self.net.keys() if
((i not in mods) and (self.net[i].dtype != 'bool'))]
assert set(a) == set(b)
def test_keys_mode_props_and_labels(self):
a = self.net.keys(mode=['props', 'labels'])
b = list(self.net.keys())
assert set(a) == set(b)
# def test_props_all(self):
# a = self.geo.props()
# b = ['pore.diameter', 'pore.volume', 'throat.cross_sectional_area',
# 'throat.diameter']
# assert sorted(a) == b
# def test_props_models(self):
# a = self.geo.props(mode='models')
# b = ['pore.volume', 'throat.cross_sectional_area']
# assert sorted(a) == sorted(b)
# def test_props_constants(self):
# a = self.geo.props(mode='constants')
# b = ['pore.diameter', 'throat.diameter']
# assert sorted(a) == sorted(b)
# def test_props_pores_all(self):
# a = self.geo.props(element='pores')
# b = ['pore.diameter', 'pore.volume']
# assert sorted(a) == sorted(b)
# def test_props_pores_models(self):
# a = self.geo.props(element='pores', mode='models')
# b = ['pore.volume']
# assert sorted(a) == sorted(b)
# def test_props_pores_constants(self):
# a = self.geo.props(element='pores', mode='constants')
# b = ['pore.diameter']
# assert sorted(a) == sorted(b)
def test_props_hidden_keys(self):
self.net['pore._blah'] = 1.0
assert 'pore._blah' not in self.net.__str__()
assert 'pore._blah' not in self.net.props()
assert 'pore._blah' in self.net.keys()
def test_labels(self):
a = self.net.labels()
assert 'pore.top' in a
def test_labels_on_pores(self):
a = self.net.labels(element='pore')
b = ['pore.back',
'pore.bottom',
'pore.front',
'pore.internal',
'pore.left',
'pore.right',
'pore.surface',
'pore.top',
'pore.xmax',
'pore.xmin',
'pore.ymax',
'pore.ymin',
'pore.zmax',
'pore.zmin']
assert sorted(a) == sorted(b)
def test_labels_on_throats(self):
a = self.net.labels(element='throat')
b = ['throat.internal', 'throat.surface']
assert sorted(a) == sorted(b)
def test_labels_on_pores_and_throats(self):
with pytest.raises(Exception):
self.net.labels(pores=[0, 1], throats=[0, 1])
# def test_labels_on_foo(self):
# with pytest.raises(Exception):
# self.net.labels(element='foo')
def test_labels_on_all_pores(self):
a = self.net.labels(pores=self.net.Ps)
b = ['pore.back',
'pore.bottom',
'pore.front',
'pore.internal',
'pore.left',
'pore.right',
'pore.surface',
'pore.top',
'pore.xmax',
'pore.xmin',
'pore.ymax',
'pore.ymin',
'pore.zmax',
'pore.zmin']
assert sorted(a) == sorted(b)
def test_labels_on_all_throats(self):
a = self.net.labels(throats=self.net.Ts)
b = ['throat.internal', 'throat.surface']
assert sorted(a) == sorted(b)
def test_labels_on_one_pore(self):
a = self.net.labels(pores=0)
b = ['pore.bottom',
'pore.front',
'pore.internal',
'pore.left',
'pore.surface',
'pore.xmin',
'pore.ymin',
'pore.zmin']
assert sorted(a) == sorted(b)
def test_labels_on_list_of_pores(self):
a = self.net.labels(pores=[0, 1])
b = ['pore.bottom',
'pore.front',
'pore.internal',
'pore.left',
'pore.surface',
'pore.xmin',
'pore.ymin',
'pore.zmin']
assert sorted(a) == sorted(b)
def test_labels_locations_boolean(self):
ind = np.zeros((self.net.Np), dtype=bool)
ind[[0, 1]] = True
a = self.net.labels(pores=ind)
b = ['pore.bottom',
'pore.front',
'pore.internal',
'pore.left',
'pore.surface',
'pore.xmin',
'pore.ymin',
'pore.zmin']
assert sorted(a) == sorted(b)
def test_labels_pores_mode_or(self):
a = self.net.labels(pores=[0, 1, 2], mode='or')
b = ['pore.bottom',
'pore.front',
'pore.internal',
'pore.left',
'pore.surface',
'pore.top',
'pore.xmin',
'pore.ymin',
'pore.zmax',
'pore.zmin']
assert sorted(a) == sorted(b)
def test_labels_pores_mode_and(self):
a = self.net.labels(pores=[0, 1, 2], mode='and')
b = ['pore.front',
'pore.internal',
'pore.left',
'pore.surface',
'pore.xmin',
'pore.ymin']
assert sorted(a) == sorted(b)
def test_labels_pores_mode_xor(self):
a = self.net.labels(pores=[0, 1, 2], mode='xor')
b = ['pore.bottom', 'pore.top', 'pore.zmax', 'pore.zmin']
assert sorted(a) == sorted(b)
def test_labels_pores_mode_nand(self):
a = self.net.labels(pores=[0, 1, 2], mode='nand')
b = []
assert sorted(a) == sorted(b)
def test_labels_pores_mode_xnor(self):
a = self.net.labels(pores=[0, 1, 2], mode='xnor')
b = ['pore.front',
'pore.internal',
'pore.left',
'pore.surface',
'pore.xmin',
'pore.ymin']
assert sorted(a) == sorted(b)
def test_labels_pores_mode_nor(self):
a = self.net.labels(pores=[0, 1, 2], mode='nor')
b = ['pore.back', 'pore.right', 'pore.xmax', 'pore.ymax']
assert sorted(a) == sorted(b)
def test_labels_pores_mode_foo(self):
with pytest.raises(Exception):
self.net.labels(pores=[0, 1], mode='foo')
def test_labels_hidden_key(self):
self.net['pore._foo'] = True
assert 'pore._foo' not in self.net.__str__()
assert 'pore._foo' in self.net.keys()
def test_parse_indices_boolean(self):
b = np.array([True, True, True])
with pytest.raises(Exception):
self.net._parse_indices(indices=b)
b = np.zeros((self.net.Np,), dtype=bool)
assert len(self.net._parse_indices(indices=b)) == 0
b = np.zeros((self.net.Nt,), dtype=bool)
b[[0, 1, 2]] = True
assert np.shape(self.net._parse_indices(indices=b)) == (3,)
def test_parse_indices_None(self):
assert len(self.net._parse_indices(indices=None)) == 0
def test_parse_indices_int(self):
a = self.net._parse_indices(indices=0)
assert isinstance(a, np.ndarray)
assert np.all(a == 0)
def test_parse_indices_list(self):
a = self.net._parse_indices(indices=[0, 1])
assert isinstance(a, np.ndarray)
assert np.all(a == [0, 1])
def test_parse_element_None(self):
a = self.net._parse_element(element=None)
assert sorted(a) == ['pore', 'throat']
def test_parse_element_various_strings(self):
a = self.net._parse_element(element='pore')
assert a == ['pore']
a = self.net._parse_element(element='Pore')
assert a == ['pore']
a = self.net._parse_element(element='pores')
assert a == ['pore']
a = self.net._parse_element(element='Pores')
assert a == ['pore']
a = self.net._parse_element(element='throat')
assert a == ['throat']
a = self.net._parse_element(element='Throat')
assert a == ['throat']
a = self.net._parse_element(element='throats')
assert a == ['throat']
a = self.net._parse_element(element='Throats')
assert a == ['throat']
def test_parse_element_bad_string(self):
with pytest.raises(Exception):
self.net._parse_element(element='pore2')
def test_parse_element_duplicate(self):
a = self.net._parse_element(element=['pore', 'pore'])
assert a == ['pore']
a = self.net._parse_element(element=['pore', 'pore'], single=True)
assert a == 'pore'
def test_parse_element_single_true(self):
with pytest.raises(Exception):
self.net._parse_element(element=['pore', 'throat'], single=True)
a = self.net._parse_element(element=['pore'], single=True)
assert a == 'pore'
def test_parse_element_props(self):
a = self.net._parse_element(element=['pore.diameter'], single=True)
assert a == 'pore'
def test_parse_labels_none(self):
with pytest.raises(Exception):
self.net._parse_labels(labels=None, element='pore')
def test_parse_labels_string(self):
a = self.net._parse_labels(labels='top', element='pore')
assert a == ['pore.top']
a = self.net._parse_labels(labels='internal', element='throat')
assert a == ['throat.internal']
a = self.net._parse_labels(labels='pore.top', element='pore')
assert a == ['pore.top']
a = self.net._parse_labels(labels='throat.internal', element='throat')
assert a == ['throat.internal']
def test_parse_labels_wildcards(self):
a = self.net._parse_labels(labels='pore.b*', element='pore')
assert sorted(a) == ['pore.back', 'pore.bottom']
a = self.net._parse_labels(labels='pore.*ight', element='pore')
assert sorted(a) == ['pore.right']
def test_parse_labels_duplicates(self):
a = self.net._parse_labels(['pore.r*', 'pore.right'], element='pore')
assert a == ['pore.right']
def test_parse_mode_string(self):
a = self.net._parse_mode(mode='or')
assert a == ['or']
def test_parse_mode_single(self):
a = self.net._parse_mode(mode=['or', 'xnor'])
assert sorted(a) == ['or', 'xnor']
with pytest.raises(Exception):
a = self.net._parse_mode(mode=['or1', 'or2'], single=True)
a = self.net._parse_mode(mode=['or1'], single=True)
assert a == 'or1'
def test_parse_mode_allowed(self):
allowed = ['a', 'b', 'c']
with pytest.raises(Exception):
self.net._parse_mode(mode=['a', 'd'], allowed=allowed)
def test_parse_mode_duplicate(self):
a = self.net._parse_mode(mode=['or', 'or'])
assert a == ['or']
a = self.net._parse_mode(mode=['or', 'or'], single=True)
assert a == 'or'
def test_setitem_wrong_prefix(self):
with pytest.raises(Exception):
self.geo['pore2.test'] = 0
def test_setitem_wrong_length(self):
with pytest.raises(Exception):
self.net['pore.test'] = np.ones((self.net.Np+1))
assert 'pore.test' not in self.net.keys()
# def test_setitem_replace_all(self):
# array_len = np.size(self.geo['pore.all'])
# self.geo['pore.all'] = np.ones((self.geo.Np+1))
# assert np.size(self.geo['pore.all']) == array_len
def test_setitem_overwrite_into_all(self):
pass
# This test will fail as there is currently no way to prevent this
# array_sum = np.sum(self.geo['pore.all'])
# self.geo['pore.all'][0] = False
# assert np.sum(self.geo['pore.all']) == array_sum
# def test_setitem_subdict_conflicts(self):
# self.geo['pore.foo'] = 1
# with pytest.raises(Exception):
# self.geo['pore.foo.bar'] = 1
# self.geo['throat.foo.bar'] = 1
# with pytest.raises(Exception):
# self.geo['throat.foo'] = 1
# def test_object_name_name_conflict(self):
# with pytest.raises(Exception):
# self.geo.name = self.net.name
# def test_object_name_array_conflict(self):
# with pytest.raises(Exception):
# self.geo.name = 'coords'
# Np = self.geo.Np
# Nt = self.geo.Nt
# assert self.geo.Np == Np
# assert self.geo.Nt == Nt
def test_get_indices_wildcard(self):
a = self.net._get_indices(element='pore', labels='ba*')
assert np.all(a == [6, 7, 8, 15, 16, 17, 24, 25, 26])
b = self.net._get_indices(element='pore', labels='*ck')
assert np.all(a == b)
def test_write_dict(self):
self.net['pore.test_dict'] = {'test1': 1, 'test2': self.net.Ps}
assert 'pore.test_dict.test1' in self.net.keys()
assert self.net['pore.test_dict.test1'].shape == (self.net.Np, )
assert 'pore.test_dict.test2' in self.net.keys()
# def test_map_pores(self):
# a = self.geo21['pore._id']
# b = self.geo22['pore._id']
# assert a.size == self.geo21.Np
# assert b.size == self.geo22.Np
# assert ~np.any(np.in1d(a, b))
# Pgeo21 = self.net2.map_pores(pores=self.geo21.Ps, origin=self.geo21)
# assert np.all(Pgeo21 == self.net2.pores(self.geo21.name))
# Pgeo22 = self.net2.map_pores(pores=self.geo22.Ps, origin=self.geo22)
# assert np.all(Pgeo22 == self.net2.pores(self.geo22.name))
# def test_map_throats(self):
# a = self.geo21['throat._id']
# assert a.size == self.geo21.Nt
# Tgeo21 = self.net2.map_throats(throats=self.geo21.Ts,
# origin=self.geo21)
# assert np.all(Tgeo21 == self.net2.throats(self.geo21.name))
# def test_map_pores_unfiltered(self):
# b = self.net.map_pores(pores=self.geo.Ps, origin=self.geo,
# filtered=False)
# assert np.all(b.indices == self.net.pores(self.geo.name))
# assert b.mask.size == self.geo.Np
# def test_map_pores_unfiltered_missing(self):
# Ps = self.net2.Ps[15:20]
# b = self.geo22.map_pores(pores=Ps, origin=self.net2, filtered=False)
# assert sum(b.mask) == 2
# assert len(b.mask) == 5
# def test_map_pores_reverse(self):
# Ps = self.net2.Ps[:5]
# b = self.geo21.map_pores(pores=Ps, origin=self.net2)
# assert np.all(b == [0, 1, 2, 3, 4])
# Ps = self.net2.Ps[-5:]
# b = self.geo22.map_pores(pores=Ps, origin=self.net2)
# assert np.all(b == [4, 5, 6, 7, 8])
# def test_map_pores_missing(self):
# Ps = self.net2.Ps[:5]
# b = self.geo22.map_pores(pores=Ps, origin=self.net2)
# assert len(b) == 0
# def test_getitem_with_no_matches(self):
# self.geo.pop('pore.blah', None)
# with pytest.raises(KeyError):
# _ = self.geo['pore.blah']
def test_getitem_with_numeric_value(self):
assert self.net[44] == 44
assert self.net[44.4] == 44.4
assert self.net[4j] == 4j
# def test_interpolate_data(self):
# self.geo['throat.tester'] = np.linspace(0, 1.0, self.geo.network.Nt)
# self.geo['pore.tester'] = np.linspace(0, 1.0, self.geo.network.Np)
# a = self.geo.interpolate_data(propname='throat.tester')
# assert a.size == self.geo.Np
# assert np.isclose(a.mean(), 0.5)
# a = self.geo.interpolate_data(propname='pore.tester')
# assert a.size == self.geo.Nt
# assert np.isclose(a.mean(), 0.5)
def test_get_string(self):
a = self.net.get('pore.coords')
assert a.shape == (self.net.Np, 3)
def test_subdict_getitem_on_network_from_network(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn['pore.foo.bar'] = 1
pn['pore.foo.baz'] = 2
d = pn['pore.foo']
assert len(d) == 2
assert 'bar' in d.keys()
assert 'baz' in d.keys()
def test_subdict_lookup_errors(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn['pore.foo.bar'] = 1
pn['pore.foo.baz'] = 2
with pytest.raises(KeyError):
_ = pn['pore.foo.b']
with pytest.raises(KeyError):
_ = pn['pore.fo']
def test_set_label_add_to_pores(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', pores=[1, 2])
assert pn['pore.tester'].sum() == 2
def test_set_label_add_to_throats(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', throats=[1, 2])
assert pn['throat.tester'].sum() == 2
def test_set_label_overwrite_on_pores(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', pores=[1, 2])
pn.set_label(label='tester', pores=[2, 3, 4], mode='overwrite')
assert pn['pore.tester'].sum() == 3
def test_set_label_overwrite_on_throats(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', throats=[1, 2])
pn.set_label(label='tester', throats=[2, 3, 4], mode='overwrite')
assert pn['throat.tester'].sum() == 3
def test_set_label_remove_from_pores(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', pores=[1, 2])
assert pn['pore.tester'].sum() == 2
pn.set_label(label='tester', pores=[1, 2, 3], mode='remove')
assert pn['pore.tester'].sum() == 0
def test_set_label_remove_from_throats(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', throats=[1, 2])
assert pn['throat.tester'].sum() == 2
pn.set_label(label='tester', throats=[1, 2, 3], mode='remove')
assert pn['throat.tester'].sum() == 0
def test_set_label_purge_from_pores(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', pores=[1, 2])
assert pn['pore.tester'].sum() == 2
pn.set_label(label='tester', mode='purge')
assert 'pore.tester' not in pn.keys()
def test_set_label_purge_from_throats(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', throats=[1, 2])
assert pn['throat.tester'].sum() == 2
pn.set_label(label='tester', mode='purge')
assert 'throat.tester' not in pn.keys()
def test_set_label_purge_nonexistent_label(self):
pn = op.network.Cubic(shape=[5, 5, 5])
pn.set_label(label='tester', mode='purge')
# Should only issue warning
def test_renaming_to_current_name_is_allowed(self):
obj = op.core.Base2(name="temp")
obj.name = "temp"
def test_get_conduit_data(self):
pn = op.network.Cubic(shape=[3, 3, 3])
pn['pore.diameter'] = 2.0
pn['throat.diameter'] = 2.0
a = pn.get_conduit_data('diameter')
assert np.all(a.shape == (54, 3))
assert a.sum() == np.prod(a.shape)*2.0
pn['pore.volume'] = 2.0
pn['throat.volume'] = 2.0
b = pn.get_conduit_data('volume')
assert np.all(b.shape == (54, 3))
assert b.sum() == 2*np.prod(b.shape)
with pytest.raises(KeyError):
pn.get_conduit_data('blah')
if __name__ == '__main__':
t = BaseTest()
self = t
t.setup_class()
for item in t.__dir__():
if item.startswith('test'):
print(f"Running test: {item}")
t.__getattribute__(item)()