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])
self.left = paths.CVDefinedVolume(cv, float("-inf"), -1.0)
self.right = paths.CVDefinedVolume(cv, 1.0, float("inf"))
self.state_labels = {"Left" : self.left,
"Right" : self.right,
"None" : ~(self.left | self.right)}
randomizer = paths.NoModification()
self.filename = data_filename("committor_test.nc")
self.storage = paths.Storage(self.filename, mode="w")
self.storage.save(self.snap0)
self.simulation = CommittorSimulation(storage=self.storage,
engine=self.engine,
states=[self.left, self.right],
randomizer=randomizer,
initial_snapshots=self.snap0)
self.simulation.output_stream = open(os.devnull, 'w')
def setup(self):
pes = linear
integ = toy.LeapfrogVerletIntegrator(dt=0.002)
topology = toy.Topology(
n_spatial=2,
masses=sys_mass,
pes=pes
)
options = {
'integ': integ,
'n_frames_max': 5
}
sim = toy.Engine(options=options,
topology=topology)
template = toy.Snapshot(
coordinates=init_pos.copy(),
velocities=init_pos.copy(),
engine=sim
)
sim.positions = init_pos.copy()
sim.velocities = init_vel.copy()
sim.n_steps_per_frame = 10
self.sim = sim
def make_1d_traj(coordinates, velocities=None, engine=None):
if velocities is None:
velocities = [1.0]*len(coordinates)
try:
_ = len(velocities)
except TypeError:
velocities = [velocities] * len(coordinates)
if engine is None:
engine = toys.Engine(
{},
toys.Topology(
n_spatial=3,
masses=[1.0, 1.0, 1.0], pes=None
)
)
traj = []
for (pos, vel) in zip(coordinates, velocities):
snap = toys.Snapshot(
coordinates=np.array([[pos, 0, 0]]),
velocities=np.array([[vel, 0, 0]]),
engine=engine
)
traj.append(snap)
return paths.Trajectory(traj)
def setUp(self):
pes = linear
integ = toy.LangevinBAOABIntegrator(dt=0.002, temperature=0.5,
gamma=1.0)
topology=toy.Topology(
n_spatial = 2,
masses = sys_mass,
pes = pes
)
options={
'integ' : integ,
'n_frames_max' : 5}
sim = toy.Engine(options=options,
topology=topology
)
template = toy.Snapshot(
coordinates=init_pos.copy(),
velocities=init_pos.copy(),
engine=sim
)
sim.positions = init_pos.copy()
sim.velocities = init_vel.copy()
sim.n_steps_per_frame = 10
self.sim = sim
def setup(self):
import openpathsampling.engines.toy as toys
self.toy_modifier = SingleAtomVelocityDirectionModifier(
delta_v=[1.0, 2.0],
subset_mask=[1, 2],
remove_linear_momentum=False)
self.toy_engine = toys.Engine(
topology=toys.Topology(n_spatial=2,
n_atoms=3,
pes=None,
masses=np.array([1.0, 1.5, 4.0])),
options={})
self.toy_snapshot = toys.Snapshot(coordinates=np.array([[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0]]),
velocities=np.array([[1.0, 1.0],
[2.0, 2.0],
[3.0, 3.0]]),
engine=self.toy_engine)
u_vel = old_div(u.nanometer, u.picosecond)
self.openmm_modifier = SingleAtomVelocityDirectionModifier(
delta_v=1.2 * u_vel, remove_linear_momentum=False)
ad_vacuum = omt.testsystems.AlanineDipeptideVacuum(constraints=None)
self.test_snap = omm_engine.snapshot_from_testsystem(ad_vacuum)
self.openmm_engine = omm_engine.Engine(
topology=self.test_snap.topology,
system=ad_vacuum.system,
integrator=omt.integrators.VVVRIntegrator())
self.openmm_snap = self.test_snap.copy_with_replacement(
engine=self.openmm_engine,
velocities=np.ones(shape=self.test_snap.velocities.shape) * u_vel)
def test_storage(self):
import os
fname = data_filename("tps_network_storage_test.nc")
if os.path.isfile(fname):
os.remove(fname)
topol = peng.Topology(n_spatial=1, masses=[1.0], pes=None)
engine = peng.Engine({}, topol)
self.template = peng.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[0.0]]),
engine=engine)
states = [self.stateA, self.stateB, self.stateC]
network_a = self.NetworkType(initial_states=states,
final_states=states,
**self.std_kwargs)
assert_equal(len(network_a.sampling_transitions), 1)
assert_equal(len(network_a.transitions), 6)
storage_w = paths.storage.Storage(fname, "w")
storage_w.snapshots.save(self.template)
storage_w.save(network_a)
storage_w.sync_all()
storage_r = paths.storage.AnalysisStorage(fname)
network_b = storage_r.networks[0]
assert_equal(len(network_b.sampling_transitions), 1)
assert_equal(len(network_b.transitions), 6)
if os.path.isfile(fname):
os.remove(fname)
def setup(self):
import openpathsampling.engines.toy as toys
# applies one delta_v to all atoms
self.toy_modifier_all = GeneralizedDirectionModifier(1.5)
# defines delta_v per atom, including those not in the mask
self.toy_modifier_long_dv = GeneralizedDirectionModifier(
delta_v=[0.5, 1.0, 2.0], subset_mask=[1, 2])
# defines delta_v per atom in the subset mask
self.toy_modifier = GeneralizedDirectionModifier(delta_v=[1.0, 2.0],
subset_mask=[1, 2])
self.toy_engine = toys.Engine(topology=toys.Topology(
n_spatial=2, n_atoms=3, pes=None, masses=[1.0, 1.5, 4.0]),
options={})
self.toy_snapshot = toys.Snapshot(coordinates=np.array([[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0]]),
velocities=np.array([[1.0, 1.0],
[2.0, 2.0],
[3.0, 3.0]]),
engine=self.toy_engine)
# create the OpenMM versions
u_vel = old_div(u.nanometer, u.picosecond)
self.openmm_modifier = GeneralizedDirectionModifier(1.2 * u_vel)
ad_vacuum = omt.testsystems.AlanineDipeptideVacuum(constraints=None)
self.test_snap = omm_engine.snapshot_from_testsystem(ad_vacuum)
self.openmm_engine = omm_engine.Engine(
topology=self.test_snap.topology,
system=ad_vacuum.system,
integrator=omt.integrators.VVVRIntegrator())
self.openmm_snap = self.test_snap.copy_with_replacement(
engine=self.openmm_engine)
def make_mstis_engine():
pes = (
toys.OuterWalls([1.0, 1.0], [0.0, 0.0])
+ toys.Gaussian(-0.7, [12.0, 12.0], [0.0, 0.4])
+ toys.Gaussian(-0.7, [12.0, 12.0], [-0.5, -0.5])
+ toys.Gaussian(-0.7, [12.0, 12.0], [0.5, -0.5])
)
topology=toys.Topology(
n_spatial=2,
masses=[1.0, 1.0],
pes=pes
)
integ = toys.LangevinBAOABIntegrator(dt=0.02, temperature=0.1, gamma=2.5)
options={
'integ': integ,
'n_frames_max': 5000,
'n_steps_per_frame': 1
}
toy_eng = toys.Engine(
options=options,
topology=topology
).named('toy_engine')
template = toys.Snapshot(
coordinates=np.array([[-0.5, -0.5]]),
velocities=np.array([[0.0,0.0]]),
engine=toy_eng
)
toy_eng.current_snapshot = template
return toy_eng
def setup(self):
pes = toys.HarmonicOscillator(A=[1.0], omega=[1.0], x0=[0.0])
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': 2
}
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])
self.cv = cv
self.center = paths.CVDefinedVolume(cv, -0.2, 0.2)
self.interface = paths.CVDefinedVolume(cv, -0.3, 0.3)
self.outside = paths.CVDefinedVolume(cv, 0.6, 0.9)
self.extra = paths.CVDefinedVolume(cv, -1.5, -0.9)
self.flux_pairs = [(self.center, self.interface)]
self.sim = DirectSimulation(storage=None,
engine=self.engine,
states=[self.center, self.outside],
flux_pairs=self.flux_pairs,
initial_snapshot=self.snap0)
def make_engine():
pes = toys.LinearSlope([0, 0], 0)
topology = toys.Topology(n_spatial=2, masses=[1.0, 1.0], pes=pes)
integ = toys.LeapfrogVerletIntegrator(dt=0.1)
options = {'integ': integ, 'n_frames_max': 1000, 'n_steps_per_frame': 1}
engine = toys.Engine(options=options, topology=topology)
return engine
def make_mistis_engine():
pes = (
toys.OuterWalls([1.0, 1.0], [0.0, 0.0])
+ toys.Gaussian(-1.0, [12.0, 12.0], [-0.5, 0.5])
+ toys.Gaussian(-1.0, [12.0, 12.0], [-0.5, -0.5])
+ toys.Gaussian(-1.0, [12.0, 12.0], [0.5, -0.5])
)
topology=toys.Topology(n_spatial=2,
masses=[1.0, 1.0],
pes=pes)
integ = toys.LangevinBAOABIntegrator(dt=0.02, temperature=0.1, gamma=2.5)
options = {
'integ': integ,
'n_frames_max': 5000,
'n_steps_per_frame': 1
}
toy_eng = toys.Engine(
options=options,
topology=topology
).named('engine')
return toy_eng
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 setup(self):
self.mdtraj = md.load(data_filename("ala_small_traj.pdb"))
self.traj = peng.trajectory_from_mdtraj(
self.mdtraj, simple_topology=True)
self.filename = data_filename("storage_test.nc")
self.filename_clone = data_filename("storage_test_clone.nc")
self.simplifier = ObjectJSON()
self.template_snapshot = self.traj[0]
self.solute_indices = list(range(22))
self.toy_topology = toys.Topology(
n_spatial=2,
masses=[1.0, 1.0],
pes=None
)
self.engine = toys.Engine({}, self.toy_topology)
self.toy_template = toys.Snapshot(
coordinates=np.array([[-0.5, -0.5]]),
velocities=np.array([[0.0,0.0]]),
engine=self.engine
)
def setup(self):
# PES is one-dimensional linear slope (y(x) = x)
pes = toys.LinearSlope(m=[-1.0], c=[0.0])
# one particle with mass 1.0
topology = toys.Topology(n_spatial=1, masses=[1.0], pes=pes)
integrator = toys.LeapfrogVerletIntegrator(0.02)
options = {
'integ': integrator,
'n_frames_max': 1000,
'n_steps_per_frame': 5
}
self.engine = toys.Engine(options=options, topology=topology)
# test uses three snapshots with different velocities
# 0: direction ok, velocity too low => falls back to dividing surface
# 1: wrong direction => backward shot towards B
# 2: direction ok, velocity high enough => successfull new trajectory
self.initial_snapshots = [
toys.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[1.0]]),
engine=self.engine),
toys.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[-1.0]]),
engine=self.engine),
toys.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[2.0]]),
engine=self.engine)
]
# reaction coordinate is just x coordinate
rc = paths.FunctionCV("Id", lambda snap: snap.coordinates[0][0])
# state A: [-inf, -1]
self.state_A = paths.CVDefinedVolume(rc, float("-inf"), -1.0)
# area between A and dividing surface: [-1, 0]
self.towards_A = paths.CVDefinedVolume(rc, -1.0, 0.0)
# state B: [1, inf]
self.state_B = paths.CVDefinedVolume(rc, 1.0, float("inf"))
# define state labels
self.state_labels = {
"A": self.state_A,
"B": self.state_B,
"ToA": self.towards_A,
"None": ~(self.state_A | self.state_B | self.towards_A)
}
# velocities are not randomized
randomizer = paths.NoModification()
self.filename = data_filename("rf_test.nc")
self.storage = paths.Storage(self.filename, mode="w")
self.storage.save(self.initial_snapshots)
self.simulation = ReactiveFluxSimulation(
storage=self.storage,
engine=self.engine,
states=[self.state_A, self.state_B],
randomizer=randomizer,
initial_snapshots=self.initial_snapshots,
rc=rc)
self.simulation.output_stream = open(os.devnull, 'w')
def setup(self):
integ = toys.LangevinBAOABIntegrator(dt=0.002,
temperature=1.0,
gamma=2.5)
options = {'integ': integ, 'n_frames_max': 5}
topology_2D = toys.Topology(n_spatial=2, masses=[1.0], pes=None)
engine_2D = toys.Engine(options=options, topology=topology_2D)
self.snap_2D = toys.Snapshot(coordinates=np.array([[0.0, 0.0]]),
velocities=np.array([[2.0, 4.0]]),
engine=engine_2D)
topology_6D = toys.Topology(n_spatial=3,
n_atoms=2,
masses=[1.0, 2.0],
pes=None)
engine_6D = toys.Engine(options=options, topology=topology_6D)
self.snap_6D = toys.Snapshot(coordinates=np.array([[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0]]),
velocities=np.array([[1.0, 0.0, 0.0],
[1.0, 0.0, 0.0]]),
engine=engine_6D)
def setup(self):
# PES is one-dimensional zero function (y(x) = 0)
pes = toys.LinearSlope(m=[0.0], c=[0.0])
topology = toys.Topology(n_spatial=1, masses=[1.0], pes=pes)
integrator = toys.LeapfrogVerletIntegrator(0.02)
options = {
'integ' : integrator,
'n_frames_max' : 1000,
'n_steps_per_frame' : 1
}
self.engine = toys.Engine(options=options, topology=topology)
# test uses snapshots with different velocities
self.initial_snapshots = [toys.Snapshot(
coordinates=np.array([[0.0]]),
velocities=np.array([[1.0]]),
engine=self.engine),
toys.Snapshot(
coordinates=np.array([[0.1]]),
velocities=np.array([[-1.0]]),
engine=self.engine),
toys.Snapshot(
coordinates=np.array([[-0.2]]),
velocities=np.array([[2.0]]),
engine=self.engine)]
# trajectory length is set to 100 steps
self.l = 100
# reaction coordinate is just x coordinate
rc = paths.FunctionCV("Id", lambda snap : snap.coordinates[0][0])
# state S: [-0.5, 0.5]
self.state_S = paths.CVDefinedVolume(rc, -0.5, 0.5)
# define state labels
self.state_labels = {
"S" : self.state_S,
"NotS" :~self.state_S}
# velocities are not randomized
randomizer = paths.NoModification()
self.filename = data_filename("sshooting_test.nc")
self.storage = paths.Storage(self.filename, mode="w")
self.storage.save(self.initial_snapshots)
self.simulation = SShootingSimulation(
storage=self.storage,
engine=self.engine,
state_S=self.state_S,
randomizer=randomizer,
initial_snapshots=self.initial_snapshots,
trajectory_length=self.l
)
self.simulation.output_stream = open(os.devnull, 'w')
def setup(self):
self.HAS_TQDM = paths.progress.HAS_TQDM
paths.progress.HAS_TQDM = False
# taken from the TestCommittorSimulation
import openpathsampling.engines.toy as toys
pes = toys.LinearSlope(m=[0.0], c=[0.0]) # flat line
topology = toys.Topology(n_spatial=1, masses=[1.0], pes=pes)
descriptor = peng.SnapshotDescriptor.construct(
toys.Snapshot,
{
'n_atoms': 1,
'n_spatial': 1
}
)
engine = peng.NoEngine(descriptor)
self.snap0 = toys.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[1.0]]),
engine=engine)
self.snap1 = toys.Snapshot(coordinates=np.array([[0.1]]),
velocities=np.array([[1.0]]),
engine=engine)
integrator = toys.LeapfrogVerletIntegrator(0.1)
options = {
'integ': integrator,
'n_frames_max': 10000,
'n_steps_per_frame': 5
}
self.engine = toys.Engine(options=options, topology=topology)
self.cv = paths.FunctionCV("Id", lambda snap: snap.coordinates[0][0])
self.left = paths.CVDefinedVolume(self.cv, float("-inf"), -1.0)
self.right = paths.CVDefinedVolume(self.cv, 1.0, float("inf"))
randomizer = paths.NoModification()
self.filename = data_filename("shooting_analysis.nc")
self.storage = paths.Storage(self.filename, mode="w")
self.simulation = paths.CommittorSimulation(
storage=self.storage,
engine=self.engine,
states=[self.left, self.right],
randomizer=randomizer,
initial_snapshots=[self.snap0, self.snap1]
)
self.simulation.output_stream = open(os.devnull, 'w')
self.simulation.run(20)
# set up the analysis object
self.analyzer = ShootingPointAnalysis(self.storage.steps,
[self.left, self.right])
def setup(self):
# PES is one-dimensional negative slope (y(x) = -x)
pes = toys.LinearSlope(m=[-1.0], c=[0.0])
topology = toys.Topology(n_spatial=1, masses=[1.0], pes=pes)
integrator = toys.LeapfrogVerletIntegrator(0.02)
options = {
'integ': integrator,
'n_frames_max': 1000,
'n_steps_per_frame': 1
}
self.engine = toys.Engine(options=options, topology=topology)
# test uses snapshots with different velocities
# (1) does not ever reach A
# (2) goes form A to S to B
# (3) goes from B to S to A
self.initial_snapshots = [
toys.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[1.0]]),
engine=self.engine),
toys.Snapshot(coordinates=np.array([[0.1]]),
velocities=np.array([[2.0]]),
engine=self.engine),
toys.Snapshot(coordinates=np.array([[-0.2]]),
velocities=np.array([[-2.0]]),
engine=self.engine)
]
# trajectory length is set to 100 steps
self.l = 100
# reaction coordinate is just x coordinate
rc = paths.FunctionCV("Id", lambda snap: snap.coordinates[0][0])
# state A: [-inf, -1]
self.state_A = paths.CVDefinedVolume(rc, float("-inf"), -1.0)
# state B: [1, inf]
self.state_B = paths.CVDefinedVolume(rc, 1.0, float("inf"))
# state S: [-0.5, 0.5]
self.state_S = paths.CVDefinedVolume(rc, -0.5, 0.5)
# define state labels
self.state_labels = {
"A": self.state_A,
"B": self.state_B,
"S": self.state_S,
"None": ~(self.state_A | self.state_B | self.state_S)
}
# velocities are not randomized
randomizer = paths.NoModification()
self.filename = data_filename("sshooting_test.nc")
self.storage = paths.Storage(self.filename, mode="w")
self.storage.save(self.initial_snapshots)
self.simulation = SShootingSimulation(
storage=self.storage,
engine=self.engine,
state_S=self.state_S,
randomizer=randomizer,
initial_snapshots=self.initial_snapshots,
trajectory_length=self.l)
self.simulation.output_stream = open(os.devnull, 'w')
self.simulation.run(n_per_snapshot=1)
self.analysis = SShootingAnalysis(
steps=self.storage.steps,
states=[self.state_A, self.state_B, self.state_S])
import argparse
def make_parser():
parser = argparse.ArgumentParser()
parser.add_argument('--nsteps', type=int, default=10000)
return parser
parser = make_parser()
opts = parser.parse_args()
n_steps = opts.nsteps
pes = (toys.OuterWalls([1.0,1.0], [0.0,0.0])
+ toys.Gaussian(-0.7, [30.0, 0.5], [-0.6, 0.0])
+ toys.Gaussian(-0.7, [30.0, 0.5], [0.6, 0.0])
+ toys.Gaussian(0.5, [85.0, 70.0], [0.1, 0.0]))
topology = toys.Topology(n_spatial=2, masses=[1.0, 1.0], pes=pes)
engine = toys.Engine(
{'integ': toys.LangevinBAOABIntegrator(dt=0.02,
temperature=0.1,
gamma=2.5),
'n_frames_max': 5000,
'n_steps_per_frame': 10}, topology)
template = toys.Snapshot(coordinates=np.array([[0.0, 0.0]]),
velocities=np.array([[0.0, 0.0]]),
engine=engine)
def val(snapshot, index):
return snapshot.xyz[0][index]
cv_x = paths.FunctionCV("xval", val, index=0)
cv_y = paths.FunctionCV("yval", val, index=1)
