def test_save_scheme(self, tmpdir):
filename = tmpdir.join("temp.db")
storage = Storage(filename, mode='w')
assert len(storage.schemes) == 0
sim = paths.PathSampling(storage=storage,
move_scheme=self.scheme,
sample_set=self.init_cond)
assert len(storage.schemes) == 1
def test_save_initial_scheme(self, tmpdir):
# check that we actually save scheme when we save this
filename = tmpdir.join("temp.nc")
storage = paths.Storage(str(filename), mode='w')
assert len(storage.schemes) == 0
sim = paths.PathSampling(storage=storage,
move_scheme=self.scheme,
sample_set=self.init_cond)
assert len(storage.schemes) == 1
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
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
def test_integration(self):
simulation = paths.PathSampling(storage=None,
sample_set=paths.SampleSet([]),
move_scheme=MagicMock())
simulation.live_visualizer = MagicMock()
simulation.run_hooks('before_simulation', sim=simulation) # prep
simulation.run_hooks('after_step',
sim=simulation,
step_number=1,
step_info=(1, 100),
state=simulation.sample_set,
results=MagicMock(),
hook_state={})
simulation.live_visualizer.draw_ipynb.assert_called_once()
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
def run_example(nsteps, setup, output_filename):
engine, network, snapshots = setup()
minus, outers = zip(*[prep_from_frame(network, init_frame, engine)
for init_frame in snapshots])
minus = sum([list(m) for m in minus], [])
outers = sum([list(o) for o in outers], [])
scheme = paths.DefaultScheme(network, engine=engine)
print("Loading initial conditions with outermost trajs")
init_conds = scheme.initial_conditions_from_trajectories(outers)
print("Loading initial conditions with minus trajs")
init_conds = scheme.initial_conditions_from_trajectories(
minus, sample_set=init_conds
)
storage = paths.Storage(output_filename, mode='w')
simulation = paths.PathSampling(
storage=storage,
move_scheme=scheme,
sample_set=init_conds
)
simulation.save_frequency = 50
simulation.run(nsteps)
storage.close()
def test_non_shooting_steps(self):
network = paths.TPSNetwork(self.left, self.right)
init_traj = make_1d_traj([-1.1, 0.0, 1.1])
ensemble = network.all_ensembles[0]
mover = paths.PathReversalMover(ensemble)
scheme = paths.LockedMoveScheme(mover, network)
init_conds = scheme.initial_conditions_from_trajectories([init_traj])
assert_equal(len(init_conds), 1)
self.storage.close()
self.storage = paths.Storage(self.filename, "w")
assert_equal(init_conds[ensemble].trajectory, init_traj)
sim = paths.PathSampling(storage=self.storage,
move_scheme=scheme,
sample_set=init_conds)
sim.output_stream = open(os.devnull, "w")
sim.run(1)
step0 = self.storage.steps[0]
step1 = self.storage.steps[1]
assert_equal(self.analyzer.step_key(step0), None)
assert_equal(self.analyzer.step_key(step1), None)
assert_equal(self.analyzer.analyze_single_step(step0), [])
assert_equal(self.analyzer.analyze_single_step(step1), [])
# 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.
# In[9]:
#sampler.live_visualizer = paths.StepVisualization2D(network, phi, psi, [-3.14, 3.14], [-3.14, 3.14])
sampler.run(n_steps)
# With this done, you can go on to do the flexible-length parts of the analysis in `alanine_dipeptide_tps_analysis.ipynb`.
cv_wrap_numpy_array=True).with_diskcache()
# Defining the states
rmax = 4.5 * unit.nanometer
rmin = -2.5 * unit.nanometer
entrance = paths.CVDefinedVolume(cv_r_p, lambda_min=-2.5,
lambda_max=-0.5).named("entrance")
exit = paths.CVDefinedVolume(cv_r_p, lambda_min=2.0,
lambda_max=4.5).named("exit")
# Setting up the transition network and move scheme
network = paths.TPSNetwork(entrance, exit)
scheme = paths.OneWayShootingMoveScheme(network,
selector=paths.UniformSelector(),
engine=engine)
mdtraj_t = md.load('../../arg/smd.nc', top=topology)
ops_trajectory = trajectory_from_mdtraj(mdtraj_t)
# take the subtrajectory matching the ensemble (only one ensemble, only one subtraj)
subtrajectories = []
for ens in network.analysis_ensembles:
subtrajectories += ens.split(ops_trajectory)
init_cond = scheme.initial_conditions_from_trajectories(
trajectories=subtrajectories)
sim = paths.PathSampling(storage=paths.Storage("one-way-shooting.nc", "w",
template),
move_scheme=scheme,
sample_set=init_cond)
sim.run(90)
# sset = scheme.initial_conditions_from_trajectories(initial_trajectories)
# print scheme.initial_conditions_report(sset)
#
# # Populate minus ensemble
# print('Populating the minus ensemble')
# minus_samples = []
# for minus in mistis.minus_ensembles:
# samp = minus.extend_sample_from_trajectories(
# trajectories=sset,
# replica=-mistis.minus_ensembles.index(minus)-1,
# engine=engine
# )
# minus_samples.append(samp)
#
# sset = sset.apply_samples(minus_samples)
# print scheme.initial_conditions_report(sset)
else:
raise Exception('initial trajectory method "%s" unknown' %
initial_trajectory_method)
print('Running MISTIS')
mistis_calc = paths.PathSampling(storage=storage,
move_scheme=scheme,
sample_set=sset)
mistis_calc.save_frequency = 100
import logging.config
logging.config.fileConfig("logging.conf", disable_existing_loggers=False)
mistis_calc.run(1000)
])
initial_conditions = scheme.initial_conditions_from_trajectories(trajectory)
# use this for debugging the equilibration
# equil_store = paths.Storage('equil.nc', 'w')
equil_store = None
# update the user on what we're doing
equil_str = "Running 1000 steps of equilibration."
if equil_store is None:
equil_str += " Not saving equilibration steps."
print(equil_str)
equil_sim = paths.PathSampling(storage=equil_store,
move_scheme=scheme,
sample_set=initial_conditions)
equil_sim.status_update_frequency = 500
equil_sim.run(1000)
equil_conditions = equil_sim.sample_set
# this should be a decorrelated trajectory
equil_traj = equil_conditions[0].trajectory
init_traj = initial_conditions[0].trajectory
assert(not equil_traj.is_correlated(init_traj))
print("Setting up the full simulation and running " + str(n_steps)
+ " steps.")
simulation = paths.PathSampling(
# make subtrajectories into initial conditions (trajectories become a sampleset)
initial_conditions = scheme.initial_conditions_from_trajectories(subtrajectories)
# In[16]:
# check that initial conditions are valid and complete (raise AssertionError otherwise)
scheme.assert_initial_conditions(initial_conditions)
# In[17]:
sampler = paths.PathSampling(storage=paths.Storage("alanine_dipeptide_tps_equil.nc", "w", template),
move_scheme=scheme,
sample_set=initial_conditions)
sampler.live_visualizer = paths.StepVisualizer2D(network, phi, psi, [-3.14, 3.14], [-3.14, 3.14])
# In[18]:
# initially, these trajectories are correlated (actually, identical)
# once decorrelated, we have a (somewhat) reasonable 300K trajectory
initial_conditions[0].trajectory.is_correlated(sampler.sample_set[0].trajectory)
# In[19]: