def test_analyze_incr_decr(self):
steps = [
paths.MCStep(mccycle=0, active=self.incr_1),
paths.MCStep(mccycle=1, active=self.decr_1)
]
results = paths.ChannelAnalysis(steps, self.channels)
assert_equal(results._results,
{'incr': [(0,1)], 'decr': [(1,2)], None: []})
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 _make_fake_steps(self, sample_sets, mover):
steps = []
for (mccycle, sample_set) in enumerate(sample_sets):
change = paths.AcceptedSampleMoveChange(
samples=sample_set.samples,
mover=mover,
details=None,
input_samples=None
)
step = paths.MCStep(mccycle=mccycle,
active=sample_set,
change=change)
steps.append(step)
return steps
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 run_moves(init_conds, moves, org_by_group=True):
"""Run a sequence of moves.
Once the individual moves have been mocked up, this runs them to iterate
over the steps that you would get from the simulation.
Since this is a generator, you may want to wrap it in a list when using
it.
Parameters
----------
init_conds : :class:`.SampleSet`
initial conditions for this run
moves : List[:class:`.MockMove`]
the moves to run, in the order they will be applied
org_by_group : bool
whether to wrap each resulting change to include the structural move
changes that come from the :class:`.OrganizeByMoveGroupStrategy`.
Yields
------
:class:`.MCStep`
the step for each mock move
"""
for stepnum, move in enumerate(moves):
change = _do_single_step(init_conds, move,
org_by_group=org_by_group)
new_conds = init_conds.apply_samples(change.results)
step = paths.MCStep(
simulation=None,
mccycle=stepnum,
active=new_conds,
change=change
)
yield step
init_conds = new_conds
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)
def run(self, step_info_list):
"""
Parameters
----------
step_info_list : list of tuple
(replica, trial_trajectory, shooting_point_index, accepted) or
(replica, one_way_trial_segment, shooting_point_index, accepted,
direction)
"""
mcstep = None
if self.step == 0:
if self.storage is not None:
self.storage.save(self.scheme)
self.save_initial_step()
for step_info in step_info_list:
self.step += 1
if len(step_info
) == 4 and not self.mover.pre_joined: # pragma: no-cover
raise RuntimeError(
"Shooting trial trajectories not pre-joined: " +
"step_info must be (replica, trial_segment, " +
"shooting_pt_idx, accepted, direction)")
replica = step_info[0]
trial_trajectory = step_info[1]
shooting_point_index = step_info[2]
accepted = step_info[3]
direction = None
if len(step_info) == 5:
direction = step_info[4]
input_sample = self.sample_set[replica]
if shooting_point_index < 0:
shooting_point_index += len(input_sample.trajectory)
shooting_point = input_sample.trajectory[shooting_point_index]
subchange = self.mover.move(input_sample, trial_trajectory,
shooting_point, accepted, direction)
change = paths.PathSimulatorMoveChange(
subchange=subchange,
mover=self._path_sim_mover,
details=paths.MoveDetails(step=self.step))
samples = change.results
new_sampleset = self.sample_set.apply_samples(samples)
mcstep = paths.MCStep(simulation=self,
mccycle=self.step,
previous=self.sample_set,
active=new_sampleset,
change=change)
if self.storage is not None:
self.storage.steps.save(mcstep)
if self.step % self.save_frequency == 0:
self.sample_set.sanity_check()
self.sync_storage()
self.sample_set = new_sampleset
self.sync_storage()
