def setup(self): # As a test system, let's use 1D motion on a flat potential. If the # velocity is positive, you right the state on the right. If it is # negative, you hit the state on the left. pes = toys.LinearSlope(m=[0.0], c=[0.0]) # flat line topology = toys.Topology(n_spatial=1, masses=[1.0], pes=pes) integrator = toys.LeapfrogVerletIntegrator(0.1) options = { 'integ': integrator, 'n_frames_max': 100000, 'n_steps_per_frame': 5 } self.engine = toys.Engine(options=options, topology=topology) self.snap0 = toys.Snapshot(coordinates=np.array([[0.0]]), velocities=np.array([[1.0]]), engine=self.engine) cv = paths.FunctionCV("Id", lambda snap: snap.coordinates[0][0]) starting_volume = paths.CVDefinedVolume(cv, -0.01, 0.01) forward_ensemble = paths.LengthEnsemble(5) backward_ensemble = paths.LengthEnsemble(3) randomizer = paths.NoModification() self.filename = data_filename("shoot_from_snaps.nc") self.storage = paths.Storage(self.filename, 'w') self.simulation = ShootFromSnapshotsSimulation( storage=self.storage, engine=self.engine, starting_volume=starting_volume, forward_ensemble=forward_ensemble, backward_ensemble=backward_ensemble, randomizer=randomizer, initial_snapshots=self.snap0) self.simulation.output_stream = open(os.devnull, "w")
def __init__(self, storage, engine=None, states=None, randomizer=None, initial_snapshots=None, direction=None): all_state_volume = paths.join_volumes(states) no_state_volume = ~all_state_volume # shoot forward until we hit a state forward_ensemble = paths.SequentialEnsemble([ paths.AllOutXEnsemble(all_state_volume), paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1) ]) # or shoot backward until we hit a state backward_ensemble = paths.SequentialEnsemble([ paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1), paths.AllOutXEnsemble(all_state_volume) ]) super(CommittorSimulation, self).__init__( storage=storage, engine=engine, starting_volume=no_state_volume, forward_ensemble=forward_ensemble, backward_ensemble=backward_ensemble, randomizer=randomizer, initial_snapshots=initial_snapshots ) self.states = states self.direction = direction # override the default self.mover given by the superclass if self.direction is None: self.mover = paths.RandomChoiceMover([self.forward_mover, self.backward_mover]) elif self.direction > 0: self.mover = self.forward_mover elif self.direction < 0: self.mover = self.backward_mover
def analyze_transition_duration(self, trajectory, stateA, stateB): """Analysis to obtain transition durations for given state. Parameters ---------- trajectory : :class:`.Trajectory` trajectory to analyze stateA : :class:`.Volume` initial state volume for the transition stateB : :class:`.Volume` final state volume for the transition Returns ------- :class:`.TrajectorySegmentContainer` transitions from `stateA` to `stateB` within `trajectory` """ # we define the transitions ensemble just in case the transition is, # e.g., fixed path length TPS. We want flexible path length ensemble transition_ensemble = paths.SequentialEnsemble([ paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1), paths.OptionalEnsemble( # optional to allow instantaneous hops paths.AllOutXEnsemble(stateA) & paths.AllOutXEnsemble(stateB) ), paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1) ]) segments = [seg[1:-1] for seg in transition_ensemble.split(trajectory)] return TrajectorySegmentContainer(segments, self.dt)
def A2BEnsemble(volume_a, volume_b, trusted=True): # this is a little replacement for the same name that used to be in # EnsembleFactory. It was only used in tests. return paths.SequentialEnsemble([ paths.AllInXEnsemble(volume_a) & paths.LengthEnsemble(1), paths.AllOutXEnsemble(volume_a | volume_b), paths.AllInXEnsemble(volume_b) & paths.LengthEnsemble(1) ])
def get_lifetime_segments(trajectory, from_vol, to_vol, forbidden=None, padding=[0, -1]): """General script to get lifetimes. Lifetimes for a transition between volumes are used in several other calculations: obviously, the state lifetime, but also the flux through an interface. This is a generic function to calculate that. Parameters ---------- trajectory : :class:`.Trajectory` trajectory to analyze from_vol : :class:`.Volume` the volume for which this represents the lifetime: the trajectory segments returned are associated with the lifetime of `from_vol` to_vol : :class:`.Volume` the volume which indicates the end of the lifetime: a frame in this volume means the trajectory is no longer associated with `from_vol` forbidden : :class:`.Volume` if a frame is in `forbidden`, it cannot be part of the lifetime of `from_vol`. This isn't needed in 2-state lifetime calculations; however, it is useful to exclude other states from a flux calculation padding : list adjusts which frames are returned as list indices. That is, the returned segments are `full_segment[padding[0]:padding[1]]`. The `full_segment`s are the segments from (and including) each first frame in `from_vol` (after a visit to `to_vol`) until (and including) the first frame in `to_vol`. To get the full segment as output, use `padding=[None, None]`. The default is to remove the final frame (`padding=[0, -1]`) so that it doesn't include the frame in `to_vol`. Returns ------- list of :class:`.Trajectory` the frames from (and including) each first entry from `to_vol` into `from_vol` until (and including) the next entry into `to_vol`, with no frames in `forbidden`, and with frames removed from the ends according to `padding` """ if forbidden is None: forbidden = paths.EmptyVolume() ensemble_BAB = paths.SequentialEnsemble([ paths.LengthEnsemble(1) & paths.AllInXEnsemble(to_vol), paths.PartInXEnsemble(from_vol) & paths.AllOutXEnsemble(to_vol), paths.LengthEnsemble(1) & paths.AllInXEnsemble(to_vol) ]) & paths.AllOutXEnsemble(forbidden) ensemble_AB = paths.SequentialEnsemble([ paths.LengthEnsemble(1) & paths.AllInXEnsemble(from_vol), paths.OptionalEnsemble(paths.AllOutXEnsemble(to_vol)), paths.LengthEnsemble(1) & paths.AllInXEnsemble(to_vol) ]) BAB_split = ensemble_BAB.split(trajectory) AB_split = [ensemble_AB.split(part)[0] for part in BAB_split] return [subtraj[padding[0]:padding[1]] for subtraj in AB_split]
def add_transition(self, stateA, stateB): new_ens = paths.SequentialEnsemble([ paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1), paths.AllOutXEnsemble(stateA | stateB), paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1) ]) try: self.ensembles[0] = self.ensembles[0] | new_ens except AttributeError: self.ensembles = [new_ens]
def __init__(self, storage, engine=None, state_S=None, randomizer=None, initial_snapshots=None, trajectory_length=None): # Defintion of state S (A and B are only required for analysis). self.state_S = state_S # Set forward/backward shot length. self.trajectory_length = trajectory_length l = self.trajectory_length # Define backward ensemble: # trajectory starts in S and has fixed length l. backward_ensemble = paths.SequentialEnsemble([ paths.LengthEnsemble(l), paths.AllInXEnsemble(state_S) & paths.LengthEnsemble(1) ]) # Define forward ensemble: # CAUTION: first trajectory is in backward ensemble, # then continues with fixed length l. forward_ensemble = paths.SequentialEnsemble([ paths.LengthEnsemble(l), paths.AllInXEnsemble(state_S) & paths.LengthEnsemble(1), paths.LengthEnsemble(l) ]) super(SShootingSimulation, self).__init__(storage=storage, engine=engine, starting_volume=state_S, forward_ensemble=forward_ensemble, backward_ensemble=backward_ensemble, randomizer=randomizer, initial_snapshots=initial_snapshots) # Create backward mover (starting from single point). self.backward_mover = paths.BackwardExtendMover( ensemble=self.starting_ensemble, target_ensemble=self.backward_ensemble) # Create forward mover (starting from the backward ensemble). self.forward_mover = paths.ForwardExtendMover( ensemble=self.backward_ensemble, target_ensemble=self.forward_ensemble) # Create mover combining forward and backward shooting. No condition # here, shots in both directions are executed in any case. self.mover = paths.NonCanonicalConditionalSequentialMover( [self.backward_mover, self.forward_mover])
def __init__(self, stateA, stateB, name=None): super(TPSTransition, self).__init__(stateA, stateB) if name is not None: self.name = name if not hasattr(self, "ensembles"): self.ensembles = [ paths.SequentialEnsemble([ paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1), paths.AllOutXEnsemble(stateA | stateB), paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1) ]) ]
def __init__(self, storage, engine=None, states=None, randomizer=None, initial_snapshots=None, direction=None): super(CommittorSimulation, self).__init__(storage) self.engine = engine paths.EngineMover.default_engine = engine self.states = states self.randomizer = randomizer try: initial_snapshots = list(initial_snapshots) except TypeError: initial_snapshots = [initial_snapshots] self.initial_snapshots = initial_snapshots self.direction = direction all_state_volume = paths.join_volumes(states) # we should always start from a single frame not in any state self.starting_ensemble = (paths.AllOutXEnsemble(all_state_volume) & paths.LengthEnsemble(1)) # shoot forward until we hit a state self.forward_ensemble = paths.SequentialEnsemble([ paths.AllOutXEnsemble(all_state_volume), paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1) ]) # or shoot backward until we hit a state self.backward_ensemble = paths.SequentialEnsemble([ paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1), paths.AllOutXEnsemble(all_state_volume) ]) self.forward_mover = paths.ForwardExtendMover( ensemble=self.starting_ensemble, target_ensemble=self.forward_ensemble) self.backward_mover = paths.BackwardExtendMover( ensemble=self.starting_ensemble, target_ensemble=self.backward_ensemble) if self.direction is None: self.mover = paths.RandomChoiceMover( [self.forward_mover, self.backward_mover]) elif self.direction > 0: self.mover = self.forward_mover elif self.direction < 0: self.mover = self.backward_mover
def setup(self): cv = paths.FunctionCV("Id", lambda snap: snap.xyz[0][0]) self.state_A = paths.CVDefinedVolume(cv, -0.1, 0.1) self.state_B = ~paths.CVDefinedVolume(cv, -1.0, 1.0) nml_increasing = paths.CVDefinedVolume(cv, 0.1, 1.0) nml_decreasing = paths.CVDefinedVolume(cv, -1.0, -0.1) increasing = paths.AllInXEnsemble(nml_increasing) decreasing = paths.AllInXEnsemble(nml_decreasing) self.ensemble = paths.SequentialEnsemble([ paths.LengthEnsemble(1) & paths.AllInXEnsemble(self.state_A), paths.AllOutXEnsemble(self.state_A | self.state_B), paths.LengthEnsemble(1) & paths.AllInXEnsemble(self.state_B) ]) self.incr_1 = self._make_active([0.0, 0.5, 1.1]) self.incr_2 = self._make_active([0.05, 0.6, 1.2]) self.decr_1 = self._make_active([0.0, -0.5, -1.1]) self.both_1 = self._make_active([0.0, 0.5, -0.5, 1.1]) self.both_2 = self._make_active([0.0, -0.4, 0.4, -1.1]) self.none_1 = self._make_active([0.0, 1.1]) self.none_2 = self._make_active([0.0, -1.1]) self.channels = {'incr': increasing, 'decr': decreasing} # used in simplest tests of relabeling self.toy_results = { 'a': [(0, 5), (8, 10)], 'b': [(3, 9)], 'c': [(7, 9)] } self.results_with_none = { 'a': [(0, 2), (6, 9)], 'b': [(5, 7), (9, 10)], None: [(2, 5)] } self.set_a = frozenset(['a']) self.set_b = frozenset(['b']) self.set_c = frozenset(['c']) self.toy_expanded_results = [(0, 5, self.set_a), (3, 9, self.set_b), (7, 9, self.set_c), (8, 10, self.set_a)] self.expanded_results_simultaneous_ending = [(0, 5, self.set_a), (3, 9, self.set_b), (7, 10, self.set_c), (8, 10, self.set_a)] self.expanded_oldest_skips_internal = [(0, 5, self.set_a), (3, 9, self.set_b), (7, 8, self.set_c), (8, 10, self.set_a), (10, 11, self.set_b)]
def setup(self): self.descriptor = SnapshotDescriptor.construct( snapshot_class=ToySnapshot, snapshot_dimensions={ 'n_spatial': 1, 'n_atoms': 1 }) slow_options = { 'n_frames_max': 10000, 'engine_sleep': 100, 'name_prefix': "test", 'engine_directory': engine_dir } fast_options = { 'n_frames_max': 10000, 'engine_sleep': 0, 'name_prefix': "test", 'engine_directory': engine_dir } self.template = peng.toy.Snapshot(coordinates=np.array([[0.0]]), velocities=np.array([[1.0]])) self.slow_engine = ExampleExternalEngine(slow_options, self.descriptor, self.template) self.fast_engine = ExampleExternalEngine(fast_options, self.descriptor, self.template) self.ensemble = paths.LengthEnsemble(5)
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 __init__(self, storage, engine, starting_volume, forward_ensemble, backward_ensemble, randomizer, initial_snapshots): super(ShootFromSnapshotsSimulation, self).__init__(storage) self.engine = engine # FIXME: this next line seems weird; but tests fail without it paths.EngineMover.default_engine = engine try: initial_snapshots = list(initial_snapshots) except TypeError: initial_snapshots = [initial_snapshots] self.initial_snapshots = initial_snapshots self.randomizer = randomizer self.starting_ensemble = (paths.AllInXEnsemble(starting_volume) & paths.LengthEnsemble(1)) self.forward_ensemble = forward_ensemble self.backward_ensemble = backward_ensemble self.forward_mover = paths.ForwardExtendMover( ensemble=self.starting_ensemble, target_ensemble=self.forward_ensemble) self.backward_mover = paths.BackwardExtendMover( ensemble=self.starting_ensemble, target_ensemble=self.backward_ensemble) # subclasses will often override this self.mover = paths.RandomChoiceMover( [self.forward_mover, self.backward_mover])
def run(): template = peng.toy.Snapshot(coordinates=np.array([[0.0]]), velocities=np.array([[1.0]])) ensemble = paths.LengthEnsemble(20) engine = build_engine(template) logging.basicConfig(level=logging.INFO) engine.generate(template, ensemble.can_append, direction=+1)
def setup(self): self.cv = CollectiveVariable(lambda x: x.xyz[0][0]) self.traj = make_1d_traj([1.0, 2.0, 3.0]) ensemble = paths.LengthEnsemble(3) self.sample = paths.Sample(replica=0, trajectory=self.traj, ensemble=ensemble) self.snap = self.traj[0]
def test_assert_initial_conditions(self): scheme = DefaultScheme(self.network) traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6]) init_cond = scheme.initial_conditions_from_trajectories(traj3) init_cond.append_as_new_replica( paths.Sample(trajectory=traj3, ensemble=paths.LengthEnsemble(4), replica=None)) scheme.assert_initial_conditions(init_cond)
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_subtrajectory_indices(self): # simplify more complicated expressions stateA = self.stateA stateB = self.stateB pretraj = [ 0.20, 0.30, 0.60, 0.40, 0.65, 2.10, 2.20, 2.60, 2.10, 0.80, 0.55, 0.40, 0.20 ] # 00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12 # A, A, I, A, I, B, B, X, B, X, I, A, A trajectory = make_1d_traj(coordinates=pretraj, velocities=[1.0] * len(pretraj)) ensemble_A = paths.AllInXEnsemble(stateA) ensemble_B = paths.AllInXEnsemble(stateB) ensemble_ABA = paths.SequentialEnsemble([ paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1), paths.PartInXEnsemble(stateB) & paths.AllOutXEnsemble(stateA), paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1) ]) subtrajectoriesA = ensemble_A.split(trajectory, overlap=0) subtrajectoriesB = ensemble_B.split(trajectory, overlap=0) subtrajectoriesABA = ensemble_ABA.split(trajectory) # make sure we have the trajectories we expect assert_equal(len(subtrajectoriesA), 3) assert_equal(len(subtrajectoriesB), 2) assert_equal(len(subtrajectoriesABA), 1) # the following assertions check that the subtrajectories are the # ones that we expect; the numbers here are linked to the indices # we'll test next assert_equal(subtrajectoriesA[0], trajectory[0:2]) assert_equal(subtrajectoriesA[1], trajectory[3:4]) assert_equal(subtrajectoriesA[2], trajectory[11:13]) assert_equal(subtrajectoriesB[0], trajectory[5:7]) assert_equal(subtrajectoriesB[1], trajectory[8:9]) assert_equal(subtrajectoriesABA[0], trajectory[3:12]) # now we run the subtrajectory_indices function and test it indicesA = trajectory.subtrajectory_indices(subtrajectoriesA) indicesB = trajectory.subtrajectory_indices(subtrajectoriesB) indicesABA = trajectory.subtrajectory_indices(subtrajectoriesABA) assert_equal(indicesA, [[0, 1], [3], [11, 12]]) assert_equal(indicesB, [[5, 6], [8]]) assert_equal(indicesABA, [[3, 4, 5, 6, 7, 8, 9, 10, 11]])
def setup(self): cv = paths.CoordinateFunctionCV('x', lambda x: x.xyz[0][0]) vol_A = paths.CVDefinedVolume(cv, float("-inf"), 0.0) vol_B = paths.CVDefinedVolume(cv, 1.0, float("inf")) ensembles = [ paths.LengthEnsemble(1).named("len1"), paths.LengthEnsemble(3).named("len3"), paths.SequentialEnsemble([ paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_A), paths.AllOutXEnsemble(vol_A | vol_B), paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_A) ]).named('return'), paths.SequentialEnsemble([ paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_A), paths.AllOutXEnsemble(vol_A | vol_B), paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_B) ]).named('transition'), ] self.ensembles = {ens.name: ens for ens in ensembles} self.traj_vals = [-0.1, 1.1, 0.5, -0.2, 0.1, -0.3, 0.4, 1.4, -1.0] self.trajectory = make_1d_traj(self.traj_vals) self.engine = CalvinistDynamics(self.traj_vals) self.satisfied_when_traj_len = { "len1": 1, "len3": 3, "return": 6, "transition": 8, } self.conditions = EnsembleSatisfiedContinueConditions(ensembles)
def test_initial_conditions_report(self): scheme = DefaultScheme(self.network) traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6]) init_cond = scheme.initial_conditions_from_trajectories(traj3) init_cond.append_as_new_replica( paths.Sample(trajectory=traj3, ensemble=paths.LengthEnsemble(4), replica=None) ) expected = "Missing ensembles:\n" expected += "* [[MinusInterfaceEnsemble]]\n"*2 expected += "Extra ensembles:\n* [LengthEnsemble]\n" assert_equal(scheme.initial_conditions_report(init_cond), expected)
def run_steps(steps): template = peng.snapshot_from_pdb( "/Users/jan-hendrikprinz/Studium/git/openpathsampling/examples/data/Alanine_solvated.pdb") topology = peng.to_openmm_topology(template) # Generated using OpenMM Script Builder # http://builder.openmm.org forcefield = mm.app.ForceField( 'amber96.xml', # solute FF 'tip3p.xml' # solvent FF ) # OpenMM System system = forcefield.createSystem( topology, nonbondedMethod=mm.app.PME, nonbondedCutoff=1.0*u.nanometers, constraints=mm.app.HBonds, ewaldErrorTolerance=0.0005 ) # OpenMM Integrator integrator = mm.LangevinIntegrator( 300 * u.kelvin, 1.0 / u.picoseconds, 2.0 * u.femtoseconds ) integrator.setConstraintTolerance(0.00001) # Engine options options = { 'n_steps_per_frame': 2, 'n_frames_max': 5 } engine = peng.Engine( template.topology, system, integrator, options=options ) engine.initialize('CPU') traj = engine.generate(template, paths.LengthEnsemble(steps).can_append) return traj
def __init__(self, states, progress='default', timestep=None): self.states = states self.all_states = paths.join_volumes(states) all_states_ens = paths.join_ensembles([paths.AllOutXEnsemble(s) for s in states]) ensemble = paths.SequentialEnsemble([ all_states_ens, paths.AllInXEnsemble(self.all_states) & paths.LengthEnsemble(1) ]) super(VisitAllStatesEnsemble, self).__init__(ensemble) self.timestep = timestep self.report_frequency = 10 self.progress_formatter, self.progress_emitter = \ self._progress_indicator(progress) self.cache = EnsembleCache(direction=+1) self._reset_cache_contents()
def test_generate_n_frames(self): self.sim.initialized = True ens = paths.LengthEnsemble(4) # first snap plus n_frames orig = self.sim.current_snapshot.copy() traj1 = self.sim.generate(self.sim.current_snapshot, [ens.can_append]) self.sim.current_snapshot = orig traj2 = [orig] + self.sim.generate_n_frames(3) assert_equal(len(traj1), len(traj2)) for (s1, s2) in zip(traj1, traj2): # snapshots are not the same object assert_not_equal(s1, s2) # however, they have the same values stored in them assert_equal(len(s1.coordinates), 1) assert_equal(len(s1.coordinates[0]), 2) assert_items_equal(s1.coordinates[0], s2.coordinates[0]) assert_items_equal(s1.velocities[0], s2.velocities[0])
def test_check_initial_conditions(self): scheme = DefaultScheme(self.network) traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6]) # cheating a bit, since we know what this gives init_cond = scheme.initial_conditions_from_trajectories(traj3) assert_equal(len(init_cond), 7) assert_equal(len(scheme.list_initial_ensembles()), 9) (missing, extra) = scheme.check_initial_conditions(init_cond) assert_equal(len(missing), 2) assert_equal(len(extra), 0) for ens in list(self.network.special_ensembles['minus'].keys()): assert_in([ens], missing) init_cond.append_as_new_replica( paths.Sample(trajectory=traj3, ensemble=paths.LengthEnsemble(4), replica=None)) (missing, extra) = scheme.check_initial_conditions(init_cond) assert_equal(len(missing), 2) assert_equal(len(extra), 1)
def test_initial_conditions_report(self): scheme = DefaultScheme(self.network) traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6]) init_cond = scheme.initial_conditions_from_trajectories(traj3) init_cond.append_as_new_replica( paths.Sample(trajectory=traj3, ensemble=paths.LengthEnsemble(4), replica=None)) start = "Missing ensembles:\n" missing_A = "* [Out A minus]\n" missing_B = "* [Out B minus]\n" finish = "Extra ensembles:\n* [LengthEnsemble]\n" expected_AB = start + missing_A + missing_B + finish expected_BA = start + missing_B + missing_A + finish result = scheme.initial_conditions_report(init_cond) try: assert_equal(result, expected_AB) except AssertionError: assert_equal(result, expected_BA)
def test_generate(self): if not has_gmx: raise SkipTest("Gromacs 5 (gmx) not found. Skipping test.") if not HAS_MDTRAJ: pytest.skip("MDTraj not found. Skipping test.") traj_0 = self.engine.trajectory_filename(0) snap = self.engine.read_frame_from_file(traj_0, 0) self.engine.filename_setter.reset(0) ens = paths.LengthEnsemble(5) traj = self.engine.generate(snap, running=[ens.can_append]) assert_equal(self.engine.proc.is_running(), False) assert_equal(len(traj), 5) ttraj = md.load(self.engine.trajectory_filename(1), top=self.engine.gro) # the mdp suggests a max length of 100 frames assert_true(len(ttraj) < 100)
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 _tps_ensemble(self, stateA, stateB): return paths.SequentialEnsemble([ paths.LengthEnsemble(1) & paths.AllInXEnsemble(stateA), paths.LengthEnsemble(self.length - 2), paths.LengthEnsemble(1) & paths.AllInXEnsemble(stateB) ])
def _tps_ensemble(self, stateA, stateB): return paths.SequentialEnsemble([ paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1), paths.AllOutXEnsemble(stateA | stateB), paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1) ])
def __init__(self, transition, snapshot, storage=None, engine=None, extra_interfaces=None, extra_ensembles=None, forbidden_states=None, initial_max_length=None): super(FullBootstrapping, self).__init__(storage) self.engine = engine paths.EngineMover.default_engine = engine # set the default 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.initial_max_length = initial_max_length if self.initial_max_length is not None: self.first_traj_ensemble = (paths.LengthEnsemble( slice(0, self.initial_max_length)) & self.first_traj_ensemble) if extra_ensembles is None: extra_ensembles = [] self.extra_ensembles = [ paths.TISEnsemble(transition.stateA, transition.stateB, iface, transition.orderparameter) for iface in extra_interfaces ] + extra_ensembles self.transition_shooters = [ paths.OneWayShootingMover(selector=paths.UniformSelector(), ensemble=ens, engine=self.engine) for ens in transition.ensembles ] self.extra_shooters = [ paths.OneWayShootingMover(selector=paths.UniformSelector(), ensemble=ens, engine=self.engine) 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