def setup(self):
self.tmpdir = tempfile.mkdtemp()
self.storage_filename = os.path.join(self.tmpdir, "test.nc")
self.storage = paths.Storage(self.storage_filename, mode='w')
snap = make_1d_traj([1])[0]
self.storage.save(snap)
self.cv_x = paths.CoordinateFunctionCV("x", lambda s: s.xyz[0][0])
self.cv_y = paths.CoordinateFunctionCV("y", lambda s: s.xyz[0][1])
self.storage.save([self.cv_x, self.cv_y])
def test_safemode(self):
fname = data_filename("cv_storage_safemode_test.nc")
if os.path.isfile(fname):
os.remove(fname)
cv = paths.CoordinateFunctionCV('cv', lambda x: x)
traj = paths.Trajectory(list(self.traj))
template = traj[0]
storage_w = paths.Storage(fname, "w")
storage_w.snapshots.save(template)
storage_w.cvs.save(cv)
storage_w.close()
storage_r = paths.Storage(fname, 'r')
# default safemode = False
assert (storage_r.simplifier.safemode is False)
cv_r = storage_r.cvs[0]
assert (cv_r == cv)
assert (cv.cv_callable is not None)
storage_r.close()
storage_r = paths.Storage(fname, 'r')
storage_r.simplifier.safemode = True
cv_r = storage_r.cvs[0]
assert (cv_r == cv)
assert (cv_r.cv_callable is None)
storage_r.close()
def setup(self):
# set up the trajectory that we'll annotate in the tests
self.traj = make_1d_traj(
[-1, 1, 4, 3, 6, 11, 22, 33, 23, 101, 205, 35, 45])
# set up some states to test later
# this system is designed under the assumption that the "states" are
# defined by how many digits are in the x-coordinate (and I'll
# intentionally fail to identify some of them)
self.cv = paths.CoordinateFunctionCV("x", lambda s: s.xyz[0][0])
self.state_1 = paths.CVDefinedVolume(self.cv, 0, 9)
self.state_2 = paths.CVDefinedVolume(self.cv, 10, 99)
self.state_3 = paths.CVDefinedVolume(self.cv, 100, 999)
# create the annotations
self.annotation_1 = Annotation(state="1-digit", begin=1, end=4)
self.annotation_2 = Annotation(state="2-digit", begin=6, end=8)
self.annotation_3 = Annotation(state="3-digit", begin=10, end=10)
self.annotation_4 = Annotation(state="2-digit", begin=11, end=12)
self.states = {
"1-digit": self.state_1,
"2-digit": self.state_2,
"3-digit": self.state_3
}
self.annotated = AnnotatedTrajectory(self.traj)
self.annotations = [
self.annotation_1, self.annotation_2, self.annotation_3,
self.annotation_4
]
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_analysis(self):
# check wrong analyze_single_step() argument
empty_dict = self.analysis.analyze_single_step(3.1415)
assert empty_dict == {}
# dictionary with three entries returned
assert len(self.analysis) == 3
# run C_AB() in advance, this triggers calculate_averages()
cab = self.analysis.C_AB()
assert len(cab) == self.l + 1
assert cab.sum() > 0
# get total and per-snapshot results
M, Ns, I_Bt, Ns_Bt, hAhB_Bt, sres = self.analysis.calculate_averages()
# check total number of generated subtrajectories
assert M == 3 * (self.l + 1)
# since we did not use a bias Ns_Bt should be 1.0
np.testing.assert_almost_equal(Ns_Bt, 1.0)
# now do the same tests on a per-snapshot basis
snaps = sres.keys()
for snap in snaps:
assert sres[snap]["M"] == self.l + 1
np.testing.assert_almost_equal(sres[snap]["Ns_Bt"], 1.0)
# check whether time correlation is only filled for case (2), for
# case (1) and (3) the array should be empty.
if snap.xyz[0][0] == 0.0:
np.testing.assert_almost_equal(
np.array(sres[snap]["hAhB_Bt"]).sum(), 0)
elif snap.xyz[0][0] == 0.1:
assert np.array(sres[snap]["hAhB_Bt"]).sum() > 0
elif snap.xyz[0][0] == -0.2:
np.testing.assert_almost_equal(
np.array(sres[snap]["hAhB_Bt"]).sum(), 0)
# run C_AB() afterwards, this triggers another if clause
cab = self.analysis.C_AB()
assert len(cab) == self.l + 1
assert cab.sum() > 0
# try another analysis with different arguments for complete coverage
def dummy_bias(x):
return 1.0
cv_b = paths.CoordinateFunctionCV(name="cv_b", f=dummy_bias)
rc = paths.FunctionCV("Id", lambda snap: snap.coordinates[0][0])
self.state_S2 = paths.CVDefinedVolume(rc, -0.55, 0.05)
self.analysis2 = SShootingAnalysis(
steps=self.storage.steps,
states=[self.state_A, self.state_B, self.state_S2],
bias=cv_b)
with pytest.raises(NotImplementedError):
self.analysis.committor()
with pytest.raises(NotImplementedError):
self.analysis.committor_histogram()
def setup(self):
xval = paths.CoordinateFunctionCV(name="xA", f=lambda s: s.xyz[0][0])
self.stateA = paths.CVDefinedVolume(xval, -1.0, -0.5).named("A")
self.stateB = paths.CVDefinedVolume(xval, 0.5, float("inf")).named("B")
self.ifacesA = paths.VolumeInterfaceSet(xval, -1.0,
[-0.5, -0.4, -0.3, -0.2])
self.ifacesB = paths.VolumeInterfaceSet(xval, [0.5, 0.4, 0.3, 0.2],
1.0)
self.tcp_A = paths.numerics.LookupFunction(
ordinate=[-0.5, -0.4, -0.3, -0.2, -0.1],
abscissa=[1.0, 0.5, 0.25, 0.125, 0.0625])
self.tcp_B = paths.numerics.LookupFunction(
ordinate=[0.5, 0.4, 0.3, 0.2, 0.1],
abscissa=[1.0, 0.2, 0.04, 0.008, 0.0016])
def make_mstis_network():
opA = paths.CoordinateFunctionCV(name="opA", f=circle, center=[-0.5, -0.5])
opB = paths.CoordinateFunctionCV(name="opB", f=circle, center=[0.5, -0.5])
opC = paths.CoordinateFunctionCV(name="opC", f=circle, center=[0.0, 0.4])
stateA = paths.CVDefinedVolume(opA, 0.0, 0.2).named("A")
stateB = paths.CVDefinedVolume(opB, 0.0, 0.2).named("B")
stateC = paths.CVDefinedVolume(opC, 0.0, 0.2).named("C")
interfacesA = paths.VolumeInterfaceSet(opA, 0.0, [0.2, 0.3, 0.4])
interfacesB = paths.VolumeInterfaceSet(opB, 0.0, [0.2, 0.3, 0.4])
interfacesC = paths.VolumeInterfaceSet(opC, 0.0, [0.2, 0.3, 0.4])
ms_outers = paths.MSOuterTISInterface.from_lambdas(
{ifaces: 0.5
for ifaces in [interfacesA, interfacesB, interfacesC]}
)
mstis = paths.MSTISNetwork(
[(stateA, interfacesA),
(stateB, interfacesB),
(stateC, interfacesC)],
ms_outers=ms_outers
)
return mstis
def __init__(self, steps, states, bias=None):
# SShootingAnalysis is inherited from ShootinPointAnalysis but
# overrides the __init__ function. Thus, the call to the
# SnapshotByCoordinateDict __init__ function has to be repeated
# here (ugly)!
SnapshotByCoordinateDict.__init__(self)
#super(ShootingPointAnalysis, self).__init__()
# Definition of states A, B and S.
self.state_A = states[0]
self.state_B = states[1]
self.state_S = states[2]
# If called without bias create a dummy one.
if bias is None:
def dummy_bias(x):
return 1.0
cv_b = paths.CoordinateFunctionCV(name="cv_b", f=dummy_bias)
self.bias = cv_b
else:
self.bias = bias
# Initialize inconsistency counter.
self.count_inconsistent_S = 0
# Set one-direction shot length l.
self.l = steps[0].simulation.trajectory_length
# Prepare array for time correlation function.
self._CABxhA_hS = None
# Analyze each trajectory.
if steps is not None:
self.analyze(steps)
# Issue a warning if some trajectories were harvested with a different
# settings for the S region.
if self.count_inconsistent_S > 0:
logging.warning("Some trajectories (" +
str(self.count_inconsistent_S) +
" cases) were harvested with a different S region "
"definition than the one provided for the "
"analysis. Trajectories with starting snapshots "
"out of the given S region were ignored.")
def test_iter_generate_clear_cache(self):
# when running with iter_generate, only the most recently generated
# snapshot should contain data -- the others should have their cache
# cleared
if not has_gmx:
pytest.skip("Gromacs (gmx) not found. Skipping test.")
if not HAS_MDTRAJ:
pytest.skip("MDTraj not found. Skipping test.")
def continue_condition(trajectory, trusted=False):
if len(trajectory) == 5:
return False
for snap in trajectory[1:-1]:
# the initial snapshot does not get cleared
# the final snapshot has not yet been cleared
assert snap._xyz is None
assert snap._velocities is None
assert snap._box_vectors is None
# the final snapshot should have been loaded, and not yet
# cleared
assert trajectory[-1]._xyz is not None
assert trajectory[-1]._velocities is not None
assert trajectory[-1]._box_vectors is not None
return True
cv_x0 = paths.CoordinateFunctionCV('x0', lambda snap: snap.xyz[0][0])
in_all_space = paths.AllInXEnsemble(
paths.CVDefinedVolume(cv_x0, float("-inf"), float("inf")))
traj_0 = self.engine.trajectory_filename(0)
snap = self.engine.read_frame_from_file(traj_0, 0)
self.engine.filename_setter.reset(0)
traj = self.engine.generate(
snap, running=[in_all_space.can_append, continue_condition])
assert len(traj) == 5
ttraj = md.load(self.engine.trajectory_filename(1),
top=self.engine.gro)
assert len(ttraj) < 100
def tps_network():
cv = paths.CoordinateFunctionCV('x', lambda s: s.xyz[0][0])
state_A = paths.CVDefinedVolume(cv, float("-inf"), 0).named("A")
state_B = paths.CVDefinedVolume(cv, 0, float("inf")).named("B")
network = paths.TPSNetwork(state_A, state_B).named('tps-network')
return network
def test_storage_sync(self):
import os
# test all combinations of (1) with and without UUIDs,
# (2) using partial yes; all of these must work
allow_incomplete = True
# print
# print
for use_uuid in [True]:
# print '=========================================================='
# print 'UUID', use_uuid
# print '=========================================================='
fname = data_filename("cv_storage_test.nc")
if os.path.isfile(fname):
os.remove(fname)
traj = paths.Trajectory(list(self.traj_simple))
template = traj[0]
storage_w = paths.Storage(fname, "w")
storage_w.snapshots.save(template)
cv1 = paths.CoordinateFunctionCV(
'f1', lambda snapshot: snapshot.coordinates[0]).with_diskcache(
allow_incomplete=allow_incomplete)
# let's mess up the order in which we save and
# include reversed ones as well
assert (len(storage_w.snapshots) == 2)
storage_w.trajectories.save(traj[6:])
assert (len(storage_w.snapshots) == 10)
storage_w.snapshots.save(traj[1].reversed)
assert (len(storage_w.snapshots) == 12)
storage_w.save(cv1)
store = storage_w.cvs.cache_store(cv1)
assert (len(store.vars['value']) == 0)
storage_w.snapshots.sync_cv(cv1)
# nothing added to the cache so no changes
assert (len(store.vars['value']) == 1)
# fill the cache
_ = cv1(traj)
storage_w.snapshots.sync_cv(cv1)
# should match the number of stored snapshots
assert (len(store.vars['value']) == 6)
# save the rest
storage_w.trajectories.save(traj.reversed)
assert (len(storage_w.snapshots) == 20)
# should still be unchanged
assert (len(store.vars['value']) == 6)
# this should store the remaining CV values
storage_w.snapshots.sync_cv(cv1)
assert (len(store.vars['value']) == 10)
# check if the values match
for idx, value in zip(store.variables['index'][:],
store.vars['value']):
snap = storage_w.snapshots[storage_w.snapshots.vars['uuid']
[idx]]
assert_close_unit(cv1(snap), value)
storage_w.close()
if os.path.isfile(fname):
os.remove(fname)
def test_storage_sync_and_complete(self):
import os
# test all combinations of (1) with and without UUIDs,
# (2) using partial yes, no all of these must work
allow_incomplete = True
# print
# print
for use_uuid in [True]:
# print '=========================================================='
# print 'UUID', use_uuid
# print '=========================================================='
fname = data_filename("cv_storage_test.nc")
if os.path.isfile(fname):
os.remove(fname)
traj = paths.Trajectory(list(self.traj_simple))
template = traj[0]
storage_w = paths.Storage(fname, "w")
storage_w.snapshots.save(template)
cv1 = paths.CoordinateFunctionCV(
'f1', lambda snapshot: snapshot.coordinates[0]).with_diskcache(
allow_incomplete=allow_incomplete)
# let's mess up the order in which we save and include
# reversed ones as well
assert (len(storage_w.snapshots) == 2)
storage_w.trajectories.save(traj[3:])
assert (len(storage_w.snapshots) == 16)
storage_w.snapshots.save(traj[1].reversed)
assert (len(storage_w.snapshots) == 18)
storage_w.trajectories.save(traj.reversed)
assert (len(storage_w.snapshots) == 20)
storage_w.save(cv1)
store = storage_w.cvs.cache_store(cv1)
assert (len(store.vars['value']) == 0)
storage_w.snapshots.complete_cv(cv1)
assert (len(store.vars['value']) == 10)
# check if stored values match computed ones
for idx, value in zip(store.variables['index'][:],
store.vars['value']):
snap = storage_w.snapshots[storage_w.snapshots.vars['uuid']
[idx]]
# print(snap, snap.__uuid__, value)
assert_close_unit(cv1(snap), value)
storage_w.close()
if os.path.isfile(fname):
os.remove(fname)
def test_storage_cv_function(self):
import os
# test all combinations of (1) with and without UUIDs,
# (2) using partial yes, no all of these must work
for allow_incomplete in (True, False):
# print '=========================================================='
# print 'PARTIAL', allow_incomplete
# print '=========================================================='
fname = data_filename("cv_storage_test.nc")
if os.path.isfile(fname):
os.remove(fname)
traj = paths.Trajectory(list(self.traj_simple))
template = traj[0]
storage_w = paths.Storage(fname, "w")
storage_w.snapshots.save(template)
cv1 = paths.CoordinateFunctionCV(
'f1', lambda x: x.coordinates[0]).with_diskcache(
allow_incomplete=allow_incomplete)
storage_w.save(cv1)
# let's mess up the order in which we save and
# include reversed ones as well
assert (len(storage_w.snapshots) == 2)
storage_w.trajectories.save(traj[3:])
assert (len(storage_w.snapshots) == 16)
storage_w.snapshots.save(traj[1].reversed)
assert (len(storage_w.snapshots) == 18)
storage_w.trajectories.save(traj.reversed)
assert (len(storage_w.snapshots) == 20)
# this should be ignored for all is saved already
storage_w.trajectories.save(traj)
storage_w.close()
storage_r = paths.AnalysisStorage(fname)
rcv1 = storage_r.cvs['f1']
assert (rcv1._store_dict)
cv_cache = rcv1._store_dict.value_store
assert (cv_cache.allow_incomplete == allow_incomplete)
for idx, snap in enumerate(storage_r.trajectories[1]):
# print idx, snap
# if hasattr(snap, '_idx'):
# print 'Proxy IDX', snap._idx
# print 'ITEMS', storage_r.snapshots.index.items()
# print snap, type(snap), snap.__dict__
# print snap.__uuid__
# print snap.reversed.__uuid__
# print snap.create_reversed().__uuid__
#
# print 'POS', cv_cache.object_pos(snap),
# print 'POS', storage_r.snapshots.pos(snap),
# print 'POS', storage_r.snapshots.index[snap]
#
# print 'POS', cv_cache.object_pos(snap.reversed),
# print 'POS', storage_r.snapshots.pos(snap.reversed),
# print 'POS', storage_r.snapshots.index[snap.reversed]
# if len(cv_cache.cache._chunkdict) > 0:
#
# if allow_incomplete:
# print cv_cache.index
# print cv_cache.vars['value'][:]
#
# for n, v in enumerate(cv_cache.cache._chunkdict[0]):
# print n, v
#
# print cv1(snap)
# print cv1(snap.reversed)
# print cv_cache[snap]
#
# print cv_cache[snap.reversed]
if not allow_incomplete or cv_cache[snap] is not None:
assert_close_unit(cv_cache[snap], cv1(snap))
assert_close_unit(cv_cache[snap.reversed],
cv1(snap.reversed))
storage_r.close()
if os.path.isfile(fname):
os.remove(fname)
def cv_and_states():
cv = paths.CoordinateFunctionCV("x", lambda s: s.xyz[0][0])
state_A = paths.CVDefinedVolume(cv, float("-inf"), 0).named("A")
state_B = paths.CVDefinedVolume(cv, 1, float("inf")).named("B")
return cv, state_A, state_B
f=md.compute_contacts,
topology=template.topology,
scheme='closest-heavy',
ignore_nonprotein=False,
periodic=False).with_diskcache()
def distance(snapshot, receptor_atoms, ligand_atoms):
import numpy as np
receptor_com = snapshot.xyz[receptor_atoms, :].mean(0)
ligand_com = snapshot.xyz[ligand_atoms, :].mean(0)
return np.sqrt(((receptor_com - ligand_com)**2).sum())
cv = paths.CoordinateFunctionCV(name="distance",
f=distance,
receptor_atoms=receptor_atoms,
ligand_atoms=ligand_atoms).with_diskcache()
storage.save([cv])
# State definitions
states = ['bound ', 'unbound']
max_bound = 0.05 # nanometers, maximum bound state separation distance
min_unbound = 0.90 # nanometers, minimum unbound state separation distance
print('Creating interfaces...')
ninterfaces = 100
bound = paths.CVDefinedVolume(cv, lambda_min=0.0, lambda_max=max_bound)
unbound = paths.CVDefinedVolume(cv,
lambda_min=min_unbound,
lambda_max=float("inf"))
