@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))