def setup(self): pes = paths.engines.toy.Gaussian(1, [1.0, 1.0], [0.0, 0.0]) integ = paths.engines.toy.LangevinBAOABIntegrator(0.01, 0.1, 2.5) topology = paths.engines.toy.Topology(n_spatial=2, n_atoms=1, masses=[1.0], pes=pes) self.engine = paths.engines.toy.Engine( options={ 'n_frames_max': 1000, 'n_steps_per_frame': 10, 'integ': integ }, topology=topology).named("engine") self.other_engine = paths.engines.toy.Engine(options={ 'n_frames_max': 5000, 'n_steps_per_frame': 1, 'integ': integ }, topology=topology) self.cv = paths.FunctionCV("x", lambda x: x.xyz[0][0]) self.state_A = paths.CVDefinedVolume(self.cv, float("-inf"), 0).named("A") self.state_B = paths.CVDefinedVolume(self.cv, 10, float("inf")).named("B") self.network = paths.TPSNetwork(self.state_A, self.state_B).named('network') self.scheme = paths.OneWayShootingMoveScheme( self.network, paths.UniformSelector(), self.engine).named("scheme") self.other_scheme = paths.OneWayShootingMoveScheme( self.network, paths.UniformSelector(), self.other_engine) self.tempdir = tempfile.mkdtemp()
def test_nan_rejected(self): stateA = paths.EmptyVolume() # will run indefinitely stateB = paths.EmptyVolume() tps = A2BEnsemble(stateA, stateB) self.engine.n_frames_max = 10 init_traj = paths.Trajectory([nan_causing_template] * 5) init_samp = paths.SampleSet([paths.Sample( trajectory=init_traj, replica=0, ensemble=tps )]) mover = paths.BackwardShootMover( ensemble=tps, selector=paths.UniformSelector(), engine=self.engine ) change = mover.move(init_samp) assert (isinstance(change, paths.RejectedNaNSampleMoveChange)) assert_equal(change.details.rejection_reason, 'nan') # since we shoot, we start with a shorter trajectory assert(len(change.samples[0].trajectory) < len(init_traj)) newsamp = init_samp.apply_samples(change) assert_equal(len(newsamp), 1) # make sure there is no change! assert_equal(init_samp[0].trajectory, init_traj)
def test_max_length_rejected(self): stateA = paths.EmptyVolume() # will run indefinitely stateB = paths.EmptyVolume() tps = A2BEnsemble(stateA, stateB) self.engine.options['n_frames_max'] = 10 self.engine.on_max_length = 'fail' init_traj = paths.Trajectory([template] * 5) init_samp = paths.SampleSet([paths.Sample( trajectory=init_traj, replica=0, ensemble=tps )]) mover = paths.BackwardShootMover( ensemble=tps, selector=paths.UniformSelector(), engine=self.engine ) change = mover.move(init_samp) assert(isinstance(change, paths.RejectedMaxLengthSampleMoveChange)) assert_equal(change.details.rejection_reason, 'max_length') assert_equal( len(change.samples[0].trajectory), self.engine.n_frames_max) newsamp = init_samp.apply_samples(change) assert_equal(len(newsamp), 1) # make sure there is no change! assert_equal(init_samp[0].trajectory, init_traj)
def tps_fixture(flat_engine, tps_network_and_traj): network, traj = tps_network_and_traj scheme = paths.OneWayShootingMoveScheme(network=network, selector=paths.UniformSelector(), engine=flat_engine) init_conds = scheme.initial_conditions_from_trajectories(traj) return (scheme, network, flat_engine, init_conds)
def test_in_shooting_move(self): for testfile in glob.glob("test*out") + glob.glob("test*inp"): os.remove(testfile) ens10 = paths.LengthEnsemble(10) init_traj = self.fast_engine.generate(self.template, [ens10.can_append]) assert_equal(ens10(init_traj), True) init_conds = paths.SampleSet( [paths.Sample(replica=0, ensemble=ens10, trajectory=init_traj)]) shooter = paths.OneWayShootingMover(ensemble=ens10, selector=paths.UniformSelector(), engine=self.fast_engine) prev_sample_set = init_conds default_traj = [[[0.0]], [[1.0]], [[2.0]], [[3.0]], [[4.0]], [[5.0]], [[6.0]], [[7.0]], [[8.0]], [[9.0]]] assert_items_equal(init_conds[0].trajectory.xyz, default_traj) for step in range(10): assert_equal(len(prev_sample_set), 1) change = shooter.move(prev_sample_set) new_sample_set = prev_sample_set.apply_samples(change.results) assert_items_equal(new_sample_set[0].trajectory.xyz, default_traj) prev_traj = prev_sample_set[0].trajectory new_traj = new_sample_set[0].trajectory shared = prev_traj.shared_configurations(new_traj) assert_true(0 < len(list(shared)) < len(new_traj)) prev_sample_set = new_sample_set for testfile in glob.glob("test*out") + glob.glob("test*inp"): os.remove(testfile)
def setup(self): paths.InterfaceSet._reset() self.cv = paths.FunctionCV("x", lambda x: x.xyz[0][0]) self.state_A = paths.CVDefinedVolume(self.cv, float("-inf"), 0.0) self.state_B = paths.CVDefinedVolume(self.cv, 1.0, float("inf")) pes = paths.engines.toy.LinearSlope([0, 0, 0], 0) integ = paths.engines.toy.LangevinBAOABIntegrator(0.01, 0.1, 2.5) topology = paths.engines.toy.Topology(n_spatial=3, masses=[1.0], pes=pes) self.engine = paths.engines.toy.Engine(options={'integ': integ}, topology=topology) interfaces = paths.VolumeInterfaceSet(self.cv, float("-inf"), [0.0, 0.1, 0.2]) network = paths.MISTISNetwork([(self.state_A, interfaces, self.state_B) ]) init_traj = make_1d_traj([-0.1, 0.2, 0.5, 0.8, 1.1]) scheme = paths.MoveScheme(network) scheme.append([ paths.strategies.OneWayShootingStrategy( selector=paths.UniformSelector(), engine=self.engine), paths.strategies.PathReversalStrategy(), paths.strategies.OrganizeByMoveGroupStrategy() ]) init_cond = scheme.initial_conditions_from_trajectories(init_traj) self.sim = PathSampling(storage=None, move_scheme=scheme, sample_set=init_cond)
def __init__(self, transition, snapshot, storage=None, engine=None, extra_interfaces=None, forbidden_states=None): super(FullBootstrapping, self).__init__(storage, engine) if extra_interfaces is None: extra_interfaces = list() if forbidden_states is None: forbidden_states = list() interface0 = transition.interfaces[0] ensemble0 = transition.ensembles[0] state = transition.stateA self.state = state self.first_traj_ensemble = paths.SequentialEnsemble([ paths.OptionalEnsemble(paths.AllOutXEnsemble(state)), paths.AllInXEnsemble(state), paths.OptionalEnsemble( paths.AllOutXEnsemble(state) & paths.AllInXEnsemble(interface0) ), paths.OptionalEnsemble(paths.AllInXEnsemble(interface0)), paths.AllOutXEnsemble(interface0), paths.OptionalEnsemble(paths.AllOutXEnsemble(state)), paths.SingleFrameEnsemble(paths.AllInXEnsemble(state)) ]) & paths.AllOutXEnsemble(paths.join_volumes(forbidden_states)) self.extra_ensembles = [paths.TISEnsemble(transition.stateA, transition.stateB, iface, transition.orderparameter) for iface in extra_interfaces ] self.transition_shooters = [ paths.OneWayShootingMover(selector=paths.UniformSelector(), ensemble=ens) for ens in transition.ensembles ] self.extra_shooters = [ paths.OneWayShootingMover(selector=paths.UniformSelector(), ensemble=ens) for ens in self.extra_ensembles ] self.snapshot = snapshot.copy() self.ensemble0 = ensemble0 self.all_ensembles = transition.ensembles + self.extra_ensembles self.n_ensembles = len(self.all_ensembles) self.error_max_rounds = True
def __init__(self, selector=None, ensembles=None, engine=None, group="shooting", replace=True): super(OneWayShootingStrategy, self).__init__( ensembles=ensembles, group=group, replace=replace ) if selector is None: selector = paths.UniformSelector() self.selector = selector self.engine = engine
def __init__(self, multiple_binding_ensemble, subselector=None): self.multiple_binding_ensemble = multiple_binding_ensemble if subselector is None: subselector = paths.UniformSelector() self.subselector = subselector # cache the previously tested trajectory and the resulting # subtrajectory. This avoids wasteful recalc for most cases of # multiple use of `f`, `pick`, `sum_bias` for the same input traj self._cached_subtraj = paths.Trajectory([]) self._cached_traj = paths.Trajectory([])
def shoot_until_A_to_A(initial_ensemble, desired_ensemble, sample, engine): # we only shoot forward because we know the final frame is the problem mover = paths.ForwardShootMover(ensemble=initial_ensemble, selector=paths.UniformSelector(), engine=engine) while not desired_ensemble(sample): change = mover.move_core([sample]) if desired_ensemble(change.trials[0]): sample = change.trials[0] return sample
def __init__(self, ensemble, selector=None, engine=None, pre_joined=True): super(ShootingStub, self).__init__() if engine is None: engine = NoEngine() if selector is None: selector = paths.UniformSelector() # default self.engine = engine self.selector = selector self.ensemble = ensemble self.pre_joined = pre_joined self.mimic = paths.OneWayShootingMover(ensemble, selector, engine)
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)
def test_tps_scheme(tps_network, toy_engine, as_scheme): wizard = mock_wizard([]) wizard.networks = {tps_network.name: tps_network} if as_scheme: strategy = partial(paths.SpringShootingMoveScheme, k_spring=0.01, delta_max=10, engine=toy_engine) else: strategy = strategies.OneWayShootingStrategy( selector=paths.UniformSelector(), engine=toy_engine) with mock.patch('paths_cli.wizard.tps.shooting', new=mock.Mock(return_value=strategy)): scheme = tps_scheme(wizard) assert isinstance(scheme, paths.MoveScheme) if as_scheme: assert isinstance(scheme, paths.SpringShootingMoveScheme)
def __init__(self, storage, network, initial_file, topology_file, options=None, options_rejected=None): self.topology_file = topology_file mover = oink.ShootingStub(ensemble=network.sampling_ensembles[0], selector=paths.UniformSelector(), pre_joined=False) super(GromacsOneWayTPSConverter, self).__init__(storage=storage, network=network, initial_file=initial_file, mover=mover, options=options, options_rejected=options_rejected)
# # 1. Create a `network` # 2. Create a `move_scheme` # 3. Set up `initial_conditions` # 4. Create the `PathSampling` object and run it. # # Since we already created all the input to these when we set up the first trajectory, we can load use the versions we loaded above. # In[5]: network = paths.TPSNetwork(C_7eq, alpha_R) # In[6]: scheme = paths.OneWayShootingMoveScheme(network, selector=paths.UniformSelector(), engine=engine) # In[7]: initial_conditions = scheme.initial_conditions_from_trajectories(traj) # In[8]: storage = paths.Storage("alanine_dipeptide_tps.nc", "w", template) sampler = paths.PathSampling(storage=storage, move_scheme=scheme, sample_set=initial_conditions) # Note: 10000 steps will take a long time. If you just want to run a little bit, reduce this number.
def uniform_selector(wizard): """Create a uniform selector (using the wizard)""" import openpathsampling as paths return paths.UniformSelector()