def test_Runner_openmm_default(host_guest_mmvt_model): host_guest_mmvt_model.calculation_settings.num_production_steps = 10 host_guest_mmvt_model.openmm_settings.cuda_platform_settings = None host_guest_mmvt_model.openmm_settings.reference_platform = True myanchor = host_guest_mmvt_model.anchors[1] mmvt_output_filename = os.path.join( host_guest_mmvt_model.anchor_rootdir, myanchor.directory, "prod", "%s%d.%s" % (mmvt_base.OPENMMVT_BASENAME, 1, mmvt_base.OPENMMVT_EXTENSION)) runner = runner_openmm.Runner_openmm(host_guest_mmvt_model, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( force_overwrite=True) my_sim_openmm = mmvt_sim_openmm.create_sim_openmm(host_guest_mmvt_model, myanchor, mmvt_output_filename) runner.run(my_sim_openmm, False) assert os.path.exists(mmvt_output_filename) # restart host_guest_mmvt_model.calculation_settings.num_production_steps = 20 mmvt_output_filename = os.path.join( host_guest_mmvt_model.anchor_rootdir, myanchor.directory, "prod", "%s%d.%s" % (mmvt_base.OPENMMVT_BASENAME, 2, mmvt_base.OPENMMVT_EXTENSION)) runner = runner_openmm.Runner_openmm(host_guest_mmvt_model, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( restart=True) my_sim_openmm = mmvt_sim_openmm.create_sim_openmm(host_guest_mmvt_model, myanchor, mmvt_output_filename) runner.run(my_sim_openmm, True, restart_index=restart_index) return
def test_check_toy_openmm_context_within_boundary(toy_mmvt_model, tmp_path): """ Test whether the check can find systems that exist outside the proper Voronoi cells. """ # Test check success: system starting within Voronoi cells anchor = toy_mmvt_model.anchors[0] output_file = os.path.join(tmp_path, "output.txt") toy_mmvt_model.openmm_settings.cuda_platform_settings = None toy_mmvt_model.openmm_settings.reference_platform = True my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( toy_mmvt_model, anchor, output_file) context = my_sim_openmm.simulation.context final_result = True for milestone in anchor.milestones: cv = toy_mmvt_model.collective_variables[milestone.cv_index] result = cv.check_openmm_context_within_boundary( context, milestone.variables, verbose=True) final_result = final_result and result assert final_result # Test check failure(s): system outside Voronoi cells toy_mmvt_model.anchors[0].starting_positions = np.array( [[[0.0, -0.7, 0.0]], [[0.2, -0.5, 0.0]]]) toy_mmvt_model.anchors[1].starting_positions = np.array( [[[0.0, -0.3, 0.0]]]) anchor = toy_mmvt_model.anchors[0] my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( toy_mmvt_model, anchor, output_file, frame=1) context = my_sim_openmm.simulation.context final_result = True for milestone in anchor.milestones: cv = toy_mmvt_model.collective_variables[milestone.cv_index] result = cv.check_openmm_context_within_boundary( context, milestone.variables, verbose=True) final_result = final_result and result assert not final_result anchor = toy_mmvt_model.anchors[1] my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( toy_mmvt_model, anchor, output_file) context = my_sim_openmm.simulation.context final_result = True for milestone in anchor.milestones: cv = toy_mmvt_model.collective_variables[milestone.cv_index] result = cv.check_openmm_context_within_boundary( context, milestone.variables, verbose=True) final_result = final_result and result assert not final_result return
def test_saveCheckpoint(host_guest_mmvt_model): host_guest_mmvt_model.calculation_settings.num_production_steps = 10 host_guest_mmvt_model.openmm_settings.cuda_platform_settings = None host_guest_mmvt_model.openmm_settings.reference_platform = True myanchor = host_guest_mmvt_model.anchors[1] mmvt_output_filename = os.path.join( host_guest_mmvt_model.anchor_rootdir, myanchor.directory, "prod", "%s%d.%s" % (mmvt_base.OPENMMVT_BASENAME, 1, mmvt_base.OPENMMVT_EXTENSION)) runner = runner_openmm.Runner_openmm(host_guest_mmvt_model, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( force_overwrite=True) my_sim_openmm = mmvt_sim_openmm.create_sim_openmm(host_guest_mmvt_model, myanchor, mmvt_output_filename) assert not os.path.exists(runner.restart_checkpoint_filename) runner_openmm.saveCheckpoint(my_sim_openmm, runner.restart_checkpoint_filename) assert os.path.exists(runner.restart_checkpoint_filename) lastline = "" with open(my_sim_openmm.output_filename, "r") as f: for line in f.readlines(): lastline = line print("line:", line) assert lastline.startswith("CHECKPOINT")
def test_mmvt_swarm(host_guest_mmvt_model): """ If a multi-frame trajectory is provided as the input PDB, then an MMVT swarm should be started. """ swarm_file_name = "hostguest_at0.5_swarm.pdb" host_guest_mmvt_model.anchors[0].amber_params.pdb_coordinates_filename \ = swarm_file_name anchor_building_dir = os.path.join( host_guest_mmvt_model.anchor_rootdir, host_guest_mmvt_model.anchors[0].directory, host_guest_mmvt_model.anchors[0].building_directory) assert os.path.exists(anchor_building_dir) src_filename = os.path.join(TEST_DATA_DIRECTORY, swarm_file_name) dest_filename = os.path.join(anchor_building_dir, swarm_file_name) shutil.copyfile(src_filename, dest_filename) host_guest_mmvt_model.calculation_settings.num_production_steps = 10 host_guest_mmvt_model.openmm_settings.cuda_platform_settings = None host_guest_mmvt_model.openmm_settings.reference_platform = True myanchor = host_guest_mmvt_model.anchors[0] for i in range(10): runner = runner_openmm.Runner_openmm(host_guest_mmvt_model, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( force_overwrite=True, swarm_index=i) my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( host_guest_mmvt_model, myanchor, default_output_file) runner.run(my_sim_openmm, False) assert os.path.exists(default_output_file) return
def test_Runner_openmm_other_settings(tmp_path): if not os.path.exists(tmp_path): os.mkdir(tmp_path) mymodel = make_test_model.make_test_model(tmp_path) #sim_openmm_factory = sim_openmm.Sim_openmm_factory() myanchor = mymodel.anchors[1] mmvt_output_filename = os.path.join( tmp_path, myanchor.name, "prod", "%s%d.%s" % (mmvt_base.OPENMMVT_BASENAME, 1, mmvt_base.OPENMMVT_EXTENSION)) loading_state_filename = os.path.join(tmp_path, "start.state") runner = runner_openmm.Runner_openmm(mymodel, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( False, True) my_sim_openmm = mmvt_sim_openmm.create_sim_openmm(mymodel, myanchor, mmvt_output_filename, state_file_prefix) my_sim_openmm.simulation.saveState(loading_state_filename) runner.run(my_sim_openmm, False, load_state_file=loading_state_filename) assert my_sim_openmm.integrator.getOutputFileName() == mmvt_output_filename lines = 0 assert os.path.exists(mmvt_output_filename) assert os.path.exists(loading_state_filename) #print("glob.glob(state_file_prefix+'*')", glob.glob(state_file_prefix+'*')) #assert len(glob.glob(state_file_prefix+'*')) > 0 with open(mmvt_output_filename, "r") as f: for line in f: lines += 1
def test_mmvt_sim_openmm_forcefield(tmp_path): mymodel = make_test_model.make_test_model(tmp_path, mode='forcefield') myanchor = mymodel.anchors[1] output_file = os.path.join(tmp_path, "output.txt") my_sim_openmm = mmvt_sim_openmm.create_sim_openmm(mymodel, myanchor, output_file) return
def test_mmvt_sim_openmm_amber(tmp_path, host_guest_mmvt_model): myanchor = host_guest_mmvt_model.anchors[1] output_file = os.path.join(tmp_path, "output.txt") my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( host_guest_mmvt_model, myanchor, output_file) assert my_sim_openmm.system is not None assert my_sim_openmm.integrator is not None assert my_sim_openmm.simulation is not None return
def run_openmm(model, anchor_index, restart, total_simulation_length, cuda_device_index=False, force_overwrite=False, save_state_file=False, num_rev_launches=1, umbrella_restart_mode=False): """Run an OpenMM simulation.""" import seekr2.modules.runner_openmm as runner_openmm import seekr2.modules.mmvt_sim_openmm as mmvt_sim_openmm import seekr2.modules.elber_sim_openmm as elber_sim_openmm assert anchor_index >= 0, "only positive indices allowed." try: myanchor = model.anchors[anchor_index] except IndexError: print("Invalid anchor index provided.") exit() if cuda_device_index is not None: assert model.openmm_settings.cuda_platform_settings is not None model.openmm_settings.cuda_platform_settings.cuda_device_index = \ cuda_device_index if total_simulation_length is not None: if model.get_type() == "mmvt": old_num_production_steps = \ model.calculation_settings.num_production_steps model.calculation_settings.num_production_steps = \ total_simulation_length elif model.get_type() == "elber": old_num_production_steps = \ model.calculation_settings.num_umbrella_stage_steps model.calculation_settings.num_umbrella_stage_steps = \ total_simulation_length model.calculation_settings.num_rev_launches = num_rev_launches runner = runner_openmm.Runner_openmm(model, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( restart, save_state_file, force_overwrite, umbrella_restart_mode) if model.get_type() == "mmvt": sim_openmm_obj = mmvt_sim_openmm.create_sim_openmm( model, myanchor, default_output_file, state_file_prefix) elif model.get_type() == "elber": sim_openmm_obj = elber_sim_openmm.create_sim_openmm( model, myanchor, default_output_file, state_file_prefix) runner.run(sim_openmm_obj, restart, None, restart_index) if model.get_type() == "mmvt": model.calculation_settings.num_production_steps \ = old_num_production_steps elif model.get_type() == "elber": model.calculation_settings.num_umbrella_stage_steps \ = old_num_production_steps
def test_add_forces(tmp_path, toy_mmvt_model): anchor = toy_mmvt_model.anchors[0] output_file = os.path.join(tmp_path, "output.txt") my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( toy_mmvt_model, anchor, output_file) forces = my_sim_openmm.system.getForces() old_force_len = len(forces) assert my_sim_openmm.integrator.getNumMilestoneGroups() \ == len(anchor.milestones) mmvt_sim_openmm.add_forces(my_sim_openmm, toy_mmvt_model, anchor) forces2 = my_sim_openmm.system.getForces() assert len(forces2) == old_force_len + len(anchor.milestones) return
def test_Runner_openmm_forcefield(tmp_path, host_guest_mmvt_model_forcefield): if not os.path.exists(tmp_path): os.mkdir(tmp_path) mymodel = host_guest_mmvt_model_forcefield myanchor = mymodel.anchors[1] mmvt_output_filename = os.path.join( tmp_path, myanchor.directory, "prod", "%s%d.%s" % (mmvt_base.OPENMMVT_BASENAME, 1, mmvt_base.OPENMMVT_EXTENSION)) runner = runner_openmm.Runner_openmm(mymodel, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( force_overwrite=True) my_sim_openmm = mmvt_sim_openmm.create_sim_openmm(mymodel, myanchor, mmvt_output_filename) runner.run(my_sim_openmm, False) assert os.path.exists(mmvt_output_filename)
def get_checkpoint_step(model, anchor): dummy_file = tempfile.NamedTemporaryFile() sim_openmm_obj = mmvt_sim_openmm.create_sim_openmm(model, anchor, dummy_file.name, frame=0, load_state_file=None) simulation = sim_openmm_obj.simulation output_directory = os.path.join(model.anchor_rootdir, anchor.directory, anchor.production_directory) restart_checkpoint_basename = runner_openmm.RESTART_CHECKPOINT_FILENAME restart_checkpoint_glob = os.path.join(output_directory, restart_checkpoint_basename + "*") restart_checkpoint_list = glob.glob(restart_checkpoint_glob) if len(restart_checkpoint_list) > 0: simulation.loadCheckpoint(restart_checkpoint_list[0]) currentStep = simulation.context.getState().getStepCount() else: currentStep = 0 dummy_file.close() return currentStep
def test_Runner_openmm_forcefield(tmp_path): if not os.path.exists(tmp_path): os.mkdir(tmp_path) mymodel = make_test_model.make_test_model(tmp_path, mode="forcefield") #sim_openmm_factory = sim_openmm.Sim_openmm_factory() myanchor = mymodel.anchors[1] mmvt_output_filename = os.path.join( tmp_path, myanchor.name, "prod", "%s%d.%s" % (mmvt_base.OPENMMVT_BASENAME, 1, mmvt_base.OPENMMVT_EXTENSION)) runner = runner_openmm.Runner_openmm(mymodel, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare() my_sim_openmm = mmvt_sim_openmm.create_sim_openmm(mymodel, myanchor, mmvt_output_filename) runner.run(my_sim_openmm, False) assert os.path.exists(mmvt_output_filename) lines = 0 with open(mmvt_output_filename, "r") as f: for line in f: lines += 1
def choose_next_simulation_openmm(model, instruction, min_total_simulation_length, max_total_simulation_length, convergence_cutoff, minimum_anchor_transitions, force_overwrite, umbrella_restart_mode): """ Examine the model and all MD simulations that have run so far. Using this information, as well as the specified criteria (minimum number of steps, minimum convergence, maximum number of steps, etc.), construct a list of anchors to run, in order. """ import seekr2.modules.runner_openmm as runner_openmm import seekr2.modules.mmvt_sim_openmm as mmvt_sim_openmm import seekr2.modules.elber_sim_openmm as elber_sim_openmm if instruction == "any_bd": return [] anchor_info_to_run_unsorted = [] for alpha, anchor in enumerate(model.anchors): if anchor.bulkstate: continue if instruction not in ["any", "any_md"]: try: integer_instruction = int(instruction) except ValueError: return [] if alpha != integer_instruction: continue if min_total_simulation_length is None: if model.get_type() == "mmvt": min_total_simulation_length \ = model.calculation_settings.num_production_steps elif model.get_type() == "elber": min_total_simulation_length \ = model.calculation_settings.num_umbrella_stage_steps output_directory = os.path.join(model.anchor_rootdir, anchor.directory, anchor.production_directory) restart_checkpoint_filename = os.path.join( output_directory, runner_openmm.RESTART_CHECKPOINT_FILENAME) if os.path.exists(restart_checkpoint_filename) and not force_overwrite\ and not umbrella_restart_mode: dummy_file = tempfile.NamedTemporaryFile() if model.get_type() == "mmvt": sim_openmm_obj = mmvt_sim_openmm.create_sim_openmm( model, anchor, dummy_file.name) simulation = sim_openmm_obj.simulation elif model.get_type() == "elber": sim_openmm_obj = elber_sim_openmm.create_sim_openmm( model, anchor, dummy_file.name) simulation = sim_openmm_obj.umbrella_simulation simulation.loadCheckpoint(restart_checkpoint_filename) currentStep = int(math.ceil(simulation.context.getState().getTime()\ .value_in_unit(unit.picoseconds) \ / sim_openmm_obj.timestep)) dummy_file.close() restart = True else: currentStep = 0 restart = False if max_total_simulation_length is not None: if currentStep > max_total_simulation_length: # this simulation has run long enough continue # make sure that all simulations reach minimum number of steps # before sorting by convergence steps_to_go_to_minimum = min_total_simulation_length - currentStep if steps_to_go_to_minimum <= 0: data_sample_list = converge.converge(model) steps_to_go_to_minimum = 0 transition_minima, dummy \ = common_converge.calc_transition_steps( model, data_sample_list[-1]) num_transitions = transition_minima[alpha] if convergence_cutoff is not None: rmsd_convergence_results \ = common_converge.calc_RMSD_conv_amount( model, data_sample_list) convergence = rmsd_convergence_results[alpha] if convergence < float(convergence_cutoff): continue else: print("anchor", alpha, "has not reached the point of "\ "convergence:", convergence, "of", convergence_cutoff) total_simulation_length \ = (currentStep // CONVERGENCE_INTERVAL + 1) \ * CONVERGENCE_INTERVAL anchor_info = [ steps_to_go_to_minimum, num_transitions, alpha, restart, total_simulation_length ] anchor_info_to_run_unsorted.append(anchor_info) continue if minimum_anchor_transitions is not None: minimum_anchor_transitions = int(minimum_anchor_transitions) if num_transitions >= minimum_anchor_transitions: continue else: print("anchor", alpha, "has not had the minimum number of "\ "transitions:", num_transitions, "of", minimum_anchor_transitions) total_simulation_length = ( currentStep // CONVERGENCE_INTERVAL + 1) \ * (CONVERGENCE_INTERVAL) anchor_info = [ steps_to_go_to_minimum, num_transitions, alpha, restart, total_simulation_length ] anchor_info_to_run_unsorted.append(anchor_info) else: print("anchor", alpha, "has not run the minimum number of steps", currentStep, "of", min_total_simulation_length) total_simulation_length = min_total_simulation_length num_transitions = 0 anchor_info = [ steps_to_go_to_minimum, num_transitions, alpha, restart, total_simulation_length ] anchor_info_to_run_unsorted.append(anchor_info) # sort anchors first by how many steps still to run, then by how many # transitions have been completed. anchor_info_to_run = sorted( anchor_info_to_run_unsorted, key=lambda item: (min_total_simulation_length - item[0], item[1])) return anchor_info_to_run
def test_check_openmm_context_within_boundary(host_guest_mmvt_model, tmp_path): """ Test whether the check can find systems that exist outside the proper Voronoi cells. """ # Test check success: system starting within Voronoi cells anchor = host_guest_mmvt_model.anchors[0] output_file = os.path.join(tmp_path, "output.txt") host_guest_mmvt_model.openmm_settings.cuda_platform_settings = None host_guest_mmvt_model.openmm_settings.reference_platform = True my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( host_guest_mmvt_model, anchor, output_file) context = my_sim_openmm.simulation.context final_result = True for milestone in anchor.milestones: cv = host_guest_mmvt_model.collective_variables[milestone.cv_index] result = cv.check_openmm_context_within_boundary( context, milestone.variables, verbose=True) final_result = final_result and result assert final_result # Test check failure(s): system outside Voronoi cells anchor_pdb1 \ = host_guest_mmvt_model.anchors[0].amber_params.pdb_coordinates_filename anchor_pdb2 \ = host_guest_mmvt_model.anchors[1].amber_params.pdb_coordinates_filename anchor_pdb_src_path1 = os.path.join( host_guest_mmvt_model.anchor_rootdir, host_guest_mmvt_model.anchors[0].directory, host_guest_mmvt_model.anchors[0].building_directory, anchor_pdb1) anchor_pdb_src_path2 = os.path.join( host_guest_mmvt_model.anchor_rootdir, host_guest_mmvt_model.anchors[1].directory, host_guest_mmvt_model.anchors[1].building_directory, anchor_pdb2) anchor_pdb_dest_path1 = os.path.join( host_guest_mmvt_model.anchor_rootdir, host_guest_mmvt_model.anchors[0].directory, host_guest_mmvt_model.anchors[0].building_directory, anchor_pdb2) anchor_pdb_dest_path2 = os.path.join( host_guest_mmvt_model.anchor_rootdir, host_guest_mmvt_model.anchors[1].directory, host_guest_mmvt_model.anchors[1].building_directory, anchor_pdb1) shutil.copyfile(anchor_pdb_src_path1, anchor_pdb_dest_path2) shutil.copyfile(anchor_pdb_src_path2, anchor_pdb_dest_path1) host_guest_mmvt_model.anchors[0].amber_params.pdb_coordinates_filename \ = anchor_pdb2 host_guest_mmvt_model.anchors[1].amber_params.pdb_coordinates_filename \ = anchor_pdb1 my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( host_guest_mmvt_model, anchor, output_file) context = my_sim_openmm.simulation.context final_result = True for milestone in anchor.milestones: cv = host_guest_mmvt_model.collective_variables[milestone.cv_index] result = cv.check_openmm_context_within_boundary( context, milestone.variables, verbose=True) final_result = final_result and result assert not final_result return
def check_systems_within_Voronoi_cells(model): """ Users might provide the wrong starting structure for a given anchor, and the structure may actually belong in a different one. When the model defines Voronoi cells (such as in MMVT), check that the starting structures lie within the expected Voronoi cells, and suggest corrections if the check fails. Otherwise, the SEEKR2 backend would fail with a non-helpful error message. """ returning_result = True if model.get_type() != "mmvt": # only apply to MMVT systems return True curdir = os.getcwd() os.chdir(model.anchor_rootdir) for anchor in model.anchors: if model.using_toy(): if anchor.starting_positions is None: continue if len(anchor.starting_positions) == 0: continue tmp_path = tempfile.NamedTemporaryFile() output_file = tmp_path.name model.openmm_settings.cuda_platform_settings = None model.openmm_settings.reference_platform = True if model.get_type() == "mmvt": my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( model, anchor, output_file) context = my_sim_openmm.simulation.context else: my_sim_openmm = elber_sim_openmm.create_sim_openmm( model, anchor, output_file) context = my_sim_openmm.umbrella_simulation.context else: traj = load_structure_with_mdtraj(model, anchor) if traj is None: continue for milestone in anchor.milestones: cv = model.collective_variables[milestone.cv_index] if model.using_toy(): result = cv.check_openmm_context_within_boundary( context, milestone.variables, verbose=True) else: result = cv.check_mdtraj_within_boundary(traj, milestone.variables, verbose=True) if result == False: correct_anchor = None for anchor2 in model.anchors: within_milestones = True for milestone in anchor2.milestones: if anchor.__class__.__name__ \ in ["MMVT_toy_anchor", "Elber_toy_anchor"]: result2 = cv.check_openmm_context_within_boundary( context, milestone.variables, verbose=True) else: result2 = cv.check_mdtraj_within_boundary( traj, milestone.variables) if not result2: within_milestones = False break if within_milestones: correct_anchor = anchor2 break warnstr = """CHECK FAILURE: The provided initial starting structure for anchor {} does not lie within the anchor boundaries. The simulation would fail. Please carefully check this anchor's starting structure, as well as the collective variable's (CV) atom selections, and anchor/milestone variables.""".format(anchor.index) print(warnstr) if correct_anchor is not None: print("It looks like the failed structure might belong in "\ "anchor {}.".format(correct_anchor.index)) returning_result = False os.chdir(curdir) return returning_result
try: myanchor = model.anchors[anchor_index] except IndexError: print("Invalid anchor index provided.") exit() if cuda_device_index is not None: assert model.openmm_settings.cuda_platform_settings is not None model.openmm_settings.cuda_platform_settings.cuda_device_index = \ cuda_device_index if total_simulation_length is not None: model.calculation_settings.num_production_steps = \ total_simulation_length runner = Runner_openmm(model, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( restart, save_state_file, force_overwrite, umbrella_restart_mode) if output_file is None: output_file = default_output_file if model.get_type() == "mmvt": sim_openmm_obj = mmvt_sim_openmm.create_sim_openmm( model, myanchor, output_file, state_file_prefix) elif model.get_type() == "elber": sim_openmm_factory = elber_sim_openmm.create_sim_openmm( model, myanchor, output_file, state_file_prefix) model.calculation_settings.num_rev_launches = num_rev_launches runner.run(sim_openmm_obj, restart, load_state_file, restart_index)
def test_add_simulation(tmp_path, toy_mmvt_model): anchor = toy_mmvt_model.anchors[0] output_file = os.path.join(tmp_path, "output.txt") my_sim_openmm = mmvt_sim_openmm.create_sim_openmm( toy_mmvt_model, anchor, output_file) assert my_sim_openmm.simulation is not None
try: myanchor = model.anchors[anchor_index] except IndexError: print("Invalid anchor index provided.") exit() if cuda_device_index is not None: assert model.openmm_settings.cuda_platform_settings is not None model.openmm_settings.cuda_platform_settings.cuda_device_index = \ cuda_device_index if total_simulation_length is not None: model.calculation_settings.num_production_steps = \ total_simulation_length runner = Runner_openmm(model, myanchor) default_output_file, state_file_prefix, restart_index = runner.prepare( restart, save_state_file, force_overwrite, umbrella_restart_mode) if output_file is None: output_file = default_output_file if model.get_type() == "mmvt": sim_openmm_obj = mmvt_sim_openmm.create_sim_openmm( model, myanchor, output_file, state_file_prefix, frame=0, load_state_file=load_state_file) elif model.get_type() == "elber": sim_openmm_factory = elber_sim_openmm.create_sim_openmm( model, myanchor, output_file, state_file_prefix) model.calculation_settings.num_rev_launches = num_rev_launches runner.run(sim_openmm_obj, restart, load_state_file, restart_index)