def test_remove():
name = model.name()
assert name in client.names()
client.remove(model)
assert name not in client.names()
assert 'empty' in client.names()
client.remove('empty')
assert 'empty' not in client.names()
message = ''
try:
model.java.component()
except Exception as error:
message = error.getMessage()
assert 'no_longer_in_the_model' in message
with logging_disabled():
try:
client.remove(model)
except ValueError:
pass
try:
client.remove('non-existing')
except ValueError:
pass
try:
client.remove(True)
except TypeError:
pass
def test_parameter():
value = model.parameter('U')
model.parameter('U', '2[V]')
assert model.parameter('U') == '2[V]'
model.parameter('U', '2')
assert model.parameter('U') == '2'
assert model.parameter('U', evaluate=True) == 2
model.parameter('U', 3)
assert model.parameter('U') == '3'
assert model.parameter('U', evaluate=True) == 3
model.parameter('U', 1 + 1j)
assert model.parameter('U') == '(1+1j)'
assert model.parameter('U', evaluate=True) == 1 + 1j
with logging_disabled():
try:
model.parameter('non-existing')
except ValueError:
pass
try:
model.parameter('non-existing', evaluate=True)
except RuntimeError:
pass
with warnings_disabled():
model.parameter('U', '1', 'V')
assert model.parameter('U') == '1 [V]'
model.parameter('U', description='applied voltage')
model.parameter('U', value)
assert model.parameter('U') == value
def test_inner():
(indices, values) = model.inner('time-dependent')
assert indices.dtype.kind == 'i'
assert values.dtype.kind == 'f'
assert (indices == list(range(1, 102))).all()
assert values[0] == 0
assert values[-1] == 1
assert model.inner('datasets/time-dependent')
assert model.inner(model / 'datasets' / 'time-dependent')
with logging_disabled():
try:
model.inner('non-existing')
except ValueError:
pass
try:
model.inner(False)
except TypeError:
pass
no_solution = (model / 'datasets').create('CutPoint2D')
no_solution.property('data', 'none')
try:
model.inner(no_solution)
except RuntimeError:
pass
no_solution.remove()
def test_start():
with logging_disabled():
try:
mph.option('session', 'invalid')
mph.start()
except ValueError:
pass
mph.option('session', 'client-server')
client = mph.start(cores=1)
assert client.java is not None
assert client.cores == 1
with logging_disabled():
try:
mph.start()
except NotImplementedError:
pass
def test_truediv():
assert Node(model, 'functions')/'step' == Node(model, 'functions/step')
with logging_disabled():
try:
Node(model, 'functions')/False
except TypeError:
pass
def test_disconnect():
client.disconnect()
assert client.host is None
assert client.port is None
with logging_disabled():
try:
client.models()
except Exception:
pass
def test_truediv():
assert (model / 'functions').name() == 'functions'
node = model / 'functions' / 'step'
assert (model / node).name() == 'step'
assert (model / None).is_root()
with logging_disabled():
try:
model / False
except TypeError:
pass
def test_features():
with warnings_disabled():
assert 'Laplace equation' in model.features('electrostatic')
assert 'zero charge' in model.features('electrostatic')
assert 'initial values' in model.features('electrostatic')
assert 'anode' in model.features('electrostatic')
assert 'cathode' in model.features('electrostatic')
with logging_disabled():
try:
model.features('non-existing')
except LookupError:
pass
def test_run():
study = Node(model, 'studies/static')
solution = Node(model, 'solutions/electrostatic solution')
assert solution.java.isEmpty()
study.run()
assert not solution.java.isEmpty()
with logging_disabled():
try:
Node(model, 'functions/non-existing').run()
except LookupError:
pass
try:
Node(model, 'functions').run()
except RuntimeError:
pass
def test_init():
node = Node(model, '')
assert node.model == model
node = Node(model, 'functions')
assert node.model == model
assert 'function' in node.alias
assert 'functions' in node.alias.values()
assert 'functions' in node.groups
assert 'self.model.java.func()' in node.groups.values()
Node(model, node)
with logging_disabled():
try:
Node(model, False)
except TypeError:
pass
def test_start():
if system() != 'Windows':
return
client = mph.start(cores=1)
assert client.java is not None
assert client.cores == 1
with logging_disabled():
try:
mph.start()
except NotImplementedError:
pass
try:
client.disconnect()
except RuntimeError:
pass
def test_truediv():
assert client / 'capacitor' == model
with logging_disabled():
try:
client / 'non-existing'
except ValueError:
pass
try:
client / model
except TypeError:
pass
try:
client / False
except TypeError:
pass
def test_option():
assert 'session' in mph.option()
assert 'platform-dependent' in mph.option().values()
assert mph.option('session') == 'platform-dependent'
mph.option('session', 'something else')
assert mph.option('session') == 'something else'
mph.option('session', 'platform-dependent')
with logging_disabled():
try:
mph.option('non-existing')
except LookupError:
pass
try:
mph.option('non-existing', 'assigned value')
except LookupError:
pass
def test_init():
global client
if mph.option('session') == 'platform-dependent':
mph.option('session', 'client-server')
client = mph.start(cores=1)
assert client.java is not None
assert client.cores == 1
with logging_disabled():
try:
mph.start()
except NotImplementedError:
pass
try:
mph.Client()
except NotImplementedError:
pass
def test_caching():
assert not client.caching()
copy = client.load(demo)
assert model != copy
client.remove(copy)
client.caching(True)
assert client.caching()
copy = client.load(demo)
assert model == copy
client.caching(False)
assert not client.caching()
with logging_disabled():
try:
client.caching('anything else')
except ValueError:
pass
def test_load():
with warnings_disabled():
image = model.create('functions/image', 'Image')
image.property('funcname', 'im')
image.property('fununit', '1/m^2')
image.property('xmin', -5)
image.property('xmax', +5)
image.property('ymin', -5)
image.property('ymax', +5)
image.property('extrap', 'value')
model.load('gaussian.tif', 'image')
model.remove('functions/image')
with logging_disabled():
try:
model.load('image.png', 'non-existing')
except LookupError:
pass
def test_toggle():
node = Node(model, 'functions/step')
assert node.java.isActive()
node.toggle()
assert not node.java.isActive()
node.toggle()
assert node.java.isActive()
node.toggle('off')
assert not node.java.isActive()
node.toggle('on')
assert node.java.isActive()
assert not Node(model, 'functions/non-existing').exists()
with logging_disabled():
try:
Node(model, 'functions/non-existing').toggle()
except LookupError:
pass
def test_create():
functions = Node(model, 'functions')
functions.create('Analytic')
assert (functions/'Analytic 1').exists()
functions.create('Analytic', name='f')
assert (functions/'f').exists()
geometry = Node(model, 'geometries/geometry')
physics = Node(model, 'physics')
physics.create('Electrostatics', geometry)
with logging_disabled():
try:
Node(model, '').create()
except PermissionError:
pass
try:
Node(model, 'components/component').create()
except RuntimeError:
pass
def test_retag():
with logging_disabled():
try:
Node(model, '').retag('something')
except PermissionError:
pass
try:
Node(model, 'functions').retag('something')
except PermissionError:
pass
try:
Node(model, 'functions/non-existing').retag('something')
except Exception:
pass
node = Node(model, 'functions/step')
old = node.tag()
node.retag('new')
assert node.tag() == 'new'
node.retag(old)
assert node.tag() == old
def test_rename():
with logging_disabled():
try:
Node(model, '').rename('something')
except PermissionError:
pass
try:
Node(model, 'functions').rename('something')
except PermissionError:
pass
node = Node(model, 'functions/step')
name = node.name()
renamed = Node(model, 'functions/renamed')
assert not renamed.exists()
node.rename('renamed')
assert node.exists()
assert renamed.exists()
node.rename(name)
assert node.exists()
assert not renamed.exists()
def test_export():
here = Path(__file__).resolve().parent
assert not (here / 'data.txt').exists()
model.export('data', here / 'data.txt')
assert (here / 'data.txt').exists()
(here / 'data.txt').unlink()
assert not (here / 'data.txt').exists()
model.export('exports/data')
assert (here / 'data.txt').exists()
(here / 'data.txt').unlink()
assert not (here / 'data.txt').exists()
model.export(model / 'exports' / 'data')
assert (here / 'data.txt').exists()
(here / 'data.txt').unlink()
assert not (here / 'data.txt').exists()
model.property('exports/data', 'exporttype', 'text')
model.export('exports/data', here / 'data.txt')
assert (here / 'data.txt').exists()
(here / 'data.txt').unlink()
assert not (here / 'data.vtu').exists()
model.property('exports/data', 'exporttype', 'vtu')
model.export('exports/data', here / 'data.vtu')
assert (here / 'data.vtu').exists()
(here / 'data.vtu').unlink()
assert not (here / 'image.png').exists()
model.export('image', here / 'image.png')
assert (here / 'image.png').exists()
(here / 'image.png').unlink()
assert not (here / 'image.png').exists()
model.export()
assert (here / 'data.vtu').exists()
assert (here / 'image.png').exists()
(here / 'data.vtu').unlink()
(here / 'image.png').unlink()
assert not (here / 'data.vtu').exists()
assert not (here / 'image.png').exists()
with logging_disabled():
try:
model.export('non-existing')
except ValueError:
pass
def test_build():
model.build()
model.build('geometry')
model.build(model / 'geometries' / 'geometry')
with logging_disabled():
try:
model.build(model / 'function' / 'step')
except ValueError:
pass
try:
model.build('non-existing')
except LookupError:
pass
try:
model.build(False)
except TypeError:
pass
try:
empty.build()
except RuntimeError:
pass
def test_mesh():
model.mesh()
model.mesh('mesh')
model.mesh(model / 'meshes' / 'mesh')
with logging_disabled():
try:
model.mesh(model / 'function' / 'step')
except ValueError:
pass
try:
model.mesh('non-existing')
except LookupError:
pass
try:
model.mesh(False)
except TypeError:
pass
try:
empty.mesh()
except RuntimeError:
pass
def test_solve():
model.solve()
model.solve('static')
model.solve(model / 'studies' / 'static')
with logging_disabled():
try:
model.solve(model / 'function' / 'step')
except ValueError:
pass
try:
model.solve('non-existing')
except LookupError:
pass
try:
model.solve(False)
except TypeError:
pass
try:
empty.solve()
except RuntimeError:
pass
def test_save():
here = Path(__file__).resolve().parent
model.save()
empty.save(format='java')
assert Path(f'{model}.mph').exists()
assert Path(f'{empty}.java').exists()
Path(f'{empty}.java').unlink()
model.save(here)
model.save(here, format='java')
assert (here / f'{model}.mph').exists()
assert (here / f'{model}.java').exists()
(here / f'{model}.java').unlink()
model.save(here / 'model.mph')
model.save()
assert (here / 'model.mph').read_text(errors='ignore').startswith('PK')
model.save(here / 'model.java')
assert (here / 'model.java').exists()
assert 'public static void main' in (here / 'model.java').read_text()
(here / 'model.java').unlink()
assert not (here / 'model.java').exists()
model.save(format='java')
assert (here / 'model.java').exists()
(here / 'model.java').unlink()
model.save(here / 'model.m')
assert (here / 'model.m').exists()
assert 'function out = model' in (here / 'model.m').read_text()
(here / 'model.m').unlink()
model.save(here / 'model.vba')
assert (here / 'model.vba').exists()
assert 'Sub run()' in (here / 'model.vba').read_text()
(here / 'model.vba').unlink()
with logging_disabled():
try:
model.save('model.invalid')
except ValueError:
pass
try:
model.save('model.mph', format='invalid')
except ValueError:
pass
def test_remove():
if system() != 'Windows':
return
client = mph.session.client
model = client.create('empty')
assert 'empty' in client.names()
assert model in client.models()
(model/'components').create(True)
client.remove(model)
assert 'empty' not in client.names()
assert model not in client.models()
message = ''
try:
model.java.component()
except Exception as error:
message = error.getMessage()
assert 'is_removed' in message
with logging_disabled():
try:
client.remove(model)
except ValueError:
pass
def test_toggle():
with warnings_disabled():
model.solve('static')
assert abs(model.evaluate('V_es').mean()) < 0.1
model.toggle('electrostatic', 'cathode')
model.solve('static')
assert abs(model.evaluate('V_es').mean() - 0.5) < 0.1
model.toggle('electrostatic', 'cathode', 'on')
model.solve('static')
assert abs(model.evaluate('V_es').mean()) < 0.1
model.toggle('electrostatic', 'cathode', 'off')
model.solve('static')
assert abs(model.evaluate('V_es').mean() - 0.5) < 0.1
with logging_disabled():
try:
model.toggle('non-existing', 'feature')
except LookupError:
pass
try:
model.toggle('electrostatic', 'non-existing')
except LookupError:
pass
def test_cast():
bool_array_1d = array([True, False])
bool_array_2d = array([[True, False], [False, True]])
assert node.cast(bool_array_1d).__class__.__name__ == 'boolean[]'
assert node.cast(bool_array_2d).__class__.__name__ == 'boolean[][]'
with logging_disabled():
try:
array3d = array([[[1,2], [3,4]], [[5,6], [7,8]]], dtype=object)
node.cast(array3d)
except TypeError:
pass
try:
three_rows = array([[1,2], [3,4], [5,6]], dtype=object)
node.cast(three_rows)
except TypeError:
pass
try:
node.cast(array([1+1j, 1-1j]))
except TypeError:
pass
try:
node.cast({1, 2, 3})
except TypeError:
pass
def test_remove():
functions = Node(model, 'functions')
assert (functions/'Analytic 1').exists()
(functions/'Analytic 1').remove()
assert not (functions/'Analytic 1').exists()
assert (functions/'f').exists()
(functions/'f').remove()
assert not (functions/'f').exists()
physics = Node(model, 'physics')
(physics/'Electrostatics 1').remove()
assert not (physics/'Electrostatics 1').exists()
with logging_disabled():
try:
Node(model, '').remove()
except PermissionError:
pass
try:
Node(model, 'function').remove()
except PermissionError:
pass
try:
Node(model, 'function/non-existing').remove()
except LookupError:
pass
def test_outer():
(indices, values) = model.outer('parametric sweep')
assert indices.dtype.kind == 'i'
assert values.dtype.kind == 'f'
assert (indices == list(range(1, 4))).all()
assert (values == (1.0, 2.0, 3.0)).all()
assert model.outer('datasets/parametric sweep')
assert model.outer(model / 'datasets' / 'parametric sweep')
with logging_disabled():
try:
model.outer('non-existing')
except ValueError:
pass
try:
model.outer(False)
except TypeError:
pass
no_solution = (model / 'datasets').create('CutPoint2D')
no_solution.property('data', 'none')
try:
model.outer(no_solution)
except RuntimeError:
pass
no_solution.remove()
