def test_converge_incomplete_md_only_mmvt(toy_mmvt_model):
num_steps = 100000
toy_mmvt_model.openmm_settings.cuda_platform_settings = None
toy_mmvt_model.openmm_settings.reference_platform = True
toy_mmvt_model.openmm_settings.langevin_integrator.friction_coefficient \
= 100.0
toy_mmvt_model.calculation_settings.num_production_steps = num_steps
toy_mmvt_model.calculation_settings.energy_reporter_interval = num_steps
run.run(toy_mmvt_model, "any", force_overwrite=True)
runner_openmm.cleanse_anchor_outputs(toy_mmvt_model,
toy_mmvt_model.anchors[3])
cutoff = 0.1
minimum_anchor_transitions = 100
image_directory = common_analyze.make_image_directory(toy_mmvt_model, None)
k_on_state = None
data_sample_list = converge.converge(toy_mmvt_model,
k_on_state,
image_directory=image_directory,
verbose=True)
rmsd_convergence_results = common_converge.calc_RMSD_conv_amount(
toy_mmvt_model, data_sample_list)
transition_minima, transition_prob_results, transition_time_results \
= common_converge.calc_transition_steps(
toy_mmvt_model, data_sample_list[-1])
bd_transition_counts = data_sample_list[-1].bd_transition_counts
converge.print_convergence_results(toy_mmvt_model,
rmsd_convergence_results, cutoff,
transition_prob_results,
transition_time_results,
minimum_anchor_transitions,
bd_transition_counts)
return
def run_short_ci(model_input, cuda_device_index, long_check=True):
start_dir = os.getcwd()
model, xml_path = prepare.prepare(model_input, force_overwrite=False)
model_dir = os.path.dirname(xml_path)
model.anchor_rootdir = os.path.abspath(model_dir)
check.check_pre_simulation_all(model)
run.run(model,
"any",
min_b_surface_simulation_length=1000,
num_rev_launches=10,
cuda_device_index=cuda_device_index,
save_state_file=True)
data_sample_list = converge.converge(model, k_on_state=0)
rmsd_convergence_results = common_converge.calc_RMSD_conv_amount(
model, data_sample_list)
transition_minima, transition_details, transition_times \
= common_converge.calc_transition_steps(
model, data_sample_list[-1])
converge.print_convergence_results(
model,
rmsd_convergence_results,
cutoff=0.1,
transition_results=transition_details,
transition_time_results=transition_times,
minimum_anchor_transitions=10,
bd_transition_counts=data_sample_list[-1].bd_transition_counts)
check.check_post_simulation_all(model, long_check=long_check)
analysis = analyze.analyze(model)
analysis.print_results()
os.chdir(start_dir)
return
def test_converge_default_bd_only_mmvt(host_guest_mmvt_model):
model = host_guest_mmvt_model
bd_directory = os.path.join(host_guest_mmvt_model.anchor_rootdir,
"b_surface")
runner_browndye2.run_bd_top(model.browndye_settings.browndye_bin_dir,
bd_directory,
force_overwrite=True)
runner_browndye2.run_nam_simulation(
model.browndye_settings.browndye_bin_dir, bd_directory,
model.k_on_info.bd_output_glob)
cutoff = 0.1
minimum_anchor_transitions = 100
image_directory = common_analyze.make_image_directory(
host_guest_mmvt_model, None)
k_on_state = 0
data_sample_list = converge.converge(host_guest_mmvt_model,
k_on_state,
image_directory=image_directory,
verbose=True)
rmsd_convergence_results = common_converge.calc_RMSD_conv_amount(
host_guest_mmvt_model, data_sample_list)
transition_minima, transition_prob_results, transition_time_results \
= common_converge.calc_transition_steps(
host_guest_mmvt_model, data_sample_list[-1])
bd_transition_counts = data_sample_list[-1].bd_transition_counts
converge.print_convergence_results(host_guest_mmvt_model,
rmsd_convergence_results, cutoff,
transition_prob_results,
transition_time_results,
minimum_anchor_transitions,
bd_transition_counts)
return
def test_converge_default_md_only_elber(toy_elber_model):
num_steps = 100000
fwd_rev_interval = 100
toy_elber_model.openmm_settings.cuda_platform_settings = None
toy_elber_model.openmm_settings.reference_platform = True
toy_elber_model.openmm_settings.langevin_integrator.friction_coefficient \
= 100.0
toy_elber_model.calculation_settings.num_umbrella_stage_steps = num_steps
toy_elber_model.calculation_settings.fwd_rev_interval = fwd_rev_interval
run.run(toy_elber_model, "any")
cutoff = 0.1
minimum_anchor_transitions = 100
image_directory = common_analyze.make_image_directory(
toy_elber_model, None)
k_on_state = None
data_sample_list = converge.converge(toy_elber_model,
k_on_state,
image_directory=image_directory,
verbose=True)
rmsd_convergence_results = common_converge.calc_RMSD_conv_amount(
toy_elber_model, data_sample_list)
transition_minima, transition_prob_results, transition_time_results \
= common_converge.calc_transition_steps(
toy_elber_model, data_sample_list[-1])
bd_transition_counts = data_sample_list[-1].bd_transition_counts
converge.print_convergence_results(toy_elber_model,
rmsd_convergence_results, cutoff,
transition_prob_results,
transition_time_results,
minimum_anchor_transitions,
bd_transition_counts)
return
def test_calc_transition_steps_elber(toy_elber_model):
for anchor in toy_elber_model.anchors:
runner_openmm.cleanse_anchor_outputs(toy_elber_model, anchor)
anchor1 = toy_elber_model.anchors[1]
anchor1_output_filename = os.path.join(toy_elber_model.anchor_rootdir,
anchor1.directory,
anchor1.production_directory,
"forward.restart1.out")
copyfile(test_output_filename_elber, anchor1_output_filename)
image_directory = common_analyze.make_image_directory(
toy_elber_model, None)
data_sample_list = converge.converge(toy_elber_model,
0,
image_directory=image_directory,
verbose=True)
transition_minima, transition_prob_results, transition_time_results \
= common_converge.calc_transition_steps(
toy_elber_model, data_sample_list[-1])
for alpha, anchor in enumerate(toy_elber_model.anchors):
if anchor.bulkstate:
continue
if anchor.index == 1:
assert transition_minima[alpha] == 3
assert transition_prob_results[alpha][(1, 2)] == 5
assert transition_prob_results[alpha][(1, 0)] == 3
assert np.isclose(transition_time_results[alpha][1], (1.324 / 5))
else:
assert transition_minima[alpha] == 0
for key in transition_prob_results[alpha]:
assert transition_prob_results[alpha][key] == 0
for key in transition_time_results[alpha]:
assert transition_time_results[alpha][key] == 0
return
def choose_next_simulation_namd(model, instruction,
min_total_simulation_length,
max_total_simulation_length,
convergence_cutoff, minimum_anchor_transitions,
force_overwrite):
"""
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_namd as runner_namd
import seekr2.modules.mmvt_sim_namd as mmvt_sim_namd
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:
#print("Invalid argument for INSTRUCTION provided: "\
# "'{}'. ".format(instruction)\
# +"Allowed arguments: 'any', 'any_md', 'any_bd'.")
#exit()
return []
if alpha != integer_instruction:
continue
if min_total_simulation_length is None:
min_total_simulation_length \
= model.calculation_settings.num_production_steps
output_directory = os.path.join(model.anchor_rootdir, anchor.directory,
anchor.production_directory)
restart_checkpoint_filename = os.path.join(
output_directory, runner_namd.RESTART_CHECKPOINT_FILENAME + ".xsc")
if os.path.exists(restart_checkpoint_filename) and not force_overwrite:
currentStep = runner_namd.read_xsc_step_number(
restart_checkpoint_filename)
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_results, dummy \
= common_converge.calc_transition_steps(
model, data_sample_list[-1])
num_transitions = transition_results[alpha]
if convergence_cutoff is not None:
if model.get_type() == "mmvt":
rmsd_convergence_results \
= common_converge.calc_RMSD_conv_amount(
model, data_sample_list)
elif model.get_type() == "elber":
raise Exception("Elber auto-run not available.")
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 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
if model.get_type() == "mmvt":
end_milestones.append(milestone_id)
else:
if anchor.milestones[milestone_id].is_source_milestone:
end_milestones.append(milestone_id)
continue
assert len(end_milestones) > 0, "No end-state milestones for this "\
"model: k-on convergence cannot be computed."
print("All available options for --k_on_state include:",
end_milestones)
if k_on_state is None:
k_on_state = end_milestones[0]
print("No milestone has been provided for k_on_state. "\
"The milestone %d has been chosen by default." % k_on_state)
else:
assert k_on_state in end_milestones, "The provided "\
"milestone of %d for k_on_state is not available." % k_on_state
data_sample_list = converge(model,
k_on_state,
image_directory,
verbose=True)
rmsd_convergence_results = common_converge.calc_RMSD_conv_amount(
model, data_sample_list)
transition_minima, transition_details \
= common_converge.calc_transition_steps(
model, data_sample_list[-1])
print_convergence_results(model, rmsd_convergence_results, cutoff,
transition_details, minimum_anchor_transitions,
data_sample_list[-1].bd_transition_counts)
if anchor.milestones[milestone_id].is_source_milestone:
end_milestones.append(milestone_id)
continue
assert len(end_milestones) > 0, "No end-state milestones for this "\
"model: k-on convergence cannot be computed."
print("All available options for --k_on_state include:",
end_milestones)
if k_on_state is None:
k_on_state = end_milestones[0]
print("No BD milestone has been provided for k_on_state. "\
"The BD milestone %d has been chosen by default." \
% k_on_state)
else:
assert k_on_state in end_milestones, "The provided "\
"BD milestone of %d for k_on_state is not available." \
% k_on_state
data_sample_list = converge(model,
k_on_state,
image_directory,
verbose=True)
main_data_sample = data_sample_list[-1]
rmsd_convergence_results = common_converge.calc_RMSD_conv_amount(
model, data_sample_list)
transition_minima, transition_prob_results, transition_time_results \
= common_converge.calc_transition_steps(
model, main_data_sample)
bd_transition_counts = main_data_sample.bd_transition_counts
print_convergence_results(model, rmsd_convergence_results, cutoff,
transition_prob_results, transition_time_results,
minimum_anchor_transitions, bd_transition_counts)
