def test_multiple_initial_snapshots(self):
snap1 = toys.Snapshot(coordinates=np.array([[0.1]]),
velocities=np.array([[-1.0]]),
engine=self.engine)
sim = CommittorSimulation(storage=self.storage,
engine=self.engine,
states=[self.left, self.right],
randomizer=paths.NoModification(),
initial_snapshots=[self.snap0, snap1])
sim.run(10)
assert_equal(len(self.storage.steps), 20)
snap0_coords = self.snap0.coordinates.tolist()
snap1_coords = snap1.coordinates.tolist()
count = {self.snap0: 0, snap1: 0}
for step in self.storage.steps:
shooting_snap = step.change.canonical.details.shooting_snapshot
if shooting_snap.coordinates.tolist() == snap0_coords:
mysnap = self.snap0
elif shooting_snap.coordinates.tolist() == snap1_coords:
mysnap = snap1
else:
msg = "Shooting snapshot matches neither test snapshot"
raise AssertionError(msg)
count[mysnap] += 1
assert_equal(count, {self.snap0: 10, snap1: 10})
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):
# 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 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):
# 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 test_backward_only_committor(self):
sim = CommittorSimulation(storage=self.storage,
engine=self.engine,
states=[self.left, self.right],
randomizer=paths.NoModification(),
initial_snapshots=self.snap0,
direction=-1)
sim.output_stream = open(os.devnull, 'w')
sim.run(n_per_snapshot=10)
assert_equal(len(sim.storage.steps), 10)
for step in self.simulation.storage.steps:
s = step.active[0]
step.active.sanity_check() # traj is in ensemble
assert_equal(
s.trajectory.summarize_by_volumes_str(self.state_labels),
"Left-None")
assert_equal(s.ensemble, sim.backward_ensemble)
assert_equal(step.change.canonical.mover, sim.backward_mover)
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])