def test_local_force_field_storage():
"""A simple test to that force fields can be stored and
retrieved using the local storage backend."""
force_field_source = SmirnoffForceFieldSource.from_path(
'smirnoff99Frosst-1.1.0.offxml')
with tempfile.TemporaryDirectory() as temporary_directory:
local_storage = LocalFileStorage(temporary_directory)
force_field_id = local_storage.store_force_field(force_field_source)
retrieved_force_field = local_storage.retrieve_force_field(
force_field_id)
force_field_string = force_field_source.json()
retrieved_force_field_string = retrieved_force_field.json()
assert force_field_string == retrieved_force_field_string
local_storage_new = LocalFileStorage(temporary_directory)
assert local_storage_new.has_force_field(force_field_source)
def main():
setup_timestamp_logging()
# Load in the force field
force_field_path = 'smirnoff99Frosst-1.1.0.offxml'
force_field_source = SmirnoffForceFieldSource.from_path(force_field_path)
# Load in the data set containing a single dielectric
# property.
with open('pure_data_set.json') as file:
data_set = PhysicalPropertyDataSet.parse_json(file.read())
data_set.filter_by_property_types('DielectricConstant')
# Set up the server object which run the calculations.
setup_server(backend_type=BackendType.LocalGPU,
max_number_of_workers=1,
port=8001)
# Request the estimates.
property_estimator = client.PropertyEstimatorClient(
client.ConnectionOptions(server_port=8001))
options = PropertyEstimatorOptions()
options.allowed_calculation_layers = ['SimulationLayer']
options.workflow_options = {
'DielectricConstant': {
'SimulationLayer':
WorkflowOptions(WorkflowOptions.ConvergenceMode.NoChecks),
'ReweightingLayer':
WorkflowOptions(WorkflowOptions.ConvergenceMode.NoChecks)
}
}
parameter_gradient_keys = [
ParameterGradientKey(tag='vdW', smirks='[#6X4:1]',
attribute='epsilon'),
ParameterGradientKey(tag='vdW',
smirks='[#6X4:1]',
attribute='rmin_half')
]
request = property_estimator.request_estimate(
property_set=data_set,
force_field_source=force_field_source,
options=options,
parameter_gradient_keys=parameter_gradient_keys)
# Wait for the results.
results = request.results(True, 5)
# Save the result to file.
with open('dielectric_simulation.json', 'wb') as file:
json_results = json.dumps(results,
sort_keys=True,
indent=2,
separators=(',', ': '),
cls=TypedJSONEncoder)
file.write(json_results.encode('utf-8'))
# Attempt to reweight the cached data.
options.allowed_calculation_layers = ['ReweightingLayer']
request = property_estimator.request_estimate(
property_set=data_set,
force_field_source=force_field_source,
options=options,
parameter_gradient_keys=parameter_gradient_keys)
# Wait for the results.
results = request.results(True, 5)
# Save the result to file.
with open('dielectric_reweight.json', 'wb') as file:
json_results = json.dumps(results,
sort_keys=True,
indent=2,
separators=(',', ': '),
cls=TypedJSONEncoder)
file.write(json_results.encode('utf-8'))
def main():
setup_timestamp_logging()
# Load in the force field
force_field_path = 'smirnoff99Frosst-1.1.0.offxml'
force_field_source = SmirnoffForceFieldSource.from_path(force_field_path)
# Create a data set containing three solvation free energies.
data_set = _create_data_set()
# Set up the compute backend which will run the calculations.
working_directory = 'working_directory'
storage_directory = 'storage_directory'
queue_resources = QueueWorkerResources(
number_of_threads=1,
number_of_gpus=1,
preferred_gpu_toolkit=QueueWorkerResources.GPUToolkit.CUDA,
per_thread_memory_limit=5 * unit.gigabyte,
wallclock_time_limit="05:59")
worker_script_commands = [
'conda activate propertyestimator', 'module load cuda/10.1'
]
calculation_backend = DaskLSFBackend(
minimum_number_of_workers=1,
maximum_number_of_workers=3,
resources_per_worker=queue_resources,
queue_name='gpuqueue',
setup_script_commands=worker_script_commands,
adaptive_interval='1000ms',
adaptive_class=CustomAdaptive)
# Set up a backend to cache simulation data in.
storage_backend = LocalFileStorage(storage_directory)
# Spin up the server object.
PropertyEstimatorServer(calculation_backend=calculation_backend,
storage_backend=storage_backend,
port=8005,
working_directory=working_directory)
# Request the estimates.
property_estimator = client.PropertyEstimatorClient(
client.ConnectionOptions(server_port=8005))
options = PropertyEstimatorOptions()
options.allowed_calculation_layers = ['SimulationLayer']
workflow_options = WorkflowOptions(
WorkflowOptions.ConvergenceMode.NoChecks)
options.workflow_options = {
'SolvationFreeEnergy': {
'SimulationLayer': workflow_options
}
}
options.workflow_schemas = {
'SolvationFreeEnergy': {
'SimulationLayer': _get_fixed_lambda_schema(workflow_options)
}
}
request = property_estimator.request_estimate(
property_set=data_set,
force_field_source=force_field_source,
options=options)
# Wait for the results.
results = request.results(True, 5)
# Save the result to file.
with open('solvation_free_energy_simulation.json', 'wb') as file:
json_results = json.dumps(results,
sort_keys=True,
indent=2,
separators=(',', ': '),
cls=TypedJSONEncoder)
file.write(json_results.encode('utf-8'))
def main():
"""The main script which will create an estimation server, request
the curated data set be estimated for each force field of interest,
wait for the calculations to be complete, and save the results.
"""
setup_timestamp_logging()
logger = logging.getLogger()
# Define those force fields to use in the calculations
force_field_sources = {
'smirnoff99frosst 1.1.0':
SmirnoffForceFieldSource.from_path('smirnoff99Frosst-1.1.0.offxml'),
'parsley 0.0.9':
SmirnoffForceFieldSource.from_path('smirnoff_release_1_v0_0_9.offxml'),
'parsley rc 1':
SmirnoffForceFieldSource.from_path('openff_hbonds-1.0.0-RC1.offxml'),
'gaff 1.81':
TLeapForceFieldSource(leap_source='leaprc.gaff'),
'gaff 2.11':
TLeapForceFieldSource(leap_source='leaprc.gaff2')
}
# Set up the server object which will run the calculations.
setup_server(max_number_of_workers=50)
# Set up the client which will request the estimates.
estimator_client = PropertyEstimatorClient()
# Load in the data set to estimate.
with open('curated_data_set.json') as file:
data_set = PhysicalPropertyDataSet.parse_json(file.read())
# Specify the estimation options
protocol_replacements = {
'gaff_1': {
'BuildSmirnoffSystem': 'BuildTLeapSystem'
},
'gaff_2': {
'BuildSmirnoffSystem': 'BuildTLeapSystem'
}
}
requests = {}
# Request estimates using each force field, storing the request
# object used to query the status of the results.
for force_field_key in force_field_sources:
force_field_source = force_field_sources[force_field_key]
options = get_estimation_options(
protocol_replacements.get(force_field_key, {}))
requests[force_field_key] = estimator_client.request_estimate(
property_set=data_set,
force_field_source=force_field_source,
options=options)
# Wait for the results.
should_run = True
finished_force_fields = []
while should_run:
sleep(60)
for force_field_key in force_field_sources:
if force_field_key in finished_force_fields:
continue
results = requests[force_field_key].results(False)
if isinstance(results, PropertyEstimatorResult) and len(
results.queued_properties) > 0:
continue
logger.info(f'The server has completed {force_field_key}.')
# Save the result to file.
save_results(force_field_key, results)
finished_force_fields.append(force_field_key)
if len(finished_force_fields) == len(force_field_sources):
should_run = False