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