def test_filter_by_smiles():
"""A test to ensure that data sets may be filtered by which smiles their
measured properties contain."""
methanol_substance = Substance()
methanol_substance.add_component(Substance.Component('CO'), Substance.MoleFraction(1.0))
ethanol_substance = Substance()
ethanol_substance.add_component(Substance.Component('CCO'), Substance.MoleFraction(1.0))
property_a = create_dummy_property(Density)
property_a.substance = methanol_substance
property_b = create_dummy_property(Density)
property_b.substance = ethanol_substance
data_set = PhysicalPropertyDataSet()
data_set.properties[methanol_substance.identifier] = [property_a]
data_set.properties[ethanol_substance.identifier] = [property_b]
data_set.filter_by_smiles('CO')
assert data_set.number_of_properties == 1
assert methanol_substance.identifier in data_set.properties
assert ethanol_substance.identifier not in data_set.properties
def test_nested_input():
dummy_schema = WorkflowSchema()
dict_protocol = DummyInputOutputProtocol('dict_protocol')
dict_protocol.input_value = {'a': ThermodynamicState(temperature=1*unit.kelvin)}
dummy_schema.protocols[dict_protocol.id] = dict_protocol.schema
quantity_protocol = DummyInputOutputProtocol('quantity_protocol')
quantity_protocol.input_value = ProtocolPath('output_value[a].temperature', dict_protocol.id)
dummy_schema.protocols[quantity_protocol.id] = quantity_protocol.schema
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_workflow = Workflow(dummy_property, {})
dummy_workflow.schema = dummy_schema
with tempfile.TemporaryDirectory() as temporary_directory:
workflow_graph = WorkflowGraph(temporary_directory)
workflow_graph.add_workflow(dummy_workflow)
dask_local_backend = DaskLocalCluster(1, ComputeResources(1))
dask_local_backend.start()
results_futures = workflow_graph.submit(dask_local_backend)
assert len(results_futures) == 1
result = results_futures[0].result()
assert isinstance(result, CalculationLayerResult)
def test_group_replicators():
dummy_schema = WorkflowSchema()
replicator_id = 'replicator'
dummy_replicated_protocol = DummyInputOutputProtocol(f'dummy_$({replicator_id})')
dummy_replicated_protocol.input_value = ReplicatorValue(replicator_id)
dummy_group = ProtocolGroup('dummy_group')
dummy_group.add_protocols(dummy_replicated_protocol)
dummy_schema.protocols[dummy_group.id] = dummy_group.schema
dummy_protocol_single_value = DummyInputOutputProtocol(f'dummy_single_$({replicator_id})')
dummy_protocol_single_value.input_value = ProtocolPath('output_value', dummy_group.id,
dummy_replicated_protocol.id)
dummy_schema.protocols[dummy_protocol_single_value.id] = dummy_protocol_single_value.schema
dummy_protocol_list_value = AddValues(f'dummy_list')
dummy_protocol_list_value.values = ProtocolPath('output_value', dummy_group.id,
dummy_replicated_protocol.id)
dummy_schema.protocols[dummy_protocol_list_value.id] = dummy_protocol_list_value.schema
replicator = ProtocolReplicator(replicator_id)
replicator.template_values = [
EstimatedQuantity(1.0 * unit.kelvin, 1.0 * unit.kelvin, 'dummy_source'),
EstimatedQuantity(2.0 * unit.kelvin, 2.0 * unit.kelvin, 'dummy_source')
]
dummy_schema.replicators.append(replicator)
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_metadata = Workflow.generate_default_metadata(dummy_property,
'smirnoff99Frosst-1.1.0.offxml',
[])
dummy_workflow = Workflow(dummy_property, dummy_metadata, '')
dummy_workflow.schema = dummy_schema
assert len(dummy_workflow.protocols) == 4
assert dummy_workflow.protocols[dummy_group.id].protocols['dummy_0'].input_value == replicator.template_values[0]
assert dummy_workflow.protocols[dummy_group.id].protocols['dummy_1'].input_value == replicator.template_values[1]
assert dummy_workflow.protocols['dummy_single_0'].input_value == ProtocolPath('output_value',
dummy_group.id, 'dummy_0')
assert dummy_workflow.protocols['dummy_single_1'].input_value == ProtocolPath('output_value',
dummy_group.id, 'dummy_1')
assert len(dummy_workflow.protocols['dummy_list'].values) == 2
assert dummy_workflow.protocols['dummy_list'].values[0] == ProtocolPath('output_value', dummy_group.id, 'dummy_0')
assert dummy_workflow.protocols['dummy_list'].values[1] == ProtocolPath('output_value', dummy_group.id, 'dummy_1')
def test_simple_workflow_graph_with_groups():
dummy_schema = WorkflowSchema()
dummy_protocol_a = DummyEstimatedQuantityProtocol('protocol_a')
dummy_protocol_a.input_value = EstimatedQuantity(1 * unit.kelvin,
0.1 * unit.kelvin,
'dummy_source')
dummy_protocol_b = DummyEstimatedQuantityProtocol('protocol_b')
dummy_protocol_b.input_value = ProtocolPath('output_value',
dummy_protocol_a.id)
conditional_group = ConditionalGroup('conditional_group')
conditional_group.add_protocols(dummy_protocol_a, dummy_protocol_b)
condition = ConditionalGroup.Condition()
condition.right_hand_value = 2 * unit.kelvin
condition.type = ConditionalGroup.ConditionType.LessThan
condition.left_hand_value = ProtocolPath('output_value.value',
conditional_group.id,
dummy_protocol_b.id)
conditional_group.add_condition(condition)
dummy_schema.protocols[conditional_group.id] = conditional_group.schema
dummy_schema.final_value_source = ProtocolPath('output_value',
conditional_group.id,
dummy_protocol_b.id)
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_workflow = Workflow(dummy_property, {})
dummy_workflow.schema = dummy_schema
with tempfile.TemporaryDirectory() as temporary_directory:
workflow_graph = WorkflowGraph(temporary_directory)
workflow_graph.add_workflow(dummy_workflow)
dask_local_backend = DaskLocalClusterBackend(1, ComputeResources(1))
dask_local_backend.start()
results_futures = workflow_graph.submit(dask_local_backend)
assert len(results_futures) == 1
result = results_futures[0].result()
assert isinstance(result, CalculationLayerResult)
assert result.calculated_property.value == 1 * unit.kelvin
def test_base_layer():
properties_to_estimate = [
create_dummy_property(Density),
create_dummy_property(Density)
]
dummy_options = PropertyEstimatorOptions()
request = PropertyEstimatorServer.ServerEstimationRequest(
estimation_id=str(uuid.uuid4()),
queued_properties=properties_to_estimate,
options=dummy_options,
force_field_id='')
with tempfile.TemporaryDirectory() as temporary_directory:
with temporarily_change_directory(temporary_directory):
# Create a simple calculation backend to test with.
test_backend = DaskLocalCluster()
test_backend.start()
# Create a simple storage backend to test with.
test_storage = LocalFileStorage()
layer_directory = 'dummy_layer'
makedirs(layer_directory)
def dummy_callback(returned_request):
assert len(returned_request.estimated_properties) == 1
assert len(returned_request.exceptions) == 2
dummy_layer = DummyCalculationLayer()
dummy_layer.schedule_calculation(test_backend, test_storage,
layer_directory, request,
dummy_callback, True)
def test_physical_property_state_methods():
dummy_property = create_dummy_property(Density)
property_state = dummy_property.__getstate__()
recreated_property = Density()
recreated_property.__setstate__(property_state)
recreated_state = recreated_property.__getstate__()
original_json = json.dumps(property_state, cls=TypedJSONEncoder)
recreated_json = json.dumps(recreated_state, cls=TypedJSONEncoder)
assert original_json == recreated_json
def test_nested_replicators():
dummy_schema = WorkflowSchema()
dummy_protocol = DummyReplicableProtocol('dummy_$(rep_a)_$(rep_b)')
dummy_protocol.replicated_value_a = ReplicatorValue('rep_a')
dummy_protocol.replicated_value_b = ReplicatorValue('rep_b')
dummy_schema.protocols[dummy_protocol.id] = dummy_protocol.schema
replicator_a = ProtocolReplicator(replicator_id='rep_a')
replicator_a.template_values = ['a', 'b']
replicator_b = ProtocolReplicator(replicator_id='rep_b')
replicator_b.template_values = [1, 2]
dummy_schema.replicators = [
replicator_a,
replicator_b
]
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_metadata = Workflow.generate_default_metadata(dummy_property,
'smirnoff99Frosst-1.1.0.offxml',
[])
dummy_workflow = Workflow(dummy_property, dummy_metadata, '')
dummy_workflow.schema = dummy_schema
assert len(dummy_workflow.protocols) == 4
assert dummy_workflow.protocols['dummy_0_0'].replicated_value_a == 'a'
assert dummy_workflow.protocols['dummy_0_1'].replicated_value_a == 'a'
assert dummy_workflow.protocols['dummy_1_0'].replicated_value_a == 'b'
assert dummy_workflow.protocols['dummy_1_1'].replicated_value_a == 'b'
assert dummy_workflow.protocols['dummy_0_0'].replicated_value_b == 1
assert dummy_workflow.protocols['dummy_0_1'].replicated_value_b == 2
assert dummy_workflow.protocols['dummy_1_0'].replicated_value_b == 1
assert dummy_workflow.protocols['dummy_1_1'].replicated_value_b == 2
print(dummy_workflow.schema)
def test_cloned_schema_merging_simulation(registered_property_name,
available_layer):
"""Tests that two, the exact the same, calculations get merged into one
by the `WorkflowGraph`."""
registered_property = registered_properties[registered_property_name]
substance = Mixture()
substance.add_component('C', 1.0)
dummy_property = create_dummy_property(registered_property)
workflow_schema = dummy_property.get_default_workflow_schema(
available_layer, PropertyWorkflowOptions())
if workflow_schema is None:
return
global_metadata = create_dummy_metadata(dummy_property, available_layer)
workflow_a = Workflow(dummy_property, global_metadata)
workflow_a.schema = workflow_schema
workflow_b = Workflow(dummy_property, global_metadata)
workflow_b.schema = workflow_schema
workflow_graph = WorkflowGraph()
workflow_graph.add_workflow(workflow_a)
workflow_graph.add_workflow(workflow_b)
ordered_dict_a = OrderedDict(sorted(workflow_a.dependants_graph.items()))
ordered_dict_b = OrderedDict(sorted(workflow_b.dependants_graph.items()))
merge_order_a = graph.topological_sort(ordered_dict_a)
merge_order_b = graph.topological_sort(ordered_dict_b)
assert len(workflow_graph._protocols_by_id) == len(workflow_a.protocols)
for protocol_id in workflow_a.protocols:
assert protocol_id in workflow_graph._protocols_by_id
for protocol_id_A, protocol_id_B in zip(merge_order_a, merge_order_b):
assert protocol_id_A == protocol_id_B
assert workflow_a.protocols[protocol_id_A].schema.json() == \
workflow_b.protocols[protocol_id_B].schema.json()
def test_serialize_layer_result():
"""Tests that the `CalculationLayerResult` can be properly
serialized and deserialized."""
dummy_result = CalculationLayerResult()
dummy_result.property_id = str(uuid.uuid4())
dummy_result.calculated_property = create_dummy_property(Density)
dummy_result.exception = PropertyEstimatorException()
dummy_result.data_to_store = [('dummy_object_path', 'dummy_directory')]
dummy_result_json = json.dumps(dummy_result, cls=TypedJSONEncoder)
recreated_result = json.loads(dummy_result_json, cls=TypedJSONDecoder)
recreated_result_json = json.dumps(recreated_result, cls=TypedJSONEncoder)
assert recreated_result_json == dummy_result_json
def test_advanced_nested_replicators():
dummy_schema = WorkflowSchema()
replicator_a = ProtocolReplicator(replicator_id='replicator_a')
replicator_a.template_values = ['a', 'b']
replicator_b = ProtocolReplicator(replicator_id=f'replicator_b_{replicator_a.placeholder_id}')
replicator_b.template_values = ProtocolPath(f'dummy_list[{replicator_a.placeholder_id}]', 'global')
dummy_protocol = DummyReplicableProtocol(f'dummy_'
f'{replicator_a.placeholder_id}_'
f'{replicator_b.placeholder_id}')
dummy_protocol.replicated_value_a = ReplicatorValue(replicator_a.id)
dummy_protocol.replicated_value_b = ReplicatorValue(replicator_b.id)
dummy_schema.protocols[dummy_protocol.id] = dummy_protocol.schema
dummy_schema.replicators = [replicator_a, replicator_b]
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_metadata = Workflow.generate_default_metadata(dummy_property, 'smirnoff99Frosst-1.1.0.offxml', [])
dummy_metadata['dummy_list'] = [[1], [2]]
dummy_workflow = Workflow(dummy_property, dummy_metadata, '')
dummy_workflow.schema = dummy_schema
assert len(dummy_workflow.protocols) == 2
assert dummy_workflow.protocols['dummy_0_0'].replicated_value_a == 'a'
assert dummy_workflow.protocols['dummy_0_0'].replicated_value_b == 1
assert dummy_workflow.protocols['dummy_1_0'].replicated_value_a == 'b'
assert dummy_workflow.protocols['dummy_1_0'].replicated_value_b == 2
print(dummy_workflow.schema)
def test_simple_workflow_graph():
dummy_schema = WorkflowSchema()
dummy_protocol_a = DummyInputOutputProtocol('protocol_a')
dummy_protocol_a.input_value = EstimatedQuantity(1 * unit.kelvin, 0.1 * unit.kelvin, 'dummy_source')
dummy_schema.protocols[dummy_protocol_a.id] = dummy_protocol_a.schema
dummy_protocol_b = DummyInputOutputProtocol('protocol_b')
dummy_protocol_b.input_value = ProtocolPath('output_value', dummy_protocol_a.id)
dummy_schema.protocols[dummy_protocol_b.id] = dummy_protocol_b.schema
dummy_schema.final_value_source = ProtocolPath('output_value', dummy_protocol_b.id)
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_workflow = Workflow(dummy_property, {})
dummy_workflow.schema = dummy_schema
with tempfile.TemporaryDirectory() as temporary_directory:
workflow_graph = WorkflowGraph(temporary_directory)
workflow_graph.add_workflow(dummy_workflow)
dask_local_backend = DaskLocalCluster(1, ComputeResources(1))
dask_local_backend.start()
results_futures = workflow_graph.submit(dask_local_backend)
assert len(results_futures) == 1
result = results_futures[0].result()
assert isinstance(result, CalculationLayerResult)
assert result.calculated_property.value == 1 * unit.kelvin
def test_estimate_request():
"""Test sending an estimator request to a server."""
from openforcefield.typing.engines import smirnoff
with tempfile.TemporaryDirectory() as temporary_directory:
storage_directory = path.join(temporary_directory, 'storage')
working_directory = path.join(temporary_directory, 'working')
dummy_property = create_dummy_property(Density)
dummy_data_set = PhysicalPropertyDataSet()
dummy_data_set.properties[dummy_property.substance.identifier] = [
dummy_property
]
force_field = smirnoff.ForceField(
get_data_filename('forcefield/smirnoff99Frosst.offxml'))
calculation_backend = DaskLocalClusterBackend(1, ComputeResources())
storage_backend = LocalFileStorage(storage_directory)
PropertyEstimatorServer(calculation_backend,
storage_backend,
working_directory=working_directory)
property_estimator = PropertyEstimatorClient()
options = PropertyEstimatorOptions(
allowed_calculation_layers=[TestCalculationLayer])
request = property_estimator.request_estimate(dummy_data_set,
force_field, options)
result = request.results(synchronous=True, polling_interval=0)
assert not isinstance(result, PropertyEstimatorException)
def test_index_replicated_protocol():
dummy_schema = WorkflowSchema()
dummy_replicator = ProtocolReplicator('dummy_replicator')
dummy_replicator.template_values = ['a', 'b', 'c', 'd']
dummy_schema.replicators = [dummy_replicator]
replicated_protocol = DummyInputOutputProtocol(f'protocol_{dummy_replicator.placeholder_id}')
replicated_protocol.input_value = ReplicatorValue(dummy_replicator.id)
dummy_schema.protocols[replicated_protocol.id] = replicated_protocol.schema
for index in range(len(dummy_replicator.template_values)):
indexing_protocol = DummyInputOutputProtocol(f'indexing_protocol_{index}')
indexing_protocol.input_value = ProtocolPath('output_value', f'protocol_{index}')
dummy_schema.protocols[indexing_protocol.id] = indexing_protocol.schema
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_workflow = Workflow(dummy_property, {})
dummy_workflow.schema = dummy_schema
def test_nested_replicators():
dummy_schema = WorkflowSchema()
dummy_protocol = DummyReplicableProtocol('dummy_$(rep_a)_$(rep_b)')
dummy_protocol.replicated_value_a = ReplicatorValue('rep_a')
dummy_protocol.replicated_value_b = ReplicatorValue('rep_b')
dummy_schema.protocols[dummy_protocol.id] = dummy_protocol.schema
dummy_schema.final_value_source = ProtocolPath('final_value',
dummy_protocol.id)
replicator_a = ProtocolReplicator(replicator_id='rep_a')
replicator_a.template_values = ['a', 'b']
replicator_a.protocols_to_replicate = [ProtocolPath('', dummy_protocol.id)]
replicator_b = ProtocolReplicator(replicator_id='rep_b')
replicator_b.template_values = [1, 2]
replicator_b.protocols_to_replicate = [ProtocolPath('', dummy_protocol.id)]
dummy_schema.replicators = [replicator_a, replicator_b]
dummy_schema.validate_interfaces()
dummy_property = create_dummy_property(Density)
dummy_metadata = Workflow.generate_default_metadata(
dummy_property,
get_data_filename('forcefield/smirnoff99Frosst.offxml'),
PropertyEstimatorOptions())
dummy_workflow = Workflow(dummy_property, dummy_metadata)
dummy_workflow.schema = dummy_schema
assert len(dummy_workflow.protocols) == 4
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_0_0'].replicated_value_a == 'a'
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_0_1'].replicated_value_a == 'a'
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_1_0'].replicated_value_a == 'b'
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_1_1'].replicated_value_a == 'b'
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_0_0'].replicated_value_b == 1
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_0_1'].replicated_value_b == 2
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_1_0'].replicated_value_b == 1
assert dummy_workflow.protocols[dummy_workflow.uuid +
'|dummy_1_1'].replicated_value_b == 2
print(dummy_workflow.schema)