def test_model_update_insert_component_on_conduit() -> None:
macro = Component('macro', 'my.macro')
micro = Component('micro', 'my.micro')
components = [macro, micro]
conduit1 = Conduit('macro.intermediate_state', 'micro.initial_state')
conduit2 = Conduit('micro.final_state', 'macro.state_update')
conduits = [conduit1, conduit2]
base = Model('test_update', components, conduits)
tee = Component('tee', 'muscle3.tee')
conduit3 = Conduit('macro.intermediate_state', 'tee.input')
conduit4 = Conduit('tee.output', 'micro.initial_state')
overlay = Model('test_update_tee', [tee], [conduit3, conduit4])
base.update(overlay)
assert len(base.components) == 3
assert macro in base.components
assert micro in base.components
assert tee in base.components
assert len(base.conduits) == 3
assert conduit2 in base.conduits
assert conduit3 in base.conduits
assert conduit4 in base.conduits
def test_connect() -> None:
ref = Reference
instance_id = Reference('kernel')
conduits = [
Conduit('kernel.out', 'other.in'),
Conduit('other.out', 'kernel.in')
]
peer_dims = {ref('other'): [1]}
peer_locations = {ref('other'): ['direct:test']}
with patch('libmuscle.communicator.PeerManager') as pm_init:
communicator = Communicator(instance_id, [13], None, MagicMock())
communicator.connect(conduits, peer_dims, peer_locations)
pm_init.assert_called_with(instance_id, [13], conduits, peer_dims,
peer_locations)
# check inferred ports
ports = communicator._ports
communicator.shutdown()
assert ports['in'].name == Identifier('in')
assert ports['in'].operator == Operator.F_INIT
assert ports['in']._length is None
assert ports['out'].name == Identifier('out')
assert ports['out'].operator == Operator.O_F
assert ports['out']._length is None
def test_connect_inferred_ports(communicator) -> None:
ref = Reference
communicator._declared_ports = None
conduits = [
Conduit('other1.out', 'kernel.in'),
Conduit('kernel.out1', 'other.in'),
Conduit('kernel.out3', 'other2.in')
]
peer_dims = {ref('other1'): [20, 7], ref('other'): [25], ref('other2'): []}
peer_locations = {
ref('other'): ['direct:test'],
ref('other1'): ['direct:test1'],
ref('other2'): ['direct:test2']
}
communicator.connect(conduits, peer_dims, peer_locations)
ports = communicator._ports
assert ports['in'].name == Identifier('in')
assert ports['in'].operator == Operator.F_INIT
assert ports['in']._length == 7
assert ports['in']._is_resizable is False
assert ports['out1'].name == Identifier('out1')
assert ports['out1'].operator == Operator.O_F
assert ports['out1']._length is None
assert ports['out3'].name == Identifier('out3')
assert ports['out3'].operator == Operator.O_F
assert ports['out3']._length is None
def test_config5() -> Configuration:
model = Model(
'test_model',
[
Component('ic', 'isr2d.initial_conditions'),
Component('smc', 'isr2d.smc'),
Component('bf', 'isr2d.blood_flow'),
Component('smc2bf', 'isr2d.smc2bf'),
Component('bf2smc', 'isr2d.bf2smc')],
[
Conduit('ic.out', 'smc.initial_state'),
Conduit('smc.cell_positions', 'smc2bf.in'),
Conduit('smc2bf.out', 'bf.initial_domain'),
Conduit('bf.wss_out', 'bf2smc.in'),
Conduit('bf2smc.out', 'smc.wss_in')])
implementations = [
Implementation(
Reference('isr2d.initial_conditions'), 'isr2d/bin/ic'),
Implementation(
Reference('isr2d.smc'), 'isr2d/bin/smc'),
Implementation(
Reference('isr2d.blood_flow'), 'isr2d/bin/bf'),
Implementation(
Reference('isr2d.smc2bf'), 'isr2d/bin/smc2bf.py'),
Implementation(
Reference('isr2d.bf2smc'), 'isr2d/bin/bf2smc.py')]
resources = [
Resources(Reference('isr2d.initial_conditions'), 4),
Resources(Reference('isr2d.smc'), 4),
Resources(Reference('isr2d.blood_flow'), 4),
Resources(Reference('isr2d.smc2bf'), 1),
Resources(Reference('isr2d.bf2smc'), 1)]
return Configuration(model, None, implementations, resources)
def macro_micro() -> Model:
macro = Component('macro', 'my.macro')
micro = Component('micro', 'my.micro')
components = [macro, micro]
conduit1 = Conduit('macro.intermediate_state', 'micro.initial_state')
conduit2 = Conduit('micro.final_state', 'macro.state_update')
conduits = [conduit1, conduit2]
return Model('macro_micro', components, conduits)
def topology_store() -> TopologyStore:
config = Configuration(
Model(
'test_model',
[
ComputeElement('macro', 'macro_implementation'),
ComputeElement(
'micro', 'micro_implementation', [10, 10])],
[
Conduit('macro.out', 'micro.in'),
Conduit('micro.out', 'macro.in')
]))
return TopologyStore(config)
def test_dump_model(dump_model: Callable) -> None:
ce1 = Component('ce1', 'test.impl1')
ce2 = Component('ce2', 'test.impl2')
cd1 = Conduit('ce1.state_out', 'ce2.init_in')
cd2 = Conduit('ce2.fini_out', 'ce1.boundary_in')
model = Model('test_model', [ce1, ce2], [cd1, cd2])
text = dump_model(model)
assert text == ('name: test_model\n'
'components:\n'
' ce1: test.impl1\n'
' ce2: test.impl2\n'
'conduits:\n'
' ce1.state_out: ce2.init_in\n'
' ce2.fini_out: ce1.boundary_in\n')
def test_config2() -> PartialConfiguration:
model = Model(
'test_model',
[
Component('ic', 'isr2d.initial_conditions'),
Component('smc', 'isr2d.smc'),
Component('bf', 'isr2d.blood_flow'),
Component('smc2bf', 'isr2d.smc2bf'),
Component('bf2smc', 'isr2d.bf2smc')],
[
Conduit('ic.out', 'smc.initial_state'),
Conduit('smc.cell_positions', 'smc2bf.in'),
Conduit('smc2bf.out', 'bf.initial_domain'),
Conduit('bf.wss_out', 'bf2smc.in'),
Conduit('bf2smc.out', 'smc.wss_in')])
return PartialConfiguration(model)
def test_model_update_add_component() -> None:
macro = Component('macro', 'my.macro')
base = Model('test_update', [macro])
micro = Component('micro', 'my.micro')
conduit1 = Conduit('macro.intermediate_state', 'micro.initial_state')
conduit2 = Conduit('micro.final_state', 'macro.state_update')
conduits = [conduit1, conduit2]
overlay = Model('test_update_add', [micro], conduits)
base.update(overlay)
assert len(base.components) == 2
assert macro in base.components
assert micro in base.components
assert conduit1 in base.conduits
assert conduit2 in base.conduits
def test_wiring(log_file_in_tmpdir, mmp_server_process):
client = MMPClient('localhost:9000')
client.register_instance(Reference('macro'), ['direct:macro'], [])
conduits, peer_dims, peer_locations = client.request_peers(
Reference('micro[0]'))
assert Conduit('macro.out', 'micro.in') in conduits
assert Conduit('micro.out', 'macro.in') in conduits
assert peer_dims[Reference('macro')] == []
assert peer_locations['macro'] == ['direct:macro']
with patch('libmuscle.mmp_client.PEER_TIMEOUT', 0.1), \
patch('libmuscle.mmp_client.PEER_INTERVAL_MIN', 0.01), \
patch('libmuscle.mmp_client.PEER_INTERVAL_MAX', 0.1):
with pytest.raises(RuntimeError):
client.request_peers(Reference('macro'))
for i in range(5):
instance = Reference('micro[{}]'.format(i))
location = 'direct:{}'.format(instance)
client.register_instance(instance, [location], [])
with patch('libmuscle.mmp_client.PEER_TIMEOUT', 0.1), \
patch('libmuscle.mmp_client.PEER_INTERVAL_MIN', 0.01), \
patch('libmuscle.mmp_client.PEER_INTERVAL_MAX', 0.1):
with pytest.raises(RuntimeError):
client.request_peers(Reference('macro'))
for i in range(5, 10):
instance = Reference('micro[{}]'.format(i))
location = 'direct:{}'.format(instance)
client.register_instance(instance, [location], [])
conduits, peer_dims, peer_locations = client.request_peers(
Reference('macro'))
assert Conduit('macro.out', 'micro.in') in conduits
assert Conduit('micro.out', 'macro.in') in conduits
assert peer_dims[Reference('micro')] == [10]
assert peer_locations['micro[7]'] == ['direct:micro[7]']
def conduit_from_grpc(conduit: mmp.Conduit) -> Conduit:
"""Converts a Conduit from grpc to ymmsl.
Args:
conduit: A conduit.
Returns:
The same conduit, as ymmsl.Conduit.
"""
return Conduit(conduit.sender, conduit.receiver)
def test_connect_multidimensional_ports(communicator) -> None:
ref = Reference
communicator._declared_ports = {Operator.F_INIT: ['in[][]']}
conduits = [Conduit(ref('other.out'), ref('kernel.in'))]
peer_dims = {ref('other'): [20, 7, 30]}
peer_locations = {ref('other'): ['direct:test']}
with pytest.raises(ValueError):
communicator.connect(conduits, peer_dims, peer_locations)
def test_model_update_replace_component() -> None:
macro = Component('macro', 'my.macro')
micro = Component('micro', 'my.micro')
components = [macro, micro]
conduit1 = Conduit('macro.intermediate_state', 'micro.initial_state')
conduit2 = Conduit('micro.final_state', 'macro.state_update')
conduits = [conduit1, conduit2]
base = Model('test_update', components, conduits)
surrogate = Component('micro', 'my.surrogate')
overlay = Model('test_update_surrogate', [surrogate])
base.update(overlay)
assert len(base.components) == 2
assert macro in base.components
assert surrogate in base.components
assert len(base.conduits) == 2
assert conduit1 in base.conduits
assert conduit2 in base.conduits
def test_duplication_mapper(log_file_in_tmpdir):
"""A positive all-up test of duplication mappers.
This is an acyclic workflow.
"""
elements = [
ComputeElement('dm', 'muscle.duplication_mapper'),
ComputeElement('first', 'receiver'),
ComputeElement('second', 'receiver')
]
conduits = [Conduit('dm.out', 'first.in'), Conduit('dm.out2', 'second.in')]
model = Model('test_model', elements, conduits)
settings = Settings()
configuration = Configuration(model, settings)
implementations = {
'muscle.duplication_mapper': duplication_mapper,
'receiver': receiver
}
run_simulation(configuration, implementations)
def test_all(log_file_in_tmpdir):
"""A positive all-up test of everything.
"""
elements = [
ComputeElement('macro', 'macro_impl'),
ComputeElement('micro', 'micro_impl', [10])
]
conduits = [
Conduit('macro.out', 'micro.in'),
Conduit('micro.out', 'macro.in')
]
model = Model('test_model', elements, conduits)
settings = Settings(
OrderedDict([('test1', 13), ('test2', 13.3), ('test3', 'testing'),
('test4', True), ('test5', [2.3, 5.6]),
('test6', [[1.0, 2.0], [3.0, 1.0]])]))
configuration = Configuration(model, settings)
implementations = {'macro_impl': macro, 'micro_impl': micro}
run_simulation(configuration, implementations)
def test_settings_overlays(log_file_in_tmpdir):
"""A positive all-up test of settings overlays.
"""
elements = [
ComputeElement('qmc', 'qmc'),
ComputeElement('macro', 'macro', [10]),
ComputeElement('relay', 'explicit_relay'),
ComputeElement('relay2', 'explicit_relay'),
ComputeElement('micro', 'micro', [10])]
conduits = [
Conduit('qmc.settings_out', 'macro.muscle_settings_in'),
Conduit('macro.out', 'relay.in'),
Conduit('relay.out', 'micro.in'),
Conduit('micro.out', 'relay2.in'),
Conduit('relay2.out', 'macro.in')]
model = Model('test_model', elements, conduits)
settings = Settings(OrderedDict([
('test1', 13),
('test2', 13.3),
('test3', 'testing'),
('test4', True),
('test5', [2.3, 5.6]),
('test6', [[1.0, 2.0], [3.0, 1.0]])]))
configuration = Configuration(model, settings)
implementations = {
'qmc': qmc,
'macro': macro,
'explicit_relay': explicit_relay,
'micro': micro}
run_simulation(configuration, implementations)
cbar = plt.colorbar()
cbar.set_label('log(Concentration)', rotation=270, labelpad=20)
plt.xlabel('x')
plt.ylabel('t (ms)')
plt.title('Concentration over time')
plt.show()
if __name__ == '__main__':
elements = [
ComputeElement('macro', 'diffusion'),
ComputeElement('micro', 'reaction')
]
conduits = [
Conduit('macro.state_out', 'micro.initial_state'),
Conduit('micro.final_state', 'macro.state_in')
]
model = Model('reaction_diffusion', elements, conduits)
settings = Settings(
OrderedDict([
('micro.t_max', 2.469136e-6),
('micro.dt', 2.469136e-8),
('macro.t_max', 1.234568e-4),
('macro.dt', 2.469136e-6),
('x_max', 1.01),
('dx', 0.01),
('k', -4.05e4), # reaction parameter
('d', 4.05e-2) # diffusion parameter
]))
def test_conduit_to_grpc() -> None:
conduit = Conduit(Reference('kernel1.out'), Reference('kernel2.in'))
mmp_conduit = conduit_to_grpc(conduit)
assert mmp_conduit.sender == 'kernel1.out'
assert mmp_conduit.receiver == 'kernel2.in'
# get in n_samples input values from EasyVVUQ
feed = []
kill = []
for i in range(n_samples):
feed.append(float(inputs['feed' + str(i)]))
kill.append(float(inputs['kill' + str(i)]))
feed = np.array(feed)
kill = np.array(kill)
# Compute elements for the macro and micro model: specify the name of the python file here
elements = [ComputeElement('macro', 'macro', [n_samples]),
ComputeElement('micro', 'micro', [n_samples])]
# connect the submodels
conduits = [Conduit('macro.state_out', 'micro.state'),
Conduit('micro.sgs', 'macro.state_in')]
# create model instance
model = Model('gray_scott_reduced', elements, conduits)
# common settings
settings_dict = {'micro.t_max': 0.1, 'micro.dt': 0.1, 'N_Q': 2, 'N_LF': 128}
# parameter value settings, differs per run
for i in range(n_samples):
settings_dict['macro[%d].feed' % i] = feed[i]
settings_dict['macro[%d].kill' % i] = kill[i]
settings = Settings(settings_dict)
configuration = Configuration(model, settings)
cbar.set_label('log(Concentration)', rotation=270, labelpad=20)
plt.xlabel('x')
plt.ylabel('Sample')
plt.title('Final states')
plt.show()
if __name__ == '__main__':
elements = [
ComputeElement('qmc', 'qmc_driver'),
ComputeElement('rr', 'load_balancer'),
ComputeElement('macro', 'diffusion', [10]),
ComputeElement('micro', 'reaction', [10])]
conduits = [
Conduit('qmc.parameters_out', 'rr.front_in'),
Conduit('rr.front_out', 'qmc.states_in'),
Conduit('rr.back_out', 'macro.muscle_settings_in'),
Conduit('macro.final_state_out', 'rr.back_in'),
Conduit('macro.state_out', 'micro.initial_state'),
Conduit('micro.final_state', 'macro.state_in')
]
model = Model('reaction_diffusion_qmc', elements, conduits)
settings = Settings(OrderedDict([
('micro.t_max', 2.469136e-6),
('micro.dt', 2.469136e-8),
('macro.t_max', 1.234568e-4),
('macro.dt', 2.469136e-6),
('qmc.t_max', 1.234568e-4),
('qmc.dt', 2.469136e-6),
from libmuscle.runner import run_simulation
from ymmsl import ComputeElement, Conduit, Configuration, Model, Settings
# load the macro and micro model
from micro import reduced_sgs
from macro import gray_scott_macro
# Compute elements for the macro and micro model: specify the name of the python file here
elements = [
ComputeElement('macro', 'macro', [1]),
ComputeElement('micro', 'micro', [1])
]
# connect the submodels
conduits = [
Conduit('macro.state_out', 'micro.state_in'),
Conduit('micro.sgs_out', 'macro.sgs_in')
]
# create model instance
model = Model('gray_scott_reduced', elements, conduits)
# settings
settings = Settings({
'micro.t_max': 0.5,
'micro.dt': 0.5,
'N_Q': 2,
'N_LF': 128,
'macro[0].feed': 0.02,
'macro[0].kill': 0.05,
})
def test_conduit() -> None:
test_conduit = Conduit('submodel1.port1', 'submodel2.port2')
assert str(test_conduit.sender[0]) == 'submodel1'
assert str(test_conduit.sender[1]) == 'port1'
assert str(test_conduit.receiver[0]) == 'submodel2'
assert str(test_conduit.receiver[1]) == 'port2'
assert str(test_conduit.sending_component()) == 'submodel1'
assert str(test_conduit.sending_port()) == 'port1'
assert test_conduit.sending_slot() == []
assert str(test_conduit.receiving_component()) == 'submodel2'
assert str(test_conduit.receiving_port()) == 'port2'
assert test_conduit.receiving_slot() == []
with pytest.raises(ValueError):
Conduit('x', 'submodel1.port1')
with pytest.raises(ValueError):
Conduit('x[3].y.z', 'submodel1.port1')
with pytest.raises(ValueError):
Conduit('x[3]', 'submodel1.port1')
test_conduit2 = Conduit('submodel1.port1', 'submodel2.port2')
assert test_conduit == test_conduit2
assert 'Conduit' in str(test_conduit)
assert 'submodel1.port1' in str(test_conduit)
assert 'submodel2.port2' in str(test_conduit)
test_conduit4 = Conduit('x.y[1][2]', 'a.b[3]')
assert test_conduit4.sender[2] == 1
assert test_conduit4.sender[3] == 2
assert str(test_conduit4.sending_component()) == 'x'
assert str(test_conduit4.sending_port()) == 'y'
assert test_conduit4.sending_slot() == [1, 2]
assert test_conduit4.receiver[2] == 3
assert str(test_conduit4.receiving_component()) == 'a'
assert str(test_conduit4.receiving_port()) == 'b'
assert test_conduit4.receiving_slot() == [3]
