def test_extract_uncorrelated_trajectory_data(): import mdtraj coordinate_path = get_data_filename('test/trajectories/water.pdb') trajectory_path = get_data_filename('test/trajectories/water.dcd') original_trajectory = mdtraj.load(trajectory_path, top=coordinate_path) with tempfile.TemporaryDirectory() as temporary_directory: extract_protocol = ExtractUncorrelatedTrajectoryData( 'extract_protocol') extract_protocol.input_coordinate_file = coordinate_path extract_protocol.input_trajectory_path = trajectory_path extract_protocol.equilibration_index = 2 extract_protocol.statistical_inefficiency = 2.0 result = extract_protocol.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) final_trajectory = mdtraj.load(extract_protocol.output_trajectory_path, top=coordinate_path) assert len(final_trajectory) == (len(original_trajectory) - 2) / 2 assert extract_protocol.number_of_uncorrelated_samples == ( len(original_trajectory) - 2) / 2
def test_thermoml_mole_constraints(): """A collection of tests to ensure that the Mole fraction constraint is implemented correctly alongside solvent constraints.""" # Mole fraction data_set = ThermoMLDataSet.from_file(get_data_filename('test/properties/mole.xml')) assert data_set is not None assert len(data_set.properties) > 0 # Mole fraction + Solvent: Mass fraction data_set = ThermoMLDataSet.from_file(get_data_filename('test/properties/mole_mass.xml')) assert data_set is not None assert len(data_set.properties) > 0 # Mole fraction + Solvent: Mole fraction data_set = ThermoMLDataSet.from_file(get_data_filename('test/properties/mole_mole.xml')) assert data_set is not None assert len(data_set.properties) > 0 # Mole fraction + Solvent: Molality data_set = ThermoMLDataSet.from_file(get_data_filename('test/properties/mole_molality.xml')) assert data_set is not None assert len(data_set.properties) > 0
def test_density_dielectric_merging(): substance = Mixture() substance.add_component('C', 1.0) density = Density(thermodynamic_state=ThermodynamicState( temperature=298 * unit.kelvin, pressure=1 * unit.atmosphere), phase=PropertyPhase.Liquid, substance=substance, value=10 * unit.gram / unit.mole, uncertainty=1 * unit.gram / unit.mole) dielectric = DielectricConstant(thermodynamic_state=ThermodynamicState( temperature=298 * unit.kelvin, pressure=1 * unit.atmosphere), phase=PropertyPhase.Liquid, substance=substance, value=10 * unit.gram / unit.mole, uncertainty=1 * unit.gram / unit.mole) density_schema = density.get_default_workflow_schema( 'SimulationLayer', PropertyWorkflowOptions()) dielectric_schema = dielectric.get_default_workflow_schema( 'SimulationLayer', PropertyWorkflowOptions()) density_metadata = Workflow.generate_default_metadata( density, get_data_filename('forcefield/smirnoff99Frosst.offxml'), PropertyEstimatorOptions()) dielectric_metadata = Workflow.generate_default_metadata( density, get_data_filename('forcefield/smirnoff99Frosst.offxml'), PropertyEstimatorOptions()) density_workflow = Workflow(density, density_metadata) density_workflow.schema = density_schema dielectric_workflow = Workflow(dielectric, dielectric_metadata) dielectric_workflow.schema = dielectric_schema workflow_graph = WorkflowGraph('') workflow_graph.add_workflow(density_workflow) workflow_graph.add_workflow(dielectric_workflow) merge_order_a = graph.topological_sort(density_workflow.dependants_graph) merge_order_b = graph.topological_sort( dielectric_workflow.dependants_graph) for protocol_id_A, protocol_id_B in zip(merge_order_a, merge_order_b): if protocol_id_A.find('extract_traj') < 0 and protocol_id_A.find( 'extract_stats') < 0: assert density_workflow.protocols[protocol_id_A].schema.json() == \ dielectric_workflow.protocols[protocol_id_B].schema.json() else: assert density_workflow.protocols[protocol_id_A].schema.json() != \ dielectric_workflow.protocols[protocol_id_B].schema.json()
def test_from_files(): data_set = ThermoMLDataSet.from_file(get_data_filename('properties/j.jct.2004.09.014.xml'), get_data_filename('properties/j.jct.2004.09.022.xml'), get_data_filename('properties/j.jct.2007.09.004.xml')) assert data_set is not None assert len(data_set.properties) > 0 data_set = ThermoMLDataSet.from_file('properties/j.jct.2004.09.014.xmld') assert data_set is None
def test_thermoml_from_files(): """A test to ensure that ThermoML archive files can be loaded from local sources.""" data_set = ThermoMLDataSet.from_file(get_data_filename('properties/single_density.xml'), get_data_filename('properties/single_dielectric.xml'), get_data_filename('properties/single_enthalpy_mixing.xml')) assert data_set is not None assert len(data_set.properties) == 3 data_set = ThermoMLDataSet.from_file('dummy_filename') assert data_set is None
def compute_estimate_async(): """Submit calculations to a running server instance""" from openforcefield.typing.engines import smirnoff setup_timestamp_logging() # Load in the data set of interest. data_set = ThermoMLDataSet.from_file(get_data_filename('properties/single_dielectric.xml')) # Load in the force field to use. force_field = smirnoff.ForceField(get_data_filename('forcefield/smirnoff99Frosst.offxml')) # new_property_0 = copy.deepcopy(data_set.properties['COCCO{1.0}'][0]) # new_property_0.thermodynamic_state.temperature -= 2.0 * unit.kelvin # new_property_0.id = str(uuid4()) # # data_set.properties['COCCO{1.0}'].append(new_property_0) # # new_property_1 = copy.deepcopy(data_set.properties['COCCO{1.0}'][0]) # new_property_1.thermodynamic_state.temperature += 2.0 * unit.kelvin # new_property_1.id = str(uuid4()) # # data_set.properties['COCCO{1.0}'].append(new_property_1) # Modify the submission options submission_options = PropertyEstimatorOptions() workflow_options = PropertyWorkflowOptions(PropertyWorkflowOptions.ConvergenceMode.RelativeUncertainty, relative_uncertainty_fraction=100000) submission_options.workflow_options = { 'Density': workflow_options, 'Dielectric': workflow_options, 'EnthalpyOfMixing': workflow_options } # submission_options.allowed_calculation_layers = ['SimulationLayer'] submission_options.allowed_calculation_layers = ['ReweightingLayer'] # Create the client object. property_estimator = client.PropertyEstimatorClient() # Submit the request to a running server. request = property_estimator.request_estimate(data_set, force_field, submission_options) logging.info('Request info: {}'.format(str(request))) # Wait for the results. result = request.results(synchronous=True) logging.info('The server has returned a response: {}'.format(result.json()))
def test_statistics_object(): statistics_object = StatisticsArray.from_openmm_csv( get_data_filename('test/statistics/stats_openmm.csv'), 1 * unit.atmosphere) statistics_object.to_pandas_csv('stats_pandas.csv') statistics_object = StatisticsArray.from_pandas_csv('stats_pandas.csv') assert statistics_object is not None subsampled_array = StatisticsArray.from_existing(statistics_object, [1, 2, 3]) assert subsampled_array is not None and len(subsampled_array) == 3 if os.path.isfile('stats_pandas.csv'): os.unlink('stats_pandas.csv') reduced_potential = np.array([0.1] * (len(statistics_object) - 1)) with pytest.raises(ValueError): statistics_object[ObservableType.ReducedPotential] = reduced_potential reduced_potential = np.array([0.1] * len(statistics_object)) with pytest.raises(ValueError): statistics_object[ObservableType.ReducedPotential] = reduced_potential statistics_object[ ObservableType. ReducedPotential] = reduced_potential * unit.dimensionless assert ObservableType.ReducedPotential in statistics_object
def compute_estimate_sync(): """Submit calculations to a running server instance""" from openforcefield.typing.engines import smirnoff setup_timestamp_logging() # Load in the data set of interest. data_set = ThermoMLDataSet.from_file(get_data_filename('properties/single_density.xml')) # Load in the force field to use. force_field = smirnoff.ForceField(get_data_filename('forcefield/smirnoff99Frosst.offxml')) # Create the client object. property_estimator = client.PropertyEstimatorClient() # Submit the request to a running server, and wait for the results. result = property_estimator.request_estimate(data_set, force_field) logging.info('The server has returned a response: {}'.format(result))
def test_serialization(): """A test to ensure that data sets are JSON serializable.""" data_set = ThermoMLDataSet.from_file(get_data_filename('properties/single_density.xml')) data_set_json = data_set.json() parsed_data_set = ThermoMLDataSet.parse_json(data_set_json) assert data_set.number_of_properties == parsed_data_set.number_of_properties parsed_data_set_json = parsed_data_set.json() assert parsed_data_set_json == data_set_json
def test_concatenate_trajectories(): import mdtraj coordinate_path = get_data_filename('test/trajectories/water.pdb') trajectory_path = get_data_filename('test/trajectories/water.dcd') original_trajectory = mdtraj.load(trajectory_path, top=coordinate_path) with tempfile.TemporaryDirectory() as temporary_directory: concatenate_protocol = ConcatenateTrajectories('concatenate_protocol') concatenate_protocol.input_coordinate_paths = [coordinate_path, coordinate_path] concatenate_protocol.input_trajectory_paths = [trajectory_path, trajectory_path] result = concatenate_protocol.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) final_trajectory = mdtraj.load(concatenate_protocol.output_trajectory_path, top=coordinate_path) assert len(final_trajectory) == len(original_trajectory) * 2
def test_calculate_reduced_potential_openmm(): substance = Substance.from_components('O') thermodynamic_state = ThermodynamicState(298 * unit.kelvin, 1.0 * unit.atmosphere) with tempfile.TemporaryDirectory() as directory: force_field_path = path.join(directory, 'ff.json') with open(force_field_path, 'w') as file: file.write(build_tip3p_smirnoff_force_field().json()) build_coordinates = BuildCoordinatesPackmol('build_coordinates') build_coordinates.max_molecules = 10 build_coordinates.mass_density = 0.05 * unit.grams / unit.milliliters build_coordinates.substance = substance build_coordinates.execute(directory, None) assign_parameters = BuildSmirnoffSystem(f'assign_parameters') assign_parameters.force_field_path = force_field_path assign_parameters.coordinate_file_path = build_coordinates.coordinate_file_path assign_parameters.substance = substance assign_parameters.execute(directory, None) reduced_potentials = CalculateReducedPotentialOpenMM(f'reduced_potentials') reduced_potentials.substance = substance reduced_potentials.thermodynamic_state = thermodynamic_state reduced_potentials.reference_force_field_paths = [force_field_path] reduced_potentials.system_path = assign_parameters.system_path reduced_potentials.trajectory_file_path = get_data_filename('test/trajectories/water.dcd') reduced_potentials.coordinate_file_path = get_data_filename('test/trajectories/water.pdb') reduced_potentials.kinetic_energies_path = get_data_filename('test/statistics/stats_pandas.csv') reduced_potentials.high_precision = False result = reduced_potentials.execute(directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) assert path.isfile(reduced_potentials.statistics_file_path) final_array = StatisticsArray.from_pandas_csv(reduced_potentials.statistics_file_path) assert ObservableType.ReducedPotential in final_array
def test_extract_average_statistic(): statistics_path = get_data_filename('test/statistics/stats_pandas.csv') with tempfile.TemporaryDirectory() as temporary_directory: extract_protocol = ExtractAverageStatistic('extract_protocol') extract_protocol.statistics_path = statistics_path extract_protocol.statistics_type = ObservableType.PotentialEnergy result = extract_protocol.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException)
def test_force_field_serialization(): from openforcefield.typing.engines import smirnoff force_field = smirnoff.ForceField(get_data_filename('forcefield/smirnoff99Frosst.offxml')) serialized_force_field = serialize_force_field(force_field) deserialized_force_field = deserialize_force_field(serialized_force_field) original_generators = force_field.getGenerators() deserialized_generators = deserialized_force_field.getGenerators() assert len(original_generators) == len(deserialized_generators)
def build_solvated_system(): """An example of how to build a solvated system using the built in utilities and protocol classes. """ # Define the system that you wish to create coordinates for. mixed_system = Mixture() # Here we simply define a 1:1 mix of water and octanol. mixed_system.add_component(smiles='O', mole_fraction=0.5) mixed_system.add_component(smiles='CCCCCCCCO', mole_fraction=0.5) # Add any 'impurities' such as single solute molecules. # In this case we add a molecule of paracetamol. mixed_system.add_component(smiles='CC(=O)NC1=CC=C(C=C1)O', mole_fraction=0.0, impurity=True) # Create an object which under the hood calls the packmol utility # in a friendlier way: print('Building the coordinates (this may take a while...)') build_coordinates = BuildCoordinatesPackmol('') # Set the maximum number of molecules in the system. build_coordinates.max_molecules = 1500 # and the target density (the default 1.0 g/ml is normally fine) build_coordinates.mass_density = 1.0 * unit.grams / unit.milliliters # and finally the system which coordinates should be generated for. build_coordinates.substance = mixed_system # Build the coordinates, creating a file called output.pdb build_coordinates.execute('', None) # Assign some smirnoff force field parameters to the # coordinates print('Assigning some parameters.') assign_force_field_parameters = BuildSmirnoffSystem('') assign_force_field_parameters.force_field_path = get_data_filename('forcefield/smirnoff99Frosst.offxml') assign_force_field_parameters.coordinate_file_path = 'output.pdb' assign_force_field_parameters.substance = mixed_system assign_force_field_parameters.execute('', None) # Do a simple energy minimisation print('Performing energy minimisation.') energy_minimisation = RunEnergyMinimisation('') energy_minimisation.input_coordinate_file = 'output.pdb' energy_minimisation.system_path = assign_force_field_parameters.system_path energy_minimisation.execute('', ComputeResources())
def test_gradient_reduced_potentials(use_subset): substance = Substance.from_components('O') thermodynamic_state = ThermodynamicState(298 * unit.kelvin, 1.0 * unit.atmosphere) with tempfile.TemporaryDirectory() as directory: force_field_path = path.join(directory, 'ff.json') with open(force_field_path, 'w') as file: file.write(build_tip3p_smirnoff_force_field().json()) reduced_potentials = GradientReducedPotentials(f'reduced_potentials') reduced_potentials.substance = substance reduced_potentials.thermodynamic_state = thermodynamic_state reduced_potentials.reference_force_field_paths = [force_field_path] reduced_potentials.reference_statistics_path = get_data_filename( 'test/statistics/stats_pandas.csv') reduced_potentials.force_field_path = force_field_path reduced_potentials.trajectory_file_path = get_data_filename( 'test/trajectories/water.dcd') reduced_potentials.coordinate_file_path = get_data_filename( 'test/trajectories/water.pdb') reduced_potentials.use_subset_of_force_field = use_subset reduced_potentials.enable_pbc = True reduced_potentials.parameter_key = ParameterGradientKey( 'vdW', '[#1]-[#8X2H2+0:1]-[#1]', 'epsilon') result = reduced_potentials.execute(directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) assert path.isfile(reduced_potentials.forward_potentials_path) assert path.isfile(reduced_potentials.reverse_potentials_path) for reference_path in reduced_potentials.reference_force_field_paths: assert path.isfile(reference_path)
def test_concatenate_statistics(): statistics_path = get_data_filename('test/statistics/stats_pandas.csv') original_array = StatisticsArray.from_pandas_csv(statistics_path) with tempfile.TemporaryDirectory() as temporary_directory: concatenate_protocol = ConcatenateStatistics('concatenate_protocol') concatenate_protocol.input_statistics_paths = [statistics_path, statistics_path] result = concatenate_protocol.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) final_array = StatisticsArray.from_pandas_csv(concatenate_protocol.output_statistics_path) assert len(final_array) == len(original_array) * 2
def test_statistics_object(): statistics_object = StatisticsArray.from_openmm_csv( get_data_filename('properties/stats_openmm.csv'), 1 * unit.atmosphere) statistics_object.save_as_pandas_csv('stats_pandas.csv') statistics_object = StatisticsArray.from_pandas_csv('stats_pandas.csv') subsampled_array = StatisticsArray.from_statistics_array( statistics_object, [1, 2, 3]) if os.path.isfile('stats_pandas.csv'): os.unlink('stats_pandas.csv') assert statistics_object is not None assert subsampled_array is not None and len(subsampled_array) == 3
def create_dummy_metadata(dummy_property, calculation_layer): global_metadata = Workflow.generate_default_metadata( dummy_property, get_data_filename('forcefield/smirnoff99Frosst.offxml'), PropertyEstimatorOptions()) if calculation_layer == 'ReweightingLayer': global_metadata['full_system_data'] = [('data_path_0', 'ff_path_0'), ('data_path_1', 'ff_path_0'), ('data_path_2', 'ff_path_1')] global_metadata['component_data'] = [[('data_path_3', 'ff_path_3'), ('data_path_4', 'ff_path_4')], [('data_path_5', 'ff_path_5'), ('data_path_6', 'ff_path_6')]] return global_metadata
def parse_all_jct_files(): logging.basicConfig(filename='data_sets.log', filemode='w', level=logging.INFO) data_path = get_data_filename('properties/JCT') thermoml_files = [] for file_path in listdir(data_path): full_path = join(data_path, file_path) if not isfile(full_path): continue thermoml_files.append(full_path) data_set = ThermoMLDataSet.from_file(*thermoml_files) from propertyestimator.properties.density import Density from propertyestimator.properties.dielectric import DielectricConstant from propertyestimator.properties.enthalpy import EnthalpyOfMixing properties_by_type = {Density.__name__: [], DielectricConstant.__name__: [], EnthalpyOfMixing.__name__: []} for substance_key in data_set.properties: for data_property in data_set.properties[substance_key]: if type(data_property).__name__ not in properties_by_type: continue properties_by_type[type(data_property).__name__].append(data_property.source.reference) for type_key in properties_by_type: with open('{}.dat'.format(type_key), 'w') as file: for doi in properties_by_type[type_key]: file.write('{}\n'.format(doi))
def test_extract_uncorrelated_statistics_data(): statistics_path = get_data_filename('test/statistics/stats_pandas.csv') original_array = StatisticsArray.from_pandas_csv(statistics_path) with tempfile.TemporaryDirectory() as temporary_directory: extract_protocol = ExtractUncorrelatedStatisticsData( 'extract_protocol') extract_protocol.input_statistics_path = statistics_path extract_protocol.equilibration_index = 2 extract_protocol.statistical_inefficiency = 2.0 result = extract_protocol.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) final_array = StatisticsArray.from_pandas_csv( extract_protocol.output_statistics_path) assert len(final_array) == (len(original_array) - 2) / 2 assert extract_protocol.number_of_uncorrelated_samples == ( len(original_array) - 2) / 2
def build_tip3p_smirnoff_force_field(): """Combines the smirnoff99Frosst and tip3p offxml files into a single one which can be consumed by the property estimator. Returns ------- SmirnoffForceFieldSource The force field containing both smirnoff99Frosst-1.1.0 and TIP3P parameters """ from openforcefield.typing.engines.smirnoff import ForceField smirnoff_force_field_path = 'smirnoff99Frosst-1.1.0.offxml' tip3p_force_field_path = get_data_filename('forcefield/tip3p.offxml') smirnoff_force_field_with_tip3p = ForceField(smirnoff_force_field_path, tip3p_force_field_path) return SmirnoffForceFieldSource.from_object( smirnoff_force_field_with_tip3p)
def test_local_force_field_storage(): """A simple test to that force fields can be stored and retrieved using the local storage backend.""" from openforcefield.typing.engines import smirnoff force_field = smirnoff.ForceField( get_data_filename('forcefield/smirnoff99Frosst.offxml')) with tempfile.TemporaryDirectory() as temporary_directory: local_storage = LocalFileStorage(temporary_directory) local_storage.store_force_field('tmp_id', force_field) retrieved_force_field = local_storage.retrieve_force_field('tmp_id') serialized_force_field = serialize_force_field(force_field) serialized_retrieved_force_field = serialize_force_field( retrieved_force_field) assert json.dumps(serialized_force_field) == json.dumps( serialized_retrieved_force_field) local_storage_new = LocalFileStorage(temporary_directory) assert local_storage_new.has_force_field(force_field)
def test_build_docked_coordinates_protocol(): """Tests docking a methanol molecule into alpha-Cyclodextrin.""" ligand_substance = Substance() ligand_substance.add_component( Substance.Component('CO', role=Substance.ComponentRole.Ligand), Substance.ExactAmount(1)) # TODO: This test could likely be made substantially faster # by storing the binary prepared receptor. Would this # be in breach of any oe license terms? with tempfile.TemporaryDirectory() as temporary_directory: build_docked_coordinates = BuildDockedCoordinates('build_methanol') build_docked_coordinates.ligand_substance = ligand_substance build_docked_coordinates.number_of_ligand_conformers = 5 build_docked_coordinates.receptor_coordinate_file = get_data_filename( 'test/molecules/acd.mol2') build_docked_coordinates.execute(temporary_directory, ComputeResources()) docked_pdb = PDBFile( build_docked_coordinates.docked_complex_coordinate_path) assert docked_pdb.topology.getNumResidues() == 2
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_base_simulation_protocols(): """Tests that the commonly chain build coordinates, assigned topology, energy minimise and perform simulation are able to work together without raising an exception.""" mixed_system = Mixture() mixed_system.add_component(smiles='O', mole_fraction=1.0) thermodynamic_state = ThermodynamicState(298 * unit.kelvin, 1 * unit.atmosphere) with tempfile.TemporaryDirectory() as temporary_directory: build_coordinates = BuildCoordinatesPackmol('') # Set the maximum number of molecules in the system. build_coordinates.max_molecules = 10 # and the target density (the default 1.0 g/ml is normally fine) build_coordinates.mass_density = 0.05 * unit.grams / unit.milliliters # and finally the system which coordinates should be generated for. build_coordinates.substance = mixed_system # Build the coordinates, creating a file called output.pdb result = build_coordinates.execute(temporary_directory, None) assert not isinstance(result, PropertyEstimatorException) # Assign some smirnoff force field parameters to the # coordinates print('Assigning some parameters.') assign_force_field_parameters = BuildSmirnoffSystem('') assign_force_field_parameters.force_field_path = get_data_filename( 'forcefield/smirnoff99Frosst.offxml') assign_force_field_parameters.coordinate_file_path = path.join( temporary_directory, 'output.pdb') assign_force_field_parameters.substance = mixed_system result = assign_force_field_parameters.execute(temporary_directory, None) assert not isinstance(result, PropertyEstimatorException) # Do a simple energy minimisation print('Performing energy minimisation.') energy_minimisation = RunEnergyMinimisation('') energy_minimisation.input_coordinate_file = path.join( temporary_directory, 'output.pdb') energy_minimisation.system_path = assign_force_field_parameters.system_path result = energy_minimisation.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) npt_equilibration = RunOpenMMSimulation('npt_equilibration') npt_equilibration.ensemble = Ensemble.NPT npt_equilibration.steps = 20 # Debug settings. npt_equilibration.output_frequency = 2 # Debug settings. npt_equilibration.thermodynamic_state = thermodynamic_state npt_equilibration.input_coordinate_file = path.join( temporary_directory, 'minimised.pdb') npt_equilibration.system_path = assign_force_field_parameters.system_path result = npt_equilibration.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) extract_density = ExtractAverageStatistic('extract_density') extract_density.statistics_type = ObservableType.Density extract_density.statistics_path = path.join(temporary_directory, 'statistics.csv') result = extract_density.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) extract_dielectric = ExtractAverageDielectric('extract_dielectric') extract_dielectric.thermodynamic_state = thermodynamic_state extract_dielectric.input_coordinate_file = path.join( temporary_directory, 'input.pdb') extract_dielectric.trajectory_path = path.join(temporary_directory, 'trajectory.dcd') extract_dielectric.system_path = assign_force_field_parameters.system_path result = extract_dielectric.execute(temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) extract_uncorrelated_trajectory = ExtractUncorrelatedTrajectoryData( 'extract_traj') extract_uncorrelated_trajectory.statistical_inefficiency = extract_density.statistical_inefficiency extract_uncorrelated_trajectory.equilibration_index = extract_density.equilibration_index extract_uncorrelated_trajectory.input_coordinate_file = path.join( temporary_directory, 'input.pdb') extract_uncorrelated_trajectory.input_trajectory_path = path.join( temporary_directory, 'trajectory.dcd') result = extract_uncorrelated_trajectory.execute( temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException) extract_uncorrelated_statistics = ExtractUncorrelatedStatisticsData( 'extract_stats') extract_uncorrelated_statistics.statistical_inefficiency = extract_density.statistical_inefficiency extract_uncorrelated_statistics.equilibration_index = extract_density.equilibration_index extract_uncorrelated_statistics.input_statistics_path = path.join( temporary_directory, 'statistics.csv') result = extract_uncorrelated_statistics.execute( temporary_directory, ComputeResources()) assert not isinstance(result, PropertyEstimatorException)
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)