def setup(self):
if os.path.isfile(data_filename(self.fname)):
os.remove(data_filename(self.fname))
setup_storage = paths.Storage(data_filename("tps_setup.nc"), "r")
network = setup_storage.networks[0]
tps_ensemble = network.sampling_ensembles[0]
initial_sample = paths.Sample(
replica=0,
trajectory=common.initial_tps_sample.trajectory,
ensemble=tps_ensemble
)
template = initial_sample.trajectory[0]
setup_storage.close()
shoot = oink.ShootingStub(tps_ensemble)
self.storage = paths.Storage(data_filename(self.fname), "w",
template)
self.pseudosim = oink.ShootingPseudoSimulator(
storage=self.storage,
initial_conditions=paths.SampleSet([initial_sample]),
mover=shoot,
network=network
)
nojoin = oink.ShootingStub(tps_ensemble, pre_joined=False)
self.nojoin_pseudosim = oink.ShootingPseudoSimulator(
storage=self.storage,
initial_conditions=paths.SampleSet([initial_sample]),
mover=nojoin,
network=network
)
def setup(self):
super(TestINIT_CONDS, self).setup()
self.traj = make_1d_traj([-0.1, 1.0, 4.4, 7.7, 10.01])
ensemble = self.scheme.network.sampling_ensembles[0]
self.sample_set = paths.SampleSet(
[paths.Sample(trajectory=self.traj, replica=0, ensemble=ensemble)])
self.other_traj = make_1d_traj([-1.0, 1.0, 100.0])
self.other_sample_set = paths.SampleSet([
paths.Sample(trajectory=self.other_traj,
replica=0,
ensemble=ensemble)
])
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_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 _make_active(self, seq):
traj = make_1d_traj(seq)
sample = paths.Sample(replica=0,
trajectory=traj,
ensemble=self.ensemble)
sample_set = paths.SampleSet(sample)
return sample_set
def collapsed_samples(self):
"""
Return a collapsed set of samples with non used samples removed
This is the minimum required set of samples to keep the `MoveChange`
correct and allow to target sampleset to be correctly created.
These are the samples used by `.closed`
Examples
--------
Assume that you run 3 shooting moves for replica #1. Then only the
last of the three really matters for the target sample_set since #1
will be replaced by #2 which will be replaced by #3. So this function
will return only the last sample.
"""
if self._collapsed is None:
s = paths.SampleSet([]).apply_samples(self.results)
# keep order just for being thorough
self._collapsed = [
samp for samp in self.results
if samp in s
]
return self._collapsed
def __init__(
self,
storage,
move_scheme=None,
sample_set=None,
initialize=True
):
"""
Parameters
----------
storage : :class:`openpathsampling.storage.Storage`
the storage where all results should be stored in
move_scheme : :class:`openpathsampling.MoveScheme`
the move scheme used for the pathsampling cycle
sample_set : :class:`openpathsampling.SampleSet`
the initial SampleSet for the Simulator
initialize : bool
if `False` the new PathSimulator will continue at the step and
not create a new SampleSet object to cut the connection to previous
steps
"""
super(PathSampling, self).__init__(storage)
self.move_scheme = move_scheme
if move_scheme is not None:
self.root_mover = move_scheme.move_decision_tree()
self._mover = paths.PathSimulatorMover(self.root_mover, self)
else:
self.root_mover = None
self._mover = None
initialization_logging(init_log, self,
['move_scheme', 'sample_set'])
self.live_visualizer = None
self.status_update_frequency = 1
if initialize:
samples = []
if sample_set is not None:
for sample in sample_set:
samples.append(sample.copy_reset())
self.sample_set = paths.SampleSet(samples)
mcstep = MCStep(
simulation=self,
mccycle=self.step,
active=self.sample_set,
change=paths.AcceptedSampleMoveChange(self.sample_set.samples)
)
self._current_step = mcstep
else:
self.sample_set = sample_set
self._current_step = None
self.root = self.sample_set
if self.storage is not None:
self.save_current_step()
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 run(self, n_per_snapshot, as_chain=False):
"""Run the simulation.
Parameters
----------
n_per_snapshot : int
number of shots per snapshot
as_chain : bool
if as_chain is False (default), then the input to the modifier
is always the original snapshot. If as_chain is True, then the
input to the modifier is the previous (modified) snapshot.
Useful for modifications that can't cover the whole range from a
given snapshot.
"""
self.step = 0
snap_num = 0
for snapshot in self.initial_snapshots:
start_snap = snapshot
# do what we need to get the snapshot set up
for step in range(n_per_snapshot):
paths.tools.refresh_output(
"Working on snapshot %d / %d; shot %d / %d" % (
snap_num+1, len(self.initial_snapshots),
step+1, n_per_snapshot
),
output_stream=self.output_stream,
refresh=self.allow_refresh
)
if as_chain:
start_snap = self.randomizer(start_snap)
else:
start_snap = self.randomizer(snapshot)
sample_set = paths.SampleSet([
paths.Sample(replica=0,
trajectory=paths.Trajectory([start_snap]),
ensemble=self.starting_ensemble)
])
sample_set.sanity_check()
new_pmc = self.mover.move(sample_set)
samples = new_pmc.results
new_sample_set = sample_set.apply_samples(samples)
mcstep = MCStep(
simulation=self,
mccycle=self.step,
previous=sample_set,
active=new_sample_set,
change=new_pmc
)
if self.storage is not None:
self.storage.steps.save(mcstep)
if self.step % self.save_frequency == 0:
self.sync_storage()
self.step += 1
snap_num += 1
def _make_null_mover_step(mccycle, path_sim_mover, null_mover):
empty_sample_set = paths.SampleSet([])
change = paths.PathSimulatorMoveChange(
mover=path_sim_mover, subchange=null_mover.move(empty_sample_set))
step = paths.MCStep(mccycle=mccycle,
active=empty_sample_set,
change=change)
return step
def setup(self):
self.mytraj = make_1d_traj(coordinates=[-0.5, 0.1, 0.2, 0.3, 0.5],
velocities=[1.0, 1.0, 1.0, 1.0, 1.0])
self.dyn = CalvinistDynamics(
[-0.5, -0.4, -0.3, -0.2, -0.1, 0.1, 0.2, 0.3, 0.4, 0.5])
self.dyn.initialized = True
self.initial_guess = 3
self.ens = paths.LengthEnsemble(5)
self.ges = paths.SampleSet(
paths.Sample(replica=0, trajectory=self.mytraj, ensemble=self.ens))
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 __init__(
self,
storage,
engine=None,
movers=None,
trajectory=None,
ensembles=None
):
"""
Parameters
----------
storage : openpathsampling.storage.Storage
the storage all results should be stored in
engine : openpathsampling.DynamicsEngine
the dynamics engine to be used
movers : list of openpathsampling.PathMover
list of shooters to be used in the BootstrapPromotionMove
trajectory : openpathsampling.Trajectory
an initial trajectory to be started from
ensembles : nested list of openpathsampling.Ensemble
the ensembles this move should act on
"""
# TODO: Change input from trajectory to sample
super(Bootstrapping, self).__init__(storage)
self.engine = engine
paths.EngineMover.default_engine = engine # set the default
self.ensembles = ensembles
self.trajectory = trajectory
sample = paths.Sample(
replica=0,
trajectory=trajectory,
ensemble=self.ensembles[0]
)
self.sample_set = paths.SampleSet([sample])
if movers is None:
pass # TODO: implement defaults: one per ensemble, uniform sel
else:
self.movers = movers
initialization_logging(init_log, self,
['movers', 'ensembles'])
init_log.info("Parameter: %s : %s", 'trajectory', str(trajectory))
self._bootstrapmove = BootstrapPromotionMove(
bias=None,
shooters=self.movers,
ensembles=self.ensembles
)
def check_ensembles(self, ensembles):
"""
Check for missing or extra ensembles in the sampleset
This is primary used programmatically as a reusable function for
several use cases where we need this information. See functions
under "see also" for examples of such cases.
Parameters
----------
ensembles : list of :class:`Ensemble` or list of :class:`Ensemble`
the list of ensembles to be generated. If an element is itself a
list then one sample for one of the ensembles in that list if
generated
Returns
-------
missing : list of list of :class:`.Ensemble`
ensembles needed by the move scheme and missing in the sample
set, in the format used by `list_initial_ensembles`
extra : list of :class:`.Ensemble`
ensembles in the sampleset that are not used by the
See Also
--------
MoveScheme.list_initial_ensembles
MoveScheme.assert_initial_conditions
MoveScheme.initial_conditions_report
"""
samples = paths.SampleSet(self) # to make a copy
missing = []
for ens_list in ensembles:
if type(ens_list) is not list:
ens_list = [ens_list]
sample = None
for ens in ens_list:
if ens in samples.ensemble_list():
sample = samples[ens]
break
if sample is not None:
del samples[sample]
else:
missing.append(ens_list)
# missing, extra
return missing, samples.ensemble_list()
def setup(self):
# create the network
paths.InterfaceSet._reset()
xval = paths.FunctionCV(name="xA", f=lambda s: s.xyz[0][0])
self.stateA = paths.CVDefinedVolume(xval, -1.0, -0.5).named("A")
self.stateB = paths.CVDefinedVolume(xval, 0.5, float("inf")).named("B")
ifacesA = paths.VolumeInterfaceSet(xval, float(-1.0),
[-0.5, -0.4, -0.3, -0.2])
self.network = paths.MISTISNetwork([(self.stateA, ifacesA, self.stateB)
])
transition = self.network.transitions[(self.stateA, self.stateB)]
ensembles = transition.ensembles
self.xval = xval
self.ifacesA = ifacesA
# create the biases
bias_table = {}
bias_table[ensembles[0]] = 1.0
bias_table[ensembles[1]] = 0.5
bias_table[ensembles[2]] = 0.2
self.bias = BiasEnsembleTable.ratios_from_dictionary(bias_table)
# samples, moves, changes
traj = make_1d_traj(
[-0.55, -0.45, -0.35, -0.25, -0.15, -0.26, -0.36, -0.46, -0.56])
s0 = paths.Sample(replica=0, ensemble=ensembles[0], trajectory=traj)
s1 = paths.Sample(replica=1, ensemble=ensembles[1], trajectory=traj)
s2 = paths.Sample(replica=2, ensemble=ensembles[2], trajectory=traj)
self.sample_set = paths.SampleSet([s0, s1, s2])
self.sample_set.sanity_check()
move_01 = paths.EnsembleHopMover(ensembles[0], ensembles[1])
move_02 = paths.EnsembleHopMover(ensembles[0], ensembles[2])
move_12 = paths.EnsembleHopMover(ensembles[1], ensembles[2])
move_21 = paths.EnsembleHopMover(ensembles[2], ensembles[1])
move_20 = paths.EnsembleHopMover(ensembles[2], ensembles[0])
move_10 = paths.EnsembleHopMover(ensembles[1], ensembles[0])
# NOTE: all changes here are accepted
self.change_01 = move_01.move(self.sample_set)
self.change_02 = move_02.move(self.sample_set)
self.change_12 = move_12.move(self.sample_set)
self.change_21 = move_21.move(self.sample_set)
self.change_20 = move_20.move(self.sample_set)
self.change_10 = move_10.move(self.sample_set)
# convenience lists for changes going outward vs. inward
self.out_changes = [self.change_01, self.change_02, self.change_12]
self.in_changes = [self.change_10, self.change_20, self.change_21]
def test_missing_ctp(self):
ensembles_AB = self.sampling_ensembles_for_transition(
self.mistis, self.state_A, self.state_B
)
ensembles_BA = self.sampling_ensembles_for_transition(
self.mistis, self.state_B, self.state_A
)
all_ensembles = ensembles_AB + ensembles_BA
replicas = range(len(all_ensembles))
set_trajectories = [self.trajs_AB[2]]*3 + [self.trajs_BA[2]]*3
zipped = list(zip(set_trajectories, all_ensembles, replicas))
mover_stub_mistis = MoverWithSignature(self.mistis.all_ensembles,
self.mistis.all_ensembles)
sample_sets = []
n_steps = 3
for step in range(n_steps):
sample_set = paths.SampleSet([
paths.Sample(trajectory=traj,
ensemble=ens,
replica=rep)
for (traj, ens, rep) in zipped
])
sample_set.sanity_check()
sample_sets.append(sample_set)
steps = self._make_fake_steps(sample_sets, mover_stub_mistis)
for transition in self.mistis.transitions.values():
max_lambda_calc = FullHistogramMaxLambdas(
transition=transition,
hist_parameters={'bin_width': 0.1, 'bin_range': (-0.1, 1.1)}
)
std_tp = StandardTransitionProbability(
transition=transition,
tcp_method=TotalCrossingProbability(max_lambda_calc),
ctp_method=ConditionalTransitionProbability(
ensembles=[transition.ensembles[-1]],
states=[self.state_A, self.state_B]
)
)
results = std_tp.calculate(steps)
assert_almost_equal(results, 0.0)
def _make_fake_minus_steps(self, scheme, descriptions):
network = scheme.network
state_adjustment = {
self.state_A: lambda x: x,
self.state_B: lambda x: 1.0 - x
}
minus_ensemble_to_mover = {m.minus_ensemble: m
for m in scheme.movers['minus']}
assert_equal(set(minus_ensemble_to_mover.keys()),
set(network.minus_ensembles))
steps = []
mccycle = 0
for minus_traj in descriptions:
for i, minus_ensemble in enumerate(network.minus_ensembles):
replica = -1 - i
adjustment = state_adjustment[minus_ensemble.state_vol]
traj = make_1d_traj([adjustment(s) for s in minus_traj])
assert_equal(minus_ensemble(traj), True)
samp = paths.Sample(trajectory=traj,
ensemble=minus_ensemble,
replica=replica)
sample_set = paths.SampleSet([samp])
change = paths.AcceptedSampleMoveChange(
samples=[samp],
mover=minus_ensemble_to_mover[samp.ensemble],
details=paths.Details()
)
# NOTE: this makes it so that only one ensemble is
# represented in the same set at any time, which isn't quite
# how it actually works. However, this is doesn't matter for
# the current implementation
steps.append(paths.MCStep(mccycle=mccycle,
active=sample_set,
change=change))
mccycle += 1
assert_equal(len(steps), 4)
return steps
def _make_acceptance_mock_step(mccycle,
accepted,
path_sim_mover,
move_type,
mover_sig,
submover_num=None):
root_mover = path_sim_mover.mover
chooser_names = {m.name[:-7].lower(): m for m in root_mover.movers}
chooser = chooser_names[move_type]
sig_to_mover = {
frozenset(m.ensemble_signature[0]): m
for m in chooser.movers
}
# group_mover = chooser.movers[mover_num]
group_mover = sig_to_mover[frozenset(mover_sig)]
Change = {
True: paths.AcceptedSampleMoveChange,
False: paths.RejectedSampleMoveChange
}[accepted]
# foo here is because we need non-empty samples to show that we're
# actually accepted or not (WHY?!?!?)
if submover_num is not None:
submover = group_mover.movers[submover_num]
submover_change = Change(samples=['foo'], mover=submover)
group_mover_change = paths.RandomChoiceMoveChange(
subchange=submover_change, mover=group_mover)
else:
submover_change = None
group_mover_change = Change(samples=['foo'], mover=group_mover)
chooser_change = paths.RandomChoiceMoveChange(subchange=group_mover_change,
mover=chooser)
root_mover_change = paths.RandomChoiceMoveChange(subchange=chooser_change,
mover=root_mover)
path_sim_change = paths.PathSimulatorMoveChange(
subchange=root_mover_change, mover=path_sim_mover)
step = paths.MCStep(mccycle=mccycle,
active=paths.SampleSet([]),
change=path_sim_change)
return step
def __init__(
self,
storage,
engine=None,
move_scheme=None,
globalstate=None
):
"""
Parameters
----------
storage : openpathsampling.storage.Storage
the storage where all results should be stored in
engine : openpathsampling.DynamicsEngine
the engine to be used with shooting moves
move_scheme : openpathsampling.MoveScheme
the move scheme used for the pathsampling cycle
globalstate : openpathsampling.SampleSet
the initial SampleSet for the Simulator
"""
super(PathSampling, self).__init__(storage, engine)
self.move_scheme = move_scheme
self.root_mover = move_scheme.move_decision_tree()
# self.move_scheme.name = "PathSamplingRoot"
samples = []
if globalstate is not None:
for sample in globalstate:
samples.append(sample.copy_reset())
self.globalstate = paths.SampleSet(samples)
self.root = self.globalstate
initialization_logging(init_log, self,
['move_scheme', 'globalstate'])
self.live_visualization = None
self.visualize_frequency = 1
self._mover = paths.PathSimulatorMover(self.root_mover, self)
def _make_fake_sampling_sets(self, network):
ensembles_AB = self.sampling_ensembles_for_transition(
network, self.state_A, self.state_B
)
ensembles_BA = self.sampling_ensembles_for_transition(
network, self.state_B, self.state_A
)
all_ensembles = ensembles_AB + ensembles_BA
replicas = range(len(all_ensembles))
# This encodes how the SampleSets are at each time step. This is the
# trajectory number (from trajs_AB/trajs_BA) for each ensemble
# (index order of sampling_AB.ensembles + sampling_BA.ensembles)
descriptions = [
[2, 3, 3, 2, 3, 3],
[1, 2, 3, 1, 2, 3],
[0, 1, 2, 0, 1, 2],
[0, 1, 2, 0, 1, 2]
]
# here's the fancy fake data
sample_sets = []
for descr in descriptions:
set_trajectories = ([self.trajs_AB[d] for d in descr[:3]]
+ [self.trajs_BA[d] for d in descr[3:]])
zipped = zip(set_trajectories, all_ensembles, replicas)
sample_set = paths.SampleSet([
paths.Sample(trajectory=traj,
ensemble=ens,
replica=rep)
for (traj, ens, rep) in zip(set_trajectories, all_ensembles,
range(len(all_ensembles)))
])
sample_sets.append(sample_set)
return sample_sets
def __init__(self,
storage,
initial_file,
mover,
network,
options=None,
options_rejected=None):
# TODO: mke the initial file into an initial trajectory
if options is None:
options = TPSConverterOptions()
if options_rejected is None:
options_rejected = options
self.options = options
self.options_rejected = options_rejected
self.initial_file = initial_file # needed for restore
traj = self.load_trajectory(initial_file)
# assume we're TPS here
ensemble = network.sampling_ensembles[0]
initial_trajectories = ensemble.split(traj)
if len(initial_trajectories) == 0: # pragma: no cover
raise RuntimeError("Initial trajectory in " + str(initial_file) +
" has no subtrajectory satisfying the " +
"TPS ensemble.")
elif len(initial_trajectories) > 1: # pragma: no cover
raise RuntimeWarning("More than one potential initial " +
"subtrajectory. We use the first.")
initial_trajectory = initial_trajectories[0]
initial_conditions = paths.SampleSet([
paths.Sample(replica=0,
trajectory=initial_trajectory,
ensemble=ensemble)
])
self.extra_bw_frames = traj.index(initial_trajectory[0])
final_frame_index = traj.index(initial_trajectory[-1])
self.extra_fw_frames = len(traj) - final_frame_index - 1
# extra -1 bc frame index counts from 0; len counts from 1
self.summary_root_dir = None
self.report_progress = None
super(OneWayTPSConverter,
self).__init__(storage=storage,
initial_conditions=initial_conditions,
mover=mover,
network=network)
# initial_states = self.network.initial_states
# final_states = self.network.final_states
# TODO: prefer the above, but the below work until fix for network
# storage
initial_states = [self.network.sampling_transitions[0].stateA]
final_states = [self.network.sampling_transitions[0].stateB]
all_states = paths.join_volumes(initial_states + final_states)
self.fw_ensemble = paths.SequentialEnsemble([
paths.AllOutXEnsemble(all_states),
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1)
])
self.bw_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_states)
])
self.full_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_states),
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1)
])
self.all_states = all_states
def set_replicas(self, samples):
self.globalstate = paths.SampleSet(samples)
def full(self, ensembles, clear=True):
storage = self.storage
if clear:
self.renderer.clear()
level_y = dict()
old_sset = paths.SampleSet([])
self.t_count = 1
self.ens_x = [None] * len(ensembles)
self.repl_x = [None] * len(ensembles)
for sset in storage.samplesets[0:2]:
path = sset.movepath
# level_y = dict()
for level, sub in path.depth_post_order(lambda this: tuple(
[this, old_sset.apply_samples(this.samples)])):
self.t_count += 1
sub_mp, sub_set = sub
if sub_mp.__class__ is paths.SamplePathMoveChange:
self.renderer.add(
self.renderer.block(-8.0 + level, self.t_count, 'blue'))
self.renderer.add(
self.renderer.label(
-8.0 + level, self.t_count, 3,
sub_mp.mover.__class__.__name__[:-5],
align='start', color='black')
)
else:
self.renderer.add(
self.renderer.block(-8.0 + level, self.t_count,
'green'))
self.renderer.add(
self.renderer.label(-8.0 + level, self.t_count, 3,
sub_mp.__class__.__name__[:-8],
align='start', color='black')
)
if level + 1 in level_y \
and level_y[level + 1] == self.t_count - 1:
self.renderer.add(
self.renderer.v_connection(-7.0 + level, self.t_count,
self.t_count - 1, 'black')
)
del level_y[level + 1]
if level in level_y and level_y[level]:
self.renderer.add(
self.renderer.v_connection(-8.0 + level, self.t_count,
level_y[level], 'black')
)
level_y[level] = self.t_count
self.render_ensemble_line(ensembles, sub_set, color='gray')
self.render_replica_line(len(ensembles), sub_set, color='gray')
self.t_count += 1
self.render_ensemble_line(ensembles, sset)
self.render_replica_line(len(ensembles), sset)
self.renderer.add(self.renderer.block(-8.0, self.t_count, 'black'))
self.renderer.add(
self.renderer.label(-8.0, self.t_count, 3,
'storage.sampleset[%d]' % sset.idx[storage.samplesets],
align='start', color='black')
)
old_sset = sset
self.t_count += 1
self.renderer.shift_x = - 9.0
self.renderer.shift_y = -0.5
self.renderer.height = 1.0 * self.t_count + 1.0
self.renderer.width = 1.0 * len(ensembles) + 20.5
def initial_conditions_from_trajectories(self, trajectories,
sample_set=None,
strategies=None,
preconditions=None,
reuse_strategy='avoid-symmetric',
engine=None):
"""
Create a SampleSet with as many initial samples as possible.
The goal of this is to give the initial SampleSet that would be
desired.
Parameters
----------
trajectories : list of :class:`.Trajectory` or :class:`.Trajectory`
the input trajectories to use
sample_set : :class:`.SampleSet`, optional
if given, add samples to this sampleset. Default is None, which
means that this will start a new sampleset.
strategies : dict
a dict that specifies the options used when ensemble functions
are used to create a new sample.
preconditions : list of str
a list of possible steps to modify the initial list of trajectories.
possible choices are
1. `sort-shortest` - sorting by shortest first,
2. `sort_median` - sorting by the middle one first and then in
move away from the median length
3. `sort-longest` - sorting by the longest first
4. `reverse` - reverse the order and
5. `mirror` which will add the reversed trajectories to the
list in the same order
Default is `None` which means to do nothing.
reuse_strategy : str
if `avoid` then reusing the same same trajectory twice is avoided.
`avoid-symmetric` will also remove reversed copies
if possible. `all` will not attempt to avoid already existing ones.
`once` will strictly not reuse a trajectory and `once-symmetric`
will also not use reversed copies.
engine : :class:`openpathsampling.engines.DyanmicsEngine`
the engine used for extending moves
Returns
-------
:class:`.SampleSet`
sampleset with samples for every initial ensemble for this
scheme that could be satisfied by the given trajectories
See Also
--------
list_initial_ensembles
check_initial_conditions
assert_initial_conditions
"""
if sample_set is None:
sample_set = paths.SampleSet([])
ensembles = self.list_initial_ensembles()
sample_set = sample_set.generate_from_trajectories(
ensembles,
trajectories,
preconditions,
strategies,
reuse_strategy,
engine
)
refresh_output(self.initial_conditions_report(sample_set),
ipynb_display_only=True, print_anyway=False)
return sample_set
def test_with_minus_move_flux(self):
network = self.mstis
scheme = paths.DefaultScheme(network, engine=RandomMDEngine())
scheme.build_move_decision_tree()
# create the minus move steps
# `center` is the edge of the state/innermost interface
center = {self.state_A: 0.0, self.state_B: 1.0}
replica = {self.state_A: -1, self.state_B: -2}
minus_ensemble_to_mover = {m.minus_ensemble: m
for m in scheme.movers['minus']}
state_to_minus_ensemble = {ens.state_vol: ens
for ens in network.minus_ensembles}
minus_changes = []
# `delta` is the change on either side for in vs. out
for (state, delta) in [(self.state_A, 0.1), (self.state_B, -0.1)]:
minus_ens = state_to_minus_ensemble[state]
minus_mover = minus_ensemble_to_mover[minus_ens]
a_in = center[state] - delta
a_out = center[state] + delta
# note that these trajs are equivalent to minus move
# descriptions in TestMinusMoveFlux
seq_1 = [a_in] + [a_out]*2 + [a_in]*5 + [a_out]*5 + [a_in]
seq_2 = [a_in] + [a_out]*3 + [a_in]*3 + [a_out]*3 + [a_in]
for seq in [seq_1, seq_2]:
traj = make_1d_traj(seq)
assert_equal(minus_ens(traj), True)
samp = paths.Sample(trajectory=traj,
ensemble=minus_ens,
replica=replica[state])
sample_set = paths.SampleSet([samp])
change = paths.AcceptedSampleMoveChange(
samples=[samp],
mover=minus_mover,
details=paths.Details()
)
minus_changes.append(change)
active = self.mstis_steps[0].active
steps = []
cycle = -1
for m_change in minus_changes:
cycle += 1
active = active.apply_samples(m_change.samples)
step = paths.MCStep(mccycle=cycle,
active=active,
change=m_change)
steps.append(step)
for old_step in self.mstis_steps[1:]:
cycle += 1
active = active.apply_samples(old_step.change.samples)
step = paths.MCStep(mccycle=cycle,
active=active,
change=old_step.change)
steps.append(step)
analysis = StandardTISAnalysis(
network=self.mstis,
scheme=scheme,
max_lambda_calcs={t: {'bin_width': 0.1,
'bin_range': (-0.1, 1.1)}
for t in network.sampling_transitions},
steps=steps
)
# now we actually verify correctness
avg_t_in = (5.0 + 3.0) / 2
avg_t_out = (2.0 + 5.0 + 3.0 + 3.0) / 4
expected_flux = 1.0 / (avg_t_in + avg_t_out)
# NOTE: Apparently this approach screws up the TCP calculation. I
# think this is a problem in the fake data, not the simulation.
for flux in analysis.flux_matrix.values():
assert_almost_equal(flux, expected_flux)
### INITIAL SNAPSHOT #######################################################
print("Getting energy-minimized initial snapshot")
engine.simulation.context.setPositions(testsystem.positions)
engine.simulation.minimizeEnergy()
initial_snapshot = engine.current_snapshot
### SETUP INITIAL CONDITIONS ###############################################
print("Setting up initial conditions")
initial_trajectory = engine.generate(initial_snapshot, ensemble.can_append)
sample = paths.Sample(replica=0,
ensemble=ensemble,
trajectory=initial_trajectory)
initial_conditions = paths.SampleSet([sample])
ref_frame = initial_trajectory.to_mdtraj()[0]
ref_frame.save("ref.pdb")
### RUN PATH SAMPLING ######################################################
storage = Storage('test_data.db', mode='w')
# add CVs
phi = MDTrajFunctionCV(md.compute_dihedrals,
topology=engine.topology,
indices=[[4, 6, 8, 14]]).named("phi")
psi = MDTrajFunctionCV(md.compute_dihedrals,
topology=engine.topology,
indices=[[6, 8, 14, 16]]).named("psi")
