@INIT_CONDS.clicked(required=False)
@N_STEPS_MC
def pathsampling(input_file, output_file, scheme, init_conds, nsteps):
"""General path sampling, using setup in INPUT_FILE"""
storage = INPUT_FILE.get(input_file)
pathsampling_main(output_storage=OUTPUT_FILE.get(output_file),
scheme=SCHEME.get(storage, scheme),
init_conds=INIT_CONDS.get(storage, init_conds),
n_steps=nsteps)
def pathsampling_main(output_storage, scheme, init_conds, n_steps):
import openpathsampling as paths
init_conds = scheme.initial_conditions_from_trajectories(init_conds)
simulation = paths.PathSampling(
storage=output_storage,
move_scheme=scheme,
sample_set=init_conds
)
simulation.run(n_steps)
if output_storage:
output_storage.tags['final_conditions'] = simulation.sample_set
return simulation.sample_set, simulation
PLUGIN = OPSCommandPlugin(
command=pathsampling,
section="Simulation",
requires_ops=(1, 0),
requires_cli=(0, 3)
)
def visit_all(input_file, output_file, state, engine, init_frame):
"""Run until initial trajectory for TPS/MSTPS/MSTIS achieved.
This runs until all given states have been visited. That creates a long
trajectory, subtrajectories of which will work for the initial
trajectories in TPS, MSTPS, or MSTIS. Typically, you'll use a different
engine from the TPS production engine (often high temperature).
"""
storage = INPUT_FILE.get(input_file)
visit_all_main(output_storage=OUTPUT_FILE.get(output_file),
states=STATES.get(storage, state),
engine=ENGINE.get(storage, engine),
initial_frame=INIT_SNAP.get(storage, init_frame))
def visit_all_main(output_storage, states, engine, initial_frame):
import openpathsampling as paths
timestep = getattr(engine, 'timestep', None)
visit_all_ens = paths.VisitAllStatesEnsemble(states, timestep=timestep)
trajectory = engine.generate(initial_frame, [visit_all_ens.can_append])
paths_cli.utils.tag_final_result(trajectory, output_storage,
'final_conditions')
return trajectory, None # no simulation object to return here
PLUGIN = OPSCommandPlugin(command=visit_all,
section="Simulation",
requires_ops=(1, 0),
requires_cli=(0, 3))
args = [engine, cv, volume, network, scheme, tag]
to_save = []
for arg, param in zip(args, params):
to_save.extend(param.get(storage, arg))
to_save = [obj for obj in to_save if obj is not None]
if save_tag is not None and len(to_save) != 1:
raise RuntimeError("Can't identify the object to tag when saving " +
str(len(to_save)) + " objects.")
for obj in to_save:
output_storage.save(obj)
if tag and len(tag) == 1 and save_tag is None:
save_tag = tag[0]
if save_tag:
output_storage.tags[save_tag] = to_save[0]
# TO TEST
# 3. "untag" an object by not associating a tag in the new storage
output_storage.close()
storage.close()
PLUGIN = OPSCommandPlugin(command=append,
section="Miscellaneous",
requires_ops=(1, 0),
requires_cli=(0, 3))
engine_hot=engine_hot,
initial_frame=INIT_SNAP.get(storage, init_frame),
nsteps=nsteps)
def one_pot_tps_main(output_storage, states, engine, engine_hot, initial_frame,
nsteps):
import openpathsampling as paths
network = paths.TPSNetwork.from_states_all_to_all(states)
scheme = paths.OneWayShootingMoveScheme(network=network,
selector=paths.UniformSelector(),
engine=engine)
trajectory, _ = visit_all_main(None, states, engine_hot, initial_frame)
equil_multiplier = 1
equil_extra = 0
equil_set, _ = equilibrate_main(None, scheme, trajectory, equil_multiplier,
equil_extra)
return pathsampling_main(output_storage, scheme, equil_set, nsteps)
# these lines enable this plugin to support OPS CLI < 0.3
CLI = one_pot_tps
SECTION = "Workflow"
REQUIRES_OPS = (1, 2)
# these lines enable this plugin to support OPS CLI >= 0.3
PLUGIN = OPSCommandPlugin(command=one_pot_tps,
section="Workflow",
requires_ops=(1, 2),
requires_cli=(0, 3))
import click
from paths_cli.wizard.plugin_registration import register_installed_plugins
from paths_cli.wizard.two_state_tps import TWO_STATE_TPS_WIZARD
from paths_cli import OPSCommandPlugin
@click.command(
'wizard',
short_help="run wizard for setting up simulations",
)
def wizard(): # no-cov
register_installed_plugins()
TWO_STATE_TPS_WIZARD.run_wizard()
PLUGIN = OPSCommandPlugin(command=wizard,
section="Simulation setup",
requires_ops=(1, 0),
requires_cli=(0, 3))
def register_installed_plugins():
plugin_types = (InstanceCompilerPlugin, CategoryPlugin)
plugins = get_installed_plugins(default_loader=NamespacePluginLoader(
'paths_cli.compiling', plugin_types),
plugin_types=plugin_types)
register_plugins(plugins)
@click.command(
'compile', )
@click.argument('input_file')
@OUTPUT_FILE.clicked(required=True)
def compile_(input_file, output_file):
loader = select_loader(input_file)
with open(input_file, mode='r') as f:
dct = loader(f)
register_installed_plugins()
objs = do_compile(dct)
print(f"Saving {len(objs)} user-specified objects to {output_file}....")
storage = OUTPUT_FILE.get(output_file)
storage.save(objs)
report_all_tables(storage)
PLUGIN = OPSCommandPlugin(command=compile_,
section="Debug",
requires_ops=(1, 0),
requires_cli=(0, 3))
def tps_main(engine, states, init_traj, output_storage, n_steps):
network = paths.TPSNetwork(initial_states=states, final_states=states)
scheme = paths.OneWayShootingMoveScheme(network, engine=engine)
initial_conditions = \
scheme.initial_conditions_from_trajectories(init_traj)
simulation = paths.PathSampling(
storage=output_storage,
move_scheme=scheme,
sample_set=initial_conditions
)
simulation.run(n_steps)
output_storage.tags['final_conditions'] = simulation.sample_set
return simulation.sample_set, simulation
# these lines enable this plugin to support OPS CLI < 0.3
CLI = tps
SECTION = "Simulation"
# these lines enable this plugin to support OPS CLI >= 0.3
PLUGIN = OPSCommandPlugin(
command=tps,
section="Simulation"
)
# this allows you to use this as a script, independently of the OPS CLI
if __name__ == "__main__":
tps()
"""
storage = INPUT_FILE.get(input_file)
equilibrate_main(output_storage=OUTPUT_FILE.get(output_file),
scheme=SCHEME.get(storage, scheme),
init_conds=INIT_CONDS.get(storage, init_conds),
multiplier=multiplier,
extra_steps=extra_steps)
def equilibrate_main(output_storage, scheme, init_conds, multiplier,
extra_steps):
import openpathsampling as paths
init_conds = scheme.initial_conditions_from_trajectories(init_conds)
scheme.assert_initial_conditions(init_conds)
simulation = paths.PathSampling(storage=output_storage,
move_scheme=scheme,
sample_set=init_conds)
simulation.run_until_decorrelated()
n_decorr = simulation.step
simulation.run(n_decorr * (multiplier - 1) + extra_steps)
if output_storage:
output_storage.tags['final_conditions'] = simulation.sample_set
output_storage.tags['equilibrated'] = simulation.sample_set
return simulation.sample_set, simulation
PLUGIN = OPSCommandPlugin(command=equilibrate,
section="Simulation",
requires_ops=(1, 2),
requires_cli=(0, 3))