def test_shapes():
mid2 = molecule.load("graphics", "test")
assert graphics.listall(mid2) == []
with pytest.raises(ValueError):
graphics.cone(molid=mid2+1, v1=(0,0,0), v2=(3,5,9))
assert graphics.cone(molid=mid2, v1=(0,0,0), v2=(3,5,9)) == 0
assert graphics.triangle(mid2, (1,0,0), (0,1,0), (0,0,1)) == 1
assert graphics.listall(mid2) == [0, 1]
graphics.trinorm(mid2, (1,0,0), (0,1,0), (0,0,1),
n1=(0,1,0), n2=(1,0,0), n3=(0,0,1))
graphics.cylinder(mid2, v1=(10,10,0), v2=(0,10,10), radius=3.,
resolution=4, filled=True)
graphics.point(mid2, (20, 3, 1))
graphics.line(mid2, (-1,1,-3), (3,4,5))
with pytest.raises(ValueError):
graphics.line(mid2, (-1,1,-3), (3,4,5), style="invalid")
assert len(graphics.listall(mid2)) == 6
graphics.delete(mid2, "all")
assert len(graphics.listall(mid2)) == 0
with pytest.raises(ValueError):
graphics.delete(mid2, "invalid")
with pytest.raises(TypeError):
graphics.delete(mid2, 39.0)
molecule.delete(mid2)
def test_materials():
mid = molecule.new(name="Test")
graphics.materials(molid=mid, on=True)
graphics.material(molid=mid, name="AOShiny")
rc = graphics.sphere(molid=mid, center=(1,1,1), radius=5.1, resolution=8)
assert graphics.info(mid, rc) == "sphere {1.000000 1.000000 1.000000} " +\
"radius 5.100000 resolution 8"
with pytest.raises(ValueError):
graphics.sphere(molid=mid, center=(1,1))
rc = graphics.text(mid, (0,0,0), "hello world", size=4.0, width=2.0)
with pytest.raises(ValueError):
graphics.text(mid, 0, "oops")
assert graphics.info(mid, rc) == "text {0.000000 0.000000 0.000000} " + \
"{hello world} size 4.000000 thickness 2.000000"
with pytest.raises(ValueError):
graphics.info(mid+1, 3)
with pytest.raises(IndexError):
graphics.info(mid, 3000)
graphics.delete(mid, rc)
with pytest.raises(IndexError):
graphics.info(mid, rc)
molecule.delete(mid)
def test_multiligand_psf_opls(tmpdir):
"""
Charmm parameters, OPLS AA/M format
"""
from dabble.param import CharmmWriter
p = str(tmpdir)
molid = molecule.load("mae",
os.path.join(dir, "test_multiligand_correct.mae"))
# lipid unsupported
w = CharmmWriter(tmp_dir=p,
molid=molid,
forcefield="opls",
extra_topos=[os.path.join(dir, "dalp_opls.rtf")],
extra_params=[os.path.join(dir, "dalp_opls.prm")])
with pytest.raises(ValueError):
w.write(os.path.join(p, "test"))
# No lipid should work
molecule.delete(molid)
molid = molecule.load("mae", os.path.join(dir, "B2AR_10ALPs.mae"))
w = CharmmWriter(tmp_dir=p,
molid=molid,
forcefield="opls",
extra_topos=[os.path.join(dir, "dalp_opls.rtf")],
extra_params=[os.path.join(dir, "dalp_opls.prm")])
w.write(os.path.join(p, "test"))
check_result("psf", p, solvent=False, lipid=False)
def write(self):
"""
Writes the final built system.
Args:
filename (str): Name of file
"""
fileutils.check_write_ok(self.opts.get('output_filename'),
self.out_fmt,
overwrite=self.opts.get('overwrite'))
final_id = self._build()
print("Writing system to %s with %d atoms comprising:\n"
" %d lipid molecules\n"
" %d water molecules\n"
% (self.opts.get('output_filename'),
molutils.num_atoms_remaining(molid=final_id),
molutils.num_lipids_remaining(final_id, self.opts.get('lipid_sel')),
molutils.num_waters_remaining(molid=final_id)))
fileutils.write_final_system(out_fmt=self.out_fmt,
out_name=self.opts.get('output_filename'),
molid=final_id, tmp_dir=self.tmp_dir,
forcefield=self.opts.get('forcefield'),
extra_topos=self.opts.get('extra_topos'),
extra_params=self.opts.get('extra_params'),
extra_streams=self.opts.get('extra_streams'),
hmassrepartition=self.opts.get('hmassrepartition'))
molecule.delete(final_id)
def test_amber_custom_residues(tmpdir):
from dabble.param import AmberWriter
# Generate the file
p = str(tmpdir)
molid = molecule.load("mae", os.path.join(dir, "prepped.mae"))
w = AmberWriter(molid,
tmp_dir=p,
forcefield="amber",
hmr=False,
extra_topos=[
os.path.join(dir, "glx.off"),
os.path.join(dir, "lyx.off")
],
extra_params=[
os.path.join(dir, "join.frcmod"),
os.path.join(dir, "analogies.frcmod")
],
override_defaults=False)
w.write(os.path.join(p, "test"))
# Load the output file and start checking it
m2 = molecule.load("parm7", os.path.join(p, "test.prmtop"), "rst7",
os.path.join(p, "test.inpcrd"))
verify_amber(m2)
molecule.delete(m2)
def test_show_fix(file_3nob):
m = molecule.load("mae", file_3nob)
trans.show(molid=m, shown=True)
assert trans.is_shown(m)
with pytest.raises(ValueError):
trans.show(m+1, True)
with pytest.raises(ValueError):
trans.is_shown(m+1)
trans.show(m, False)
assert not trans.is_shown(molid=m)
trans.fix(m, fixed=False)
assert not trans.is_fixed(m)
trans.fix(m, True)
assert trans.is_fixed(m)
with pytest.raises(ValueError):
trans.fix(m+1, True)
with pytest.raises(ValueError):
trans.is_fixed(m+1)
molecule.delete(m)
def center_system(molid, tmp_dir, center_z=False):
"""
Centers an entire system in the XY-plane, and optionally in the Z
dimension. Needs to save and reload the file in case the current
positions need to be concatenated to produce a new file.
Args:
molid (int): VMD molecule id to center
tmp_dir (str): Directory to create temp file in
center_z (bool): Whether or not to center along the Z axis as well
Returns:
(int) : VMD molecule id of centered system
"""
# pylint: disable=invalid-name
x, y, z = atomsel('all', molid=molid).center()
if center_z is True:
atomsel('all', molid=molid).moveby((-x, -y, -z))
else:
atomsel('all', molid=molid).moveby((-x, -y, 0))
# Save and reload the solute to record atom positions
temp_mae = tempfile.mkstemp(suffix='.mae',
prefix='dabble_centered',
dir=tmp_dir)[1]
atomsel('all', molid=molid).write('mae', temp_mae)
molecule.delete(molid)
new_id = molecule.load('mae', temp_mae)
return new_id
def test_mol_center(file_3nob):
m = molecule.load("mae", file_3nob)
init_center = trans.get_center(m)
trans.set_center(m, center=(1., 1., 1.))
assert trans.get_center(m) == pytest.approx((1., 1., 1.))
trans.set_center(m, center=[0., 0., 0.])
assert trans.get_center(m) == pytest.approx((0., 0., 0.))
with pytest.raises(ValueError):
trans.get_center(molid=m+1)
with pytest.raises(ValueError):
trans.set_center(m+1, (3., 2., 1.))
with pytest.raises(TypeError):
trans.set_center(molid=m, center=(1.))
trans.resetview(m)
assert trans.get_center(m) == pytest.approx(init_center)
with pytest.raises(ValueError):
trans.resetview(molid=m+1)
molecule.delete(m)
def test_mol_rotate(file_3nob):
m = molecule.load("mae", file_3nob)
r = trans.get_rotation(molid=m)
assert r == pytest.approx((1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0))
newrot = [x+2. for x in r]
trans.set_rotation(m, newrot)
assert trans.get_rotation(molid=m) == pytest.approx(newrot)
with pytest.raises(ValueError):
trans.get_rotation(m+1)
with pytest.raises(ValueError):
trans.set_rotation(m+1, [0.]*16)
with pytest.raises(TypeError):
trans.set_rotation(molid=m, matrix=12)
with pytest.raises(TypeError):
trans.set_rotation(m, [True]*16)
trans.resetview(m)
assert trans.get_rotation(m) == r
molecule.delete(m)
def test_measure(file_3nob):
m1 = molecule.load("mae", file_3nob)
m2 = molecule.load("mae", file_3nob)
with pytest.warns(SyntaxWarning):
assert measure.bond(0, 0, m1, m2, frame=0, first=0) == [pytest.approx(0.)]
assert measure.bond(atom1=0, atom2=10, molid=m1)[0] == pytest.approx(4.97422456)
assert measure.bond(atom1=0, atom2=10)[0] == pytest.approx(4.97422456)
# One atom listed multiple times
with pytest.raises(RuntimeError):
measure.angle(0, 0, 0)
with pytest.warns(SyntaxWarning):
assert measure.angle(0, 1, 2, frame=0,
last=1) == [pytest.approx(119.7387237548)]
assert measure.angle(atom1=0, atom2=1, atom3=0, molid=m1, molid2=m2,
molid3=m1)[0] == pytest.approx(0.0)
with pytest.raises(RuntimeError):
measure.dihedral(0,0,0,0)
molecule.delete(m1)
molecule.delete(m2)
def test_pdb_amber_custom_residues(tmpdir):
from dabble.param import AmberWriter
p = str(tmpdir)
molid = molecule.load("pdb", os.path.join(dir, "prepped.pdb"))
w = AmberWriter(molid,
tmp_dir=p,
forcefield="amber",
hmr=False,
extra_topos=[
os.path.join(dir, "glx.off"),
os.path.join(dir, "lyx.off")
],
extra_params=[
os.path.join(dir, "join.frcmod"),
os.path.join(dir, "analogies.frcmod")
],
override_defaults=False)
w.write(os.path.join(p, "test"))
# Check for correctness
m2 = molecule.load("parm7", os.path.join(p, "test.prmtop"), "rst7",
os.path.join(p, "test.inpcrd"))
verify_amber(m2)
molecule.delete(m2)
def test_atomsel_update(file_3frames):
m = molecule.load("pdb", file_3frames)
atomsel("resid 1", m, frame=2).user = 1.0
sel = atomsel("user 1.0", molid=m, frame=-1)
assert sel.frame == -1
assert sel.index == list(range(10))
altersel = atomsel("index 9", m, frame=2)
altersel.user = 0.0
assert atomsel("index 8 9", m, frame=2).user == approx([1.0, 0.0])
assert atomsel("index 8 9", m, frame=0).user == approx([0.0, 0.0])
# Selection should only change if the frame is set to update
molecule.set_frame(m, 2)
assert sel.index == list(range(10))
sel.update()
assert sel.index == list(range(9))
# Now put it back to another frame
sel.frame = 0
assert sel.frame == 0
assert sel.index == list(range(9))
sel.update()
assert sel.index == []
molecule.delete(m)
def test_basic_load(file_3nob):
assert molecule.num() == 0
assert molecule.listall() == []
m = molecule.load("mae", file_3nob)
assert molecule.num() == 1
assert molecule.listall() == [m]
assert molecule.exists(m)
assert not molecule.exists(m + 1)
assert molecule.name(m) == "3nob.mae"
with pytest.raises(ValueError):
molecule.name(m + 1)
molecule.rename(m, "newname")
assert molecule.name(m) == "newname"
with pytest.raises(ValueError):
molecule.rename(name="wrong id", molid=m + 1)
assert molecule.numatoms(molid=m) == 2481
with pytest.raises(ValueError):
molecule.numatoms(m + 1)
molecule.delete(m)
with pytest.raises(ValueError):
molecule.delete(m)
def test_mol_time(file_3frames):
m = molecule.load("pdb", file_3frames)
assert molecule.numframes(m) == 3
assert molecule.get_physical_time(molid=m, frame=0) == pytest.approx(0.0)
with pytest.raises(ValueError):
molecule.get_physical_time(m+1)
# Test all valid combinations of default keyword arguments
molecule.set_frame(m, 0)
molecule.set_physical_time(molid=m, frame=2, time=20.0)
molecule.set_physical_time(m, 10.0, frame=1)
molecule.set_physical_time(m, 3.0)
assert molecule.get_physical_time(m) == pytest.approx(3.0)
molecule.set_frame(m, frame=2)
assert molecule.get_physical_time(molid=m) == pytest.approx(20.0)
assert molecule.get_physical_time(m, frame=1) == pytest.approx(10.0)
with pytest.raises(ValueError):
molecule.set_physical_time(molid=m+1, time=20.0)
with pytest.raises(ValueError):
molecule.set_physical_time(m, time=30.0, frame=3000)
molecule.delete(m)
def test_add_representation(file_3nob):
m = molecule.load("mae", file_3nob)
assert molrep.num(m) == 1
with pytest.raises(ValueError):
molrep.num(m+1)
with pytest.raises(ValueError):
molrep.addrep(molid=m, style="Invalid")
with pytest.raises(ValueError):
molrep.addrep(m, style="NewCartoon", color="Invalid")
with pytest.raises(ValueError):
molrep.addrep(m, "NewCartoon", "Type", selection="unparseable")
with pytest.raises(ValueError):
molrep.addrep(m, "NewCartoon", "Type", "protein", material="Invalid")
r = molrep.addrep(style="NewCartoon", color="ResID", selection="protein",
material="AOShiny", molid=m)
assert r == 1
with pytest.raises(ValueError):
molrep.delrep(m+1, 0)
with pytest.raises(ValueError):
molrep.delrep(m, rep=r+1)
molrep.delrep(rep=r, molid=m)
assert molrep.num(m) == 1
molecule.delete(m)
def test_special_load(file_3nob, file_3frames, file_psf):
# Graphics type is special
m = molecule.load("graphics", "")
assert molecule.numatoms(m) == 0
molecule.delete(m)
# Coordinates and data
m = molecule.load(struct_type="psf", coord_type="pdb",
struct_file=file_psf,
coord_file=file_3frames)
assert molecule.numframes(m) == 3
# Incorrect numbers of arguments
with pytest.raises(ValueError):
molecule.load("psf", file_psf, coord_type="pdb")
with pytest.raises(ValueError):
molecule.load("psf", file_psf, coord_file=file_3frames)
# Nonexistent files
with pytest.raises(RuntimeError):
molecule.load("psf", "nonexistent_file")
with pytest.raises(RuntimeError):
molecule.load("psf", file_psf, "pdb", "nonexistent_file")
# Wrong number of atoms in coordinate data
with pytest.raises(RuntimeError):
x = molecule.load("mae", file_3nob, "pdb", file_3frames)
print(molecule.get_filenames(x))
molecule.delete(m)
def center_system(molid, tmp_dir, center_z=False):
"""
Centers an entire system in the XY-plane, and optionally in the Z
dimension. Needs to save and reload the file in case the current
positions need to be concatenated to produce a new file.
Args:
molid (int): VMD molecule id to center
tmp_dir (str): Directory to create temp file in
center_z (bool): Whether or not to center along the Z axis as well
Returns:
(int) : VMD molecule id of centered system
"""
# pylint: disable=invalid-name
x, y, z = atomsel('all', molid=molid).center()
if center_z is True:
atomsel('all', molid=molid).moveby((-x, -y, -z))
else:
atomsel('all', molid=molid).moveby((-x, -y, 0))
# Save and reload the solute to record atom positions
temp_mae = tempfile.mkstemp(suffix='.mae',
prefix='dabble_centered',
dir=tmp_dir)[1]
atomsel('all', molid=molid).write('mae', temp_mae)
molecule.delete(molid)
new_id = molecule.load('mae', temp_mae)
return new_id
def load_solute(filename, tmp_dir):
"""
Loads a molecule input file, guessing the format from the extension.
Args:
filename (str): Filename to load
tmp_dir (str): Directory to put temporary files in
Returns:
(int) VMD molecule ID that was loaded
Raises:
ValueError if filetype is currently unsupported
"""
if len(filename) < 3:
raise ValueError("Cannot determine filetype of input file '%s'"
% filename)
ext = filename[-3:]
if ext == 'mae':
molid = molecule.load('mae', filename)
elif ext == 'dms':
molid = molecule.load('dms', filename)
elif ext == 'pdb':
# Need to convert to MAE so concatenation will work later
temp_mae = tempfile.mkstemp(suffix='.mae', prefix='dabble_input',
dir=tmp_dir)[1]
molid = molecule.load('pdb', filename)
atomsel('all').write('mae', temp_mae)
molecule.delete(molid)
molid = molecule.load('mae', temp_mae)
else:
raise ValueError("Filetype '%s' currently unsupported "
"for input protein" % ext)
return molid
def test_angles(file_3nob):
with pytest.raises(ValueError):
topology.angles(molid=0)
m = molecule.load("mae", file_3nob)
molecule.set_top(m)
# No angles defined in a mae file
x = topology.angles(molid=m, type=True)
print(len(x))
assert len(x) == 0
assert topology.angletypes() == []
# pass invalid molid
with pytest.raises(ValueError):
topology.addangle(0, 0, 0, molid=-1999)
assert topology.addangle(i=0, j=1, k=2, molid=m) == 0
assert topology.angles(m, True) == [(0, 1, 2, None)]
x = topology.addangle(0, 0, 0, molid=m, type="angle2")
assert topology.angles(m, True)[x] == (0, 0, 0, "angle2")
assert topology.delangle(i=0, j=0, k=0, molid=m)
assert topology.angles(m, True) == [(0, 1, 2, None)]
assert not topology.delangle(1, 2, 3, molid=m)
assert topology.delallangles(m) == 1
assert topology.angletypes() == ["angle2"]
molecule.delete(m)
def test_colorscale(file_3nob):
m = molecule.load("mae", file_3nob)
r = molrep.addrep(color="User2", selection="lipid", molid=m)
assert molrep.get_scaleminmax(m, r) == pytest.approx((0., 0.))
with pytest.raises(ValueError):
molrep.get_scaleminmax(m+1, 0)
with pytest.raises(ValueError):
molrep.get_scaleminmax(m, r+1)
molrep.set_scaleminmax(molid=m, rep=r, scale_min=-10., scale_max=200.)
assert molrep.get_scaleminmax(m, r) == pytest.approx((-10., 200.))
with pytest.raises(ValueError):
molrep.set_scaleminmax(m+1, 0, 0, 12)
with pytest.raises(ValueError):
molrep.set_scaleminmax(m, r+1, 12, 13)
with pytest.raises(RuntimeError):
molrep.set_scaleminmax(m, r, scale_min=100, scale_max=0)
# Test reset
molrep.reset_scaleminmax(molid=m, rep=r)
assert molrep.get_scaleminmax(m, r) == pytest.approx((-10., 200.))
with pytest.raises(ValueError):
molrep.reset_scaleminmax(m+1, 0)
with pytest.raises(ValueError):
molrep.reset_scaleminmax(m, r+1)
# Test changing with modrep
assert molrep.modrep(m, r, scaleminmax=(2.0, 3.0))
assert molrep.get_scaleminmax(m, r) == pytest.approx((2.0, 3.0))
assert molrep.modrep(m, r, scaleminmax=[-10., -5.])
assert molrep.get_scaleminmax(m, r) == pytest.approx((-10., -5.))
molecule.delete(m)
def test_basic_getset(file_3frames):
m = molecule.load("pdb", file_3frames)
sel = atomsel(selection="protein", molid=m, frame=1)
assert sel.frame == 1
assert sel.molid == m
assert len(sel.bonds) == 10
assert str(sel) == "protein"
assert repr(sel) == "atomsel('protein', molid=%d, frame=%d)" % (m, 1)
# Default selections
molecule.set_frame(m, 2)
molecule.set_top(m)
sel = atomsel()
assert repr(sel) == "atomsel('all', molid=%d, frame=-1)" % m
# Set something without a setter
with pytest.raises(AttributeError):
sel.molid = m+1
# Invalid selection text
with pytest.raises(ValueError):
atomsel(selection="cannot be parsed")
molecule.delete(m)
# Selection on deleted molecule
with pytest.raises(ValueError):
assert sel.frame == 1
with pytest.raises(ValueError):
assert sel.molid == m
with pytest.raises(ValueError):
assert sel.bonds == []
def test_animate(file_3frames):
m = molecule.load("pdb", file_3frames)
assert molecule.numframes(m) == 3
molecule.set_frame(m, 0)
with pytest.raises(ValueError):
animate.activate(-3000, True)
animate.activate(molid=m, active=False)
assert not animate.is_active(m)
animate.activate(m, True)
assert animate.is_active(m)
animate.goto(0)
display.update()
assert molecule.get_frame(m) == 0
animate.goto(1)
display.update()
assert molecule.get_frame(m) == 1
animate.forward()
animate.reverse()
animate.next()
animate.prev()
animate.pause()
molecule.delete(m)
def test_special_load(file_3nob, file_3frames, file_psf):
# Graphics type is special
m = molecule.load("graphics", "")
assert molecule.numatoms(m) == 0
molecule.delete(m)
# Coordinates and data
m = molecule.load(struct_type="psf",
coord_type="pdb",
struct_file=file_psf,
coord_file=file_3frames)
assert molecule.numframes(m) == 3
# Incorrect numbers of arguments
with pytest.raises(ValueError):
molecule.load("psf", file_psf, coord_type="pdb")
with pytest.raises(ValueError):
molecule.load("psf", file_psf, coord_file=file_3frames)
# Nonexistent files
with pytest.raises(RuntimeError):
molecule.load("psf", "nonexistent_file")
with pytest.raises(RuntimeError):
molecule.load("psf", file_psf, "pdb", "nonexistent_file")
# Wrong number of atoms in coordinate data
with pytest.raises(RuntimeError):
x = molecule.load("mae", file_3nob, "pdb", file_3frames)
print(molecule.get_filenames(x))
molecule.delete(m)
def test_mol_center(file_3nob):
m = molecule.load("mae", file_3nob)
init_center = trans.get_center(m)
trans.set_center(m, center=(1., 1., 1.))
assert trans.get_center(m) == pytest.approx((1., 1., 1.))
trans.set_center(m, center=[0., 0., 0.])
assert trans.get_center(m) == pytest.approx((0., 0., 0.))
with pytest.raises(ValueError):
trans.get_center(molid=m + 1)
with pytest.raises(ValueError):
trans.set_center(m + 1, (3., 2., 1.))
with pytest.raises(TypeError):
trans.set_center(molid=m, center=(1.))
trans.resetview(m)
assert trans.get_center(m) == pytest.approx(init_center)
with pytest.raises(ValueError):
trans.resetview(molid=m + 1)
molecule.delete(m)
def test_mol_rotate(file_3nob):
m = molecule.load("mae", file_3nob)
r = trans.get_rotation(molid=m)
assert r == pytest.approx((1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0))
newrot = [x + 2. for x in r]
trans.set_rotation(m, newrot)
assert trans.get_rotation(molid=m) == pytest.approx(newrot)
with pytest.raises(ValueError):
trans.get_rotation(m + 1)
with pytest.raises(ValueError):
trans.set_rotation(m + 1, [0.] * 16)
with pytest.raises(TypeError):
trans.set_rotation(molid=m, matrix=12)
with pytest.raises(TypeError):
trans.set_rotation(m, [True] * 16)
trans.resetview(m)
assert trans.get_rotation(m) == r
molecule.delete(m)
def test_modrep(file_3nob):
m = molecule.load("mae", file_3nob)
r = molrep.addrep(style="Licorice",
color="ResID",
selection="noh",
material="AOEdgy",
molid=m)
with pytest.raises(ValueError):
molrep.modrep(m + 1, 0)
with pytest.raises(ValueError):
molrep.modrep(m, r + 1)
assert molrep.get_style(m, r) == "Licorice"
assert molrep.modrep(m, r, style="Lines")
assert molrep.get_style(m, r) == "Lines"
assert not molrep.modrep(m, r, style="Invalid")
assert molrep.get_style(m, r) == "Lines"
assert molrep.modrep(m,
r,
color="ColorID 0",
selection="resname TIP3",
material="Transparent")
assert molrep.get_selection(m, r) == "resname TIP3"
assert molrep.get_material(m, r) == "Transparent"
assert molrep.get_color(m, r) == "ColorID 0"
molecule.delete(m)
def test_basic_getset(file_3frames):
m = molecule.load("pdb", file_3frames)
sel = atomsel(selection="protein", molid=m, frame=1)
assert sel.frame == 1
assert sel.molid == m
assert len(sel.bonds) == 10
assert str(sel) == "protein"
assert repr(sel) == "atomsel('protein', molid=%d, frame=%d)" % (m, 1)
# Default selections
molecule.set_frame(m, 2)
molecule.set_top(m)
sel = atomsel()
assert repr(sel) == "atomsel('all', molid=%d, frame=-1)" % m
# Set something without a setter
with pytest.raises(AttributeError):
sel.molid = m + 1
# Invalid selection text
with pytest.raises(ValueError):
atomsel(selection="cannot be parsed")
molecule.delete(m)
# Selection on deleted molecule
with pytest.raises(ValueError):
assert sel.frame == 1
with pytest.raises(ValueError):
assert sel.molid == m
with pytest.raises(ValueError):
assert sel.bonds == []
def test_autoupdates(file_3nob):
m = molecule.load("mae", file_3nob)
r = molrep.addrep(color="User", selection="all", molid=m)
# Color update
assert not molrep.get_colorupdate(m, r)
with pytest.raises(ValueError):
molrep.get_colorupdate(m + 1, 0)
with pytest.raises(ValueError):
molrep.get_colorupdate(m, r + 1)
molrep.set_colorupdate(m, rep=r, autoupdate=True)
assert molrep.get_colorupdate(rep=r, molid=m)
with pytest.raises(ValueError):
molrep.set_colorupdate(m + 1, 0, False)
with pytest.raises(ValueError):
molrep.set_colorupdate(m, r + 1, False)
# Selection update
assert not molrep.get_autoupdate(molid=m, rep=r)
with pytest.raises(ValueError):
molrep.get_autoupdate(m + 1, 0)
with pytest.raises(ValueError):
molrep.get_autoupdate(m, r + 1)
molrep.set_autoupdate(m, rep=r, autoupdate=True)
assert molrep.get_autoupdate(rep=r, molid=m)
with pytest.raises(ValueError):
molrep.set_autoupdate(m + 1, 0, False)
with pytest.raises(ValueError):
molrep.set_autoupdate(m, r + 1, False)
molecule.delete(m)
def test_colorscale(file_3nob):
m = molecule.load("mae", file_3nob)
r = molrep.addrep(color="User2", selection="lipid", molid=m)
assert molrep.get_scaleminmax(m, r) == pytest.approx((0., 0.))
with pytest.raises(ValueError):
molrep.get_scaleminmax(m + 1, 0)
with pytest.raises(ValueError):
molrep.get_scaleminmax(m, r + 1)
molrep.set_scaleminmax(molid=m, rep=r, scale_min=-10., scale_max=200.)
assert molrep.get_scaleminmax(m, r) == pytest.approx((-10., 200.))
with pytest.raises(ValueError):
molrep.set_scaleminmax(m + 1, 0, 0, 12)
with pytest.raises(ValueError):
molrep.set_scaleminmax(m, r + 1, 12, 13)
with pytest.raises(RuntimeError):
molrep.set_scaleminmax(m, r, scale_min=100, scale_max=0)
# Test reset
molrep.reset_scaleminmax(molid=m, rep=r)
assert molrep.get_scaleminmax(m, r) == pytest.approx((-10., 200.))
with pytest.raises(ValueError):
molrep.reset_scaleminmax(m + 1, 0)
with pytest.raises(ValueError):
molrep.reset_scaleminmax(m, r + 1)
# Test changing with modrep
assert molrep.modrep(m, r, scaleminmax=(2.0, 3.0))
assert molrep.get_scaleminmax(m, r) == pytest.approx((2.0, 3.0))
assert molrep.modrep(m, r, scaleminmax=[-10., -5.])
assert molrep.get_scaleminmax(m, r) == pytest.approx((-10., -5.))
molecule.delete(m)
def test_autoupdates(file_3nob):
m = molecule.load("mae", file_3nob)
r = molrep.addrep(color="User", selection="all", molid=m)
# Color update
assert not molrep.get_colorupdate(m, r)
with pytest.raises(ValueError):
molrep.get_colorupdate(m+1, 0)
with pytest.raises(ValueError):
molrep.get_colorupdate(m, r+1)
molrep.set_colorupdate(m, rep=r, autoupdate=True)
assert molrep.get_colorupdate(rep=r, molid=m)
with pytest.raises(ValueError):
molrep.set_colorupdate(m+1, 0, False)
with pytest.raises(ValueError):
molrep.set_colorupdate(m, r+1, False)
# Selection update
assert not molrep.get_autoupdate(molid=m, rep=r)
with pytest.raises(ValueError):
molrep.get_autoupdate(m+1, 0)
with pytest.raises(ValueError):
molrep.get_autoupdate(m, r+1)
molrep.set_autoupdate(m, rep=r, autoupdate=True)
assert molrep.get_autoupdate(rep=r, molid=m)
with pytest.raises(ValueError):
molrep.set_autoupdate(m+1, 0, False)
with pytest.raises(ValueError):
molrep.set_autoupdate(m, r+1, False)
molecule.delete(m)
def test_animate(file_3frames):
m = molecule.load("pdb", file_3frames)
assert molecule.numframes(m) == 3
molecule.set_frame(m, 0)
with pytest.raises(ValueError):
animate.activate(-3000, True)
animate.activate(molid=m, active=False)
assert not animate.is_active(m)
animate.activate(m, True)
assert animate.is_active(m)
animate.goto(0)
display.update()
assert molecule.get_frame(m) == 0
animate.goto(1)
display.update()
assert molecule.get_frame(m) == 1
animate.forward()
animate.reverse()
animate.next()
animate.prev()
animate.pause()
molecule.delete(m)
def test_atomsel_update(file_3frames):
m = molecule.load("pdb", file_3frames)
atomsel("resid 1", m, frame=2).user = 1.0
sel = atomsel("user 1.0", molid=m, frame=-1)
assert sel.frame == -1
assert sel.index == list(range(10))
altersel = atomsel("index 9", m, frame=2)
altersel.user = 0.0
assert atomsel("index 8 9", m, frame=2).user == approx([1.0, 0.0])
assert atomsel("index 8 9", m, frame=0).user == approx([0.0, 0.0])
# Selection should only change if the frame is set to update
molecule.set_frame(m, 2)
assert sel.index == list(range(10))
sel.update()
assert sel.index == list(range(9))
# Now put it back to another frame
sel.frame = 0
assert sel.frame == 0
assert sel.index == list(range(9))
sel.update()
assert sel.index == []
molecule.delete(m)
def test_basic_load(file_3nob):
assert molecule.num() == 0
assert molecule.listall() == []
m = molecule.load("mae", file_3nob)
assert molecule.num() == 1
assert molecule.listall() == [m]
assert molecule.exists(m)
assert not molecule.exists(m+1)
assert molecule.name(m) == "3nob.mae"
with pytest.raises(ValueError):
molecule.name(m+1)
molecule.rename(m, "newname")
assert molecule.name(m) == "newname"
with pytest.raises(ValueError):
molecule.rename(name="wrong id", molid=m+1)
assert molecule.numatoms(molid=m) == 2481
with pytest.raises(ValueError):
molecule.numatoms(m+1)
molecule.delete(m)
with pytest.raises(ValueError):
molecule.delete(m)
def test_measure(file_3nob):
m1 = molecule.load("mae", file_3nob)
m2 = molecule.load("mae", file_3nob)
with pytest.warns(SyntaxWarning):
assert measure.bond(0, 0, m1, m2, frame=0,
first=0) == [pytest.approx(0.)]
assert measure.bond(atom1=0, atom2=10,
molid=m1)[0] == pytest.approx(4.97422456)
assert measure.bond(atom1=0, atom2=10)[0] == pytest.approx(4.97422456)
# One atom listed multiple times
with pytest.raises(RuntimeError):
measure.angle(0, 0, 0)
with pytest.warns(SyntaxWarning):
assert measure.angle(0, 1, 2, frame=0,
last=1) == [pytest.approx(119.7387237548)]
assert measure.angle(atom1=0,
atom2=1,
atom3=0,
molid=m1,
molid2=m2,
molid3=m1)[0] == pytest.approx(0.0)
with pytest.raises(RuntimeError):
measure.dihedral(0, 0, 0, 0)
molecule.delete(m1)
molecule.delete(m2)
def test_mol_time(file_3frames):
m = molecule.load("pdb", file_3frames)
assert molecule.numframes(m) == 3
assert molecule.get_physical_time(molid=m, frame=0) == pytest.approx(0.0)
with pytest.raises(ValueError):
molecule.get_physical_time(m + 1)
# Test all valid combinations of default keyword arguments
molecule.set_frame(m, 0)
molecule.set_physical_time(molid=m, frame=2, time=20.0)
molecule.set_physical_time(m, 10.0, frame=1)
molecule.set_physical_time(m, 3.0)
assert molecule.get_physical_time(m) == pytest.approx(3.0)
molecule.set_frame(m, frame=2)
assert molecule.get_physical_time(molid=m) == pytest.approx(20.0)
assert molecule.get_physical_time(m, frame=1) == pytest.approx(10.0)
with pytest.raises(ValueError):
molecule.set_physical_time(molid=m + 1, time=20.0)
with pytest.raises(ValueError):
molecule.set_physical_time(m, time=30.0, frame=3000)
molecule.delete(m)
def check_result(format, outdir, solvent=True, lipid=True):
if format == "prmtop":
m2 = molecule.load("parm7", os.path.join(outdir, "test.prmtop"),
"rst7", os.path.join(outdir, "test.inpcrd"))
elif format == "psf":
m2 = molecule.load("psf", os.path.join(outdir, "test.psf"), "pdb",
os.path.join(outdir, "test.pdb"))
# Check by reading .top file, as VMD won't parse it and .gro doesn't
# have bond information
elif format == "gro":
return check_gro(os.path.join(outdir, "test.top"), lipid=lipid)
elif format == "lammps":
return check_lammps(os.path.join(outdir, "test.dat"))
molecule.set_top(m2)
assert len(set(atomsel("protein").resid)) == 282
assert len(set(atomsel("resname ACE NMA NME").resid)) == 4
if solvent:
assert len(atomsel("water")) == 32106
assert len(atomsel("same fragment as lipid")) == 12194
# Check for the corrrect number of alprenolols
assert len(atomsel("resname ALP")) == 420
assert len(set(atomsel("resname ALP").resid)) == 10
assert any(_ in set(atomsel("resname ALP").name) for _ in ["O09", "OX"])
assert "O1" not in set(atomsel("resname ALP").name)
# Check coordinates are unique (not zero)
assert len(atomsel("resname ALP")) == 420
assert 0.0 not in atomsel("resname ALP").x
molecule.delete(m2)
def write(self):
"""
Writes the final built system.
Args:
filename (str): Name of file
"""
fileutils.check_write_ok(self.opts.get('output_filename'),
self.out_fmt,
overwrite=self.opts.get('overwrite'))
final_id = self._build()
print("Writing system to %s with %d atoms comprising:\n"
" %d lipid molecules\n"
" %d water molecules\n" %
(self.opts.get('output_filename'),
molutils.num_atoms_remaining(molid=final_id),
molutils.num_lipids_remaining(final_id,
self.opts.get('lipid_sel')),
molutils.num_waters_remaining(molid=final_id)))
fileutils.write_final_system(
out_fmt=self.out_fmt,
out_name=self.opts.get('output_filename'),
molid=final_id,
tmp_dir=self.tmp_dir,
forcefield=self.opts.get('forcefield'),
extra_topos=self.opts.get('extra_topos'),
extra_params=self.opts.get('extra_params'),
extra_streams=self.opts.get('extra_streams'),
hmassrepartition=self.opts.get('hmassrepartition'),
verbose=self.opts.get('debug_verbose'))
molecule.delete(final_id)
def test_multiligand_building(tmpdir):
"""
Solvates and membranes a system with multiple ligands """
from dabble import DabbleBuilder
p = str(tmpdir)
# Build the system
b = DabbleBuilder(solute_filename=os.path.join(dir, "B2AR_10ALPs.mae"),
output_filename=os.path.join(p, "test.mae"),
xy_buf=10.,
wat_buffer=10.,
overwrite=True,
tmp_dir=p)
b.write()
# Load the built system
m2 = molecule.load("mae", os.path.join(p, "test.mae"))
molecule.set_top(m2)
# Check the system dimensions are correct
solsel = atomsel("protein or resname ACE NMA ALP")
prot_x = max(solsel.x) - min(solsel.x)
prot_y = max(solsel.y) - min(solsel.y)
prot_z = max(solsel.z) - min(solsel.z)
assert abs(molecule.get_periodic(m2)["a"] - prot_x - 20.0) < 0.1
assert abs(molecule.get_periodic(m2)["b"] - prot_y - 20.0) < 0.1
assert abs(molecule.get_periodic(m2)["c"] - prot_z - 20.0) < 0.1
# Check all the alprenolols are there
assert len(set(atomsel("resname ALP").resid)) == 10
assert len(atomsel("resname ALP")) == 420
molecule.delete(m2)
def test_vmdnumpy(file_3frames):
m = molecule.load("pdb", file_3frames)
# Timestep and positions are equivalent
assert arr_equals(vmdnumpy.timestep(m, 0), vmdnumpy.positions(m, 0))
with pytest.raises(ValueError):
vmdnumpy.timestep(molid=m+1)
x = vmdnumpy.atomselect(selection="index 0")
assert x.shape == (16,)
assert x[0] == 1
x[0] = 0
assert arr_equals(x, numpy.zeros(x.shape))
with pytest.raises(ValueError):
vmdnumpy.atomselect("garbage atomselection", molid=m, frame=0)
assert vmdnumpy.velocities(molid=m, frame=0) is None
# Invalid frame
with pytest.raises(ValueError):
assert vmdnumpy.velocities(molid=m, frame=10) is None
# Test on deleted molecule
molecule.delete(m)
with pytest.raises(ValueError):
vmdnumpy.atomselect("protein")
def test_show_fix(file_3nob):
m = molecule.load("mae", file_3nob)
trans.show(molid=m, shown=True)
assert trans.is_shown(m)
with pytest.raises(ValueError):
trans.show(m + 1, True)
with pytest.raises(ValueError):
trans.is_shown(m + 1)
trans.show(m, False)
assert not trans.is_shown(molid=m)
trans.fix(m, fixed=False)
assert not trans.is_fixed(m)
trans.fix(m, True)
assert trans.is_fixed(m)
with pytest.raises(ValueError):
trans.fix(m + 1, True)
with pytest.raises(ValueError):
trans.is_fixed(m + 1)
molecule.delete(m)
def test_atomsel_fit_move(file_3nob):
m1 = molecule.load("mae", file_3nob)
m2 = molecule.load("mae", file_3nob)
sel1 = atomsel("protein", m1)
sel2 = atomsel("protein", m2)
# Move one selection over
assert sel1.x[0] == approx(sel2.x[0])
sel1.moveby((1.0, 0.0, 0.0))
assert sel1.x[0] == approx(sel2.x[0] + 1.0)
sel1.moveby([1.0, 0.0, 0.0])
assert sel1.x[0] == approx(sel2.x[0] + 2.0)
assert sel1.y[0] == approx(sel2.y[0])
assert sel1.z[0] == approx(sel2.z[0])
# Fit, no weights
fit1 = sel1.fit(sel2)
assert fit1[0] == approx(1.0, abs=1e-5)
# Fit, with weights
fit0 = sel1.fit(selection=sel2, weight=[0.0] + [1.0]*(len(sel2)-1))
assert fit0 == approx((1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
1.0, 0.0, -2.0, 0.0, 0.0, 1.0))
# Test selection invertible
fit2 = np.reshape(sel2.fit(sel1), (4,4))
assert np.linalg.inv(fit2) == approx(np.reshape(fit1, (4,4)))
# Move
sel1.move(fit1)
assert sel1.x[0] == sel2.x[0]
# Move with a numpy array - all zeros nans the array?
sel1.move(np.zeros((16,)))
assert sel1.y == approx(sel1.x, nan_ok=True)
assert sel1.y != approx(sel1.x, nan_ok=False)
# Operations on empty selection
isel = atomsel("resname NOPE", m1)
with pytest.raises(ValueError):
isel.moveby((1., 2., 3.))
with pytest.raises(ValueError):
isel.move(fit1)
with pytest.raises(ValueError):
isel.fit(isel)
molecule.delete(m1)
with pytest.raises(ValueError):
sel1.fit(sel2)
molecule.delete(m2)
with pytest.raises(ValueError):
sel1.moveby((1,2,3))
with pytest.raises(ValueError):
sel2.move(fit1)
def test_atomsel_fit_move(file_3nob):
m1 = molecule.load("mae", file_3nob)
m2 = molecule.load("mae", file_3nob)
sel1 = atomsel("protein", m1)
sel2 = atomsel("protein", m2)
# Move one selection over
assert sel1.x[0] == approx(sel2.x[0])
sel1.moveby((1.0, 0.0, 0.0))
assert sel1.x[0] == approx(sel2.x[0] + 1.0)
sel1.moveby([1.0, 0.0, 0.0])
assert sel1.x[0] == approx(sel2.x[0] + 2.0)
assert sel1.y[0] == approx(sel2.y[0])
assert sel1.z[0] == approx(sel2.z[0])
# Fit, no weights
fit1 = sel1.fit(sel2)
assert fit1[0] == approx(1.0, abs=1e-5)
# Fit, with weights
fit0 = sel1.fit(selection=sel2, weight=[0.0] + [1.0] * (len(sel2) - 1))
assert fit0 == approx((1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
1.0, 0.0, -2.0, 0.0, 0.0, 1.0))
# Test selection invertible
fit2 = np.reshape(sel2.fit(sel1), (4, 4))
assert np.linalg.inv(fit2) == approx(np.reshape(fit1, (4, 4)))
# Move
sel1.move(fit1)
assert sel1.x[0] == sel2.x[0]
# Move with a numpy array - all zeros nans the array?
sel1.move(np.zeros((16, )))
assert sel1.y == approx(sel1.x, nan_ok=True)
assert sel1.y != approx(sel1.x, nan_ok=False)
# Operations on empty selection
isel = atomsel("resname NOPE", m1)
with pytest.raises(ValueError):
isel.moveby((1., 2., 3.))
with pytest.raises(ValueError):
isel.move(fit1)
with pytest.raises(ValueError):
isel.fit(isel)
molecule.delete(m1)
with pytest.raises(ValueError):
sel1.fit(sel2)
molecule.delete(m2)
with pytest.raises(ValueError):
sel1.moveby((1, 2, 3))
with pytest.raises(ValueError):
sel2.move(fit1)
def test_atomsel_rmsd(file_3frames):
m1 = molecule.load("pdb", file_3frames)
m2 = molecule.load("pdb", file_3frames)
atomsel("resname ALA", m1).moveby((4.0, 0.0, 0.0))
atomsel("resname NMA", m1).moveby((0.0, 0.0, -4.0))
sel1 = atomsel("resname ALA", m1)
sel2 = atomsel("resname ALA", m2)
assert sel1.rmsd(sel2) == approx(4.0)
# Weights cannot be all zero
with pytest.raises(ValueError):
sel1.rmsd(sel2, [0.0]*len(sel1))
# RMSDq - rotation invariant
sel2.move(np.sin(60) * np.reshape(np.identity(4), (16,)))
assert sel1.rmsdQCP(sel2) == approx(0.0, abs=1e-5)
weights = [2.0]*(len(sel1)-1) + [1.0]
assert sel1.rmsd(selection=sel2, weight=weights) == approx(4.0)
assert sel1.rmsdQCP(sel2, weights) == approx(0.0, abs=1e-5)
# RMSD per residue
perres = atomsel("all", m1).rmsdperresidue(atomsel(molid=m2))
assert len(perres) == 2
assert perres[0] == approx(sel1.rmsd(sel2))
assert perres[1] == approx(4.0)
wpr = atomsel(molid=m1).rmsdperresidue(atomsel(molid=m2),
weight=[1.0]*10 + [0.0]*6)
assert wpr[0] == approx(sel1.rmsd(sel2))
assert np.isnan(wpr[1])
# Wrong number atoms or weights
# Same code should catch this for rmsdQCP too
with pytest.raises(ValueError):
sel1.rmsd(atomsel(molid=m2))
with pytest.raises(TypeError):
sel1.rmsd(selection=sel2, weight=0.0)
with pytest.raises(ValueError):
sel1.rmsd(selection=sel2, weight="hello")
with pytest.raises(ValueError):
sel1.rmsd(selection=sel2, weight=[1.0, 2.0])
with pytest.raises(ValueError):
sel1.rmsd(selection=sel2, weight=[True, True])
# Operations on deleted molecule
# Same code should catch this for rmsdQCP etc
molecule.delete(m1)
with pytest.raises(ValueError):
sel2.rmsd(sel1)
molecule.delete(m2)
with pytest.raises(ValueError):
sel1.rmsd(sel2)
def test_mutation(tmpdir):
"""
Tests mutation of L2A in chain 0. Also as a result tests guessing
coordinates
"""
from psfgen import PsfGen
p = str(tmpdir.mkdir("mutation"))
os.chdir(dir)
gen = PsfGen(output=os.devnull)
gen.read_topology("top_all36_caps.rtf")
gen.read_topology("top_all36_prot.rtf")
gen.add_segment(segid="P0",
pdbfile="psf_protein_P0.pdb",
mutate=[("2", "ALA")])
gen.read_coords(segid="P0", filename="psf_protein_P0.pdb")
gen.patch(patchname="DISU", targets=[("P0", "10"), ("P0", "15")])
# Guess coordinates for ALA mutation
gen.guess_coords()
# Set one specific coordinate
gen.set_position(segid="P0",
resid="2",
atomname="HB1",
position=(1.0, 2.0, 3.0))
# Regenerate
gen.regenerate_angles()
gen.regenerate_dihedrals()
# Write
os.chdir(p)
gen.write_psf(filename="output.psf")
gen.write_pdb(filename="output.pdb")
# Check results with vmd-python
m = molecule.load("psf", "output.psf", "pdb", "output.pdb")
assert len(set(atomsel("protein").fragment)) == 1
assert len(set(atomsel("resname ACE NMA NME").residue)) == 2
# Test mutation happened and resid 2 is ALA not LEU
assert set(atomsel("resid 2").resname) == set(["ALA"])
# Check coordinate guessing happened and HB3 has a nonzero position
assert atomsel("resid 2 and name HB3").x != [0.0]
assert atomsel("resid 2 and name HB3").y != [0.0]
assert atomsel("resid 2 and name HB3").z != [0.0]
# Check manual coordinate setting happened
assert atomsel("resid 2 and name HB1").x == [1.0]
assert atomsel("resid 2 and name HB1").y == [2.0]
assert atomsel("resid 2 and name HB1").z == [3.0]
molecule.delete(m)
def test_atomsel_rmsd(file_3frames):
m1 = molecule.load("pdb", file_3frames)
m2 = molecule.load("pdb", file_3frames)
atomsel("resname ALA", m1).moveby((4.0, 0.0, 0.0))
atomsel("resname NMA", m1).moveby((0.0, 0.0, -4.0))
sel1 = atomsel("resname ALA", m1)
sel2 = atomsel("resname ALA", m2)
assert sel1.rmsd(sel2) == approx(4.0)
# Weights cannot be all zero
with pytest.raises(ValueError):
sel1.rmsd(sel2, [0.0] * len(sel1))
# RMSDq - rotation invariant
sel2.move(np.sin(60) * np.reshape(np.identity(4), (16, )))
assert sel1.rmsdQCP(sel2) == approx(0.0, abs=1e-5)
weights = [2.0] * (len(sel1) - 1) + [1.0]
assert sel1.rmsd(selection=sel2, weight=weights) == approx(4.0)
assert sel1.rmsdQCP(sel2, weights) == approx(0.0, abs=1e-5)
# RMSD per residue
perres = atomsel("all", m1).rmsdperresidue(atomsel(molid=m2))
assert len(perres) == 2
assert perres[0] == approx(sel1.rmsd(sel2))
assert perres[1] == approx(4.0)
wpr = atomsel(molid=m1).rmsdperresidue(atomsel(molid=m2),
weight=[1.0] * 10 + [0.0] * 6)
assert wpr[0] == approx(sel1.rmsd(sel2))
assert np.isnan(wpr[1])
# Wrong number atoms or weights
# Same code should catch this for rmsdQCP too
with pytest.raises(ValueError):
sel1.rmsd(atomsel(molid=m2))
with pytest.raises(TypeError):
sel1.rmsd(selection=sel2, weight=0.0)
with pytest.raises(ValueError):
sel1.rmsd(selection=sel2, weight="hello")
with pytest.raises(ValueError):
sel1.rmsd(selection=sel2, weight=[1.0, 2.0])
with pytest.raises(ValueError):
sel1.rmsd(selection=sel2, weight=[True, True])
# Operations on deleted molecule
# Same code should catch this for rmsdQCP etc
molecule.delete(m1)
with pytest.raises(ValueError):
sel2.rmsd(sel1)
molecule.delete(m2)
with pytest.raises(ValueError):
sel1.rmsd(sel2)
def test_create():
m = molecule.new(name="test", natoms=3000)
assert molecule.name(m) == "test"
assert molecule.numatoms(m) == 3000
with pytest.raises(ValueError):
m = molecule.new("test2", -2000)
molecule.delete(m)
def test_create():
m = molecule.new(name="test", natoms=3000)
assert molecule.name(m) == "test"
assert molecule.numatoms(m) == 3000
with pytest.raises(ValueError):
m = molecule.new("test2", -2000)
molecule.delete(m)
def generate_initial_ensemble(self):
"""
Generates an initial ensemble of frames where one ligand
is picked based on its hub score. This method alone does
the exact same thing as the previous code, but will be
extended to alter the positions of the other ligands
to correspond to other resampled clusters.
"""
# Choose which clusters to resample
if self.criteria == "hub_scores":
selected = list(
self.msm.inverse_transform(self.scores.argsort())[0])
elif self.criteria == "populations":
selected = list(
self.msm.inverse_transform(self.msm.populations_.argsort())[0])
elif self.criteria == "counts":
selected = self.counts # From cluster labels, so no need for transform
# If enforcing sample region, this will be non-None
selstr = self.config.get("model", "sampleregion")
# Go through all of our resamplers until the correct number
# have been done. Use cluster list as a refilling queue.
molids = []
while len(molids) != self.nreps:
# Pick a cluster from the cluster queue
clust = selected.pop(0)
selected.append(clust)
# Generate a frame with this cluster and check resampled ligand
# is in the restricted selection area, if present
mid = -1
failures = 0
while mid == -1 and failures <= 3:
mid = self.pick_random_frame(clust)
if not self._validate_frame(mid, selstr):
print(" Attempt fail for cluster: %d" % clust)
failures += 1
molecule.delete(mid)
mid = -1
# If this cluster didn't work, continue to the next one
if mid == -1:
print(" Failed to select cluster: %d" % clust)
continue
# Otherwise, add it to our list of sampled clusters
molids.append(mid)
# Save and start adding job for this
self.save_initial_molecule(molid=mid,
sampled=clust,
repindex=len(molids))
def test_ends(tmpdir):
"""
Tests adding patches to the beginning and end, as well as adding
residues in the segment
"""
from psfgen import PsfGen
p = str(tmpdir.mkdir("mutation"))
os.chdir(dir)
gen = PsfGen(output=os.devnull)
gen.read_topology("top_all36_prot.rtf")
# Add neutral N-terminus
# Add an alanine then a protonated glutamate at the C-terminus.
gen.add_segment(segid="P",
pdbfile="protein_nocaps.pdb",
first="NTER",
last="GLUP",
residues=[("25", "ALA"), ("26", "GLU")])
# Set coordinates and regenerate angles and dihedrals
gen.read_coords(segid="P", filename="protein_nocaps.pdb")
gen.guess_coords()
# Check internal state
assert gen.get_resids("P") == [str(_) for _ in range(2, 27)]
assert gen.get_resname(segid="P", resid=25) == "ALA"
assert gen.get_patches(list_defaults=True) == [('GLUP', 'P', '26'),
('NTER', 'P', '2')]
assert gen.get_first(segid="P") == "NTER"
assert gen.get_last(segid="P") == "GLUP"
# Output
os.chdir(p)
gen.write_psf(filename="output.psf")
gen.write_pdb(filename="output.pdb")
# Check all resids are present and that 2 extra ones were added
m = molecule.load("psf", "output.psf", "pdb", "output.pdb")
assert list(set(atomsel("all").resid)) == list(range(2, 27))
assert len(atomsel("all")) == 382
assert set(atomsel("resid 25").resname) == set(["ALA"])
# Check patches were applied correctly
assert "HT1" in atomsel("resid 2").name
assert "HN" not in atomsel("resid 2").name
assert "HE2" in atomsel("resid 26").name
# Check all coordinates are set
assert 0.0 not in atomsel("all").x
assert 0.0 not in atomsel("all").y
assert 0.0 not in atomsel("all").z
molecule.delete(m)
def test_atomsel_minmax_center(file_3frames):
m = molecule.load("pdb", file_3frames)
sel = atomsel(selection="protein", molid=m, frame=1)
alasel = atomsel("resname ALA", molid=m)
# Minmax without radii
assert sel.minmax() == (approx((2.497, 0.724, -0.890)),
approx((6.009, 4.623, 2.131)))
# Minmax with radii
sel.radius = 10.0
assert sel.minmax(radii=True) == (approx((2.497-10., 0.724-10., -0.890-10.)),
approx((6.009+10., 4.623+10., 2.131+10.)))
assert sel.center(weight=None) == approx((4.040, 2.801, 0.492), rel=1e-3)
assert sel.center(weight=[0.]*9+ [1.]) == atomsel("index 9", m).center()
# Wrong number of weights
with pytest.raises(TypeError):
sel.center(weight=3.0)
with pytest.raises(ValueError):
sel.center([3.,2.])
sel = atomsel("all")
assert sel.centerperresidue() == [approx((4.040, 2.801, 0.492), rel=1e-3),
approx((7.260, 3.987, 0.000), rel=1e-3)]
assert sel.centerperresidue(weight=None)[0] == alasel.centerperresidue()[0]
# Centerperresidue with weights
with pytest.raises(TypeError):
sel.centerperresidue(weight=[True]*len(sel))
with pytest.raises(TypeError):
sel.centerperresidue(3)
with pytest.raises(ValueError):
sel.centerperresidue([1.0,2.0])
weights = [1.0]*10 + [0.0]*6
assert sel.centerperresidue(weight=weights)[0] == approx(alasel.center(),
rel=1e-3)
assert all([math.isnan(x) for x in sel.centerperresidue(weights)[1]])
molecule.delete(m)
# Operations on deleted molecule
with pytest.raises(ValueError):
sel.minmax(radii=False)
with pytest.raises(ValueError):
sel.centerrperres()
with pytest.raises(ValueError):
sel.center()
def test_atomsel_minmax_center(file_3frames):
m = molecule.load("pdb", file_3frames)
sel = atomsel(selection="protein", molid=m, frame=1)
alasel = atomsel("resname ALA", molid=m)
# Minmax without radii
assert sel.minmax() == (approx(
(2.497, 0.724, -0.890)), approx((6.009, 4.623, 2.131)))
# Minmax with radii
sel.radius = 10.0
assert sel.minmax(radii=True) == (approx(
(2.497 - 10., 0.724 - 10.,
-0.890 - 10.)), approx((6.009 + 10., 4.623 + 10., 2.131 + 10.)))
assert sel.center(weight=None) == approx((4.040, 2.801, 0.492), rel=1e-3)
assert sel.center(weight=[0.] * 9 + [1.]) == atomsel("index 9", m).center()
# Wrong number of weights
with pytest.raises(TypeError):
sel.center(weight=3.0)
with pytest.raises(ValueError):
sel.center([3., 2.])
sel = atomsel("all")
assert sel.centerperresidue() == [
approx((4.040, 2.801, 0.492), rel=1e-3),
approx((7.260, 3.987, 0.000), rel=1e-3)
]
assert sel.centerperresidue(weight=None)[0] == alasel.centerperresidue()[0]
# Centerperresidue with weights
with pytest.raises(TypeError):
sel.centerperresidue(weight=[True] * len(sel))
with pytest.raises(TypeError):
sel.centerperresidue(3)
with pytest.raises(ValueError):
sel.centerperresidue([1.0, 2.0])
weights = [1.0] * 10 + [0.0] * 6
assert sel.centerperresidue(weight=weights)[0] == approx(alasel.center(),
rel=1e-3)
assert all([math.isnan(x) for x in sel.centerperresidue(weights)[1]])
molecule.delete(m)
# Operations on deleted molecule
with pytest.raises(ValueError):
sel.minmax(radii=False)
with pytest.raises(ValueError):
sel.centerrperres()
with pytest.raises(ValueError):
sel.center()
def test_mol_attrs(file_3nob):
m1 = molecule.load("mae", file_3nob)
m2 = molecule.load("mae", file_3nob)
# Get/set top
assert molecule.get_top() == m2
molecule.set_top(molid=m1)
assert molecule.get_top() == m1
with pytest.raises(ValueError):
molecule.set_top(m2+1)
# Get/set visibility
molecule.set_visible(m1, visible=False)
assert molecule.get_visible() == False
assert molecule.get_visible(molid=m2) == True
with pytest.warns(DeprecationWarning):
molecule.set_visible(m1, state=True)
assert molecule.get_visible(molid=m1) == True
with pytest.raises(ValueError):
molecule.set_visible(m2+1, True)
with pytest.raises(TypeError):
molecule.set_visible(m2, 3)
with pytest.raises(ValueError):
molecule.get_visible(m2+1)
# Get/set periodic
assert molecule.get_periodic(m2) == {'a': 1.0, 'alpha': 90.0, 'b': 1.0,
'beta': 90.0, 'c': 1.0, 'gamma':
90.0}
with pytest.raises(ValueError):
molecule.get_periodic(molid=m1, frame=3000)
with pytest.raises(ValueError):
molecule.set_periodic(molid=m2+1, a=2.0)
with pytest.raises(ValueError):
molecule.set_periodic(m1, frame=3000, a=20.0)
molecule.set_periodic(m2, frame=0, a=90.0, b=90.0, c=90.0,
alpha=90.0, beta=90.0, gamma=90.0)
assert list(molecule.get_periodic(m2, frame=0).values()) == [pytest.approx(90.0)]*6
assert set(molecule.get_periodic(m1, frame=0).values()) != [pytest.approx(90.0)]*6
molecule.set_periodic(c=20.0)
assert molecule.get_periodic()["c"] == pytest.approx(20.0)
molecule.delete(m1)
molecule.delete(m2)
def test_multiple_frames(file_3frames):
m = molecule.load("pdb", file_3frames)
assert measure.bond(0, 1) == [pytest.approx(1.0093883275)]
with pytest.warns(SyntaxWarning):
assert measure.dihedral(0, 1, 2, 3, molid=m, frame=0,
first=1, last=2)[0] == pytest.approx(-70.578407)
x = measure.dihedral(0, 1, 2, 3, first=0, last=-1)
assert len(x) == 3
assert x == [pytest.approx(-70.578407)] * 3
molecule.delete(m)
def test_rep_attributes(file_3nob):
m = molecule.load("mae", file_3nob)
r = molrep.addrep(style="NewCartoon", color="ResID", selection="protein",
material="AOShiny", molid=m)
# Query name
assert molrep.get_repname(molid=m, rep=r) == "rep1"
with pytest.raises(ValueError):
molrep.get_repname(m+1, 0)
with pytest.raises(ValueError):
molrep.get_repname(m, r+1)
# Query ID
assert molrep.repindex(m, "rep1") == r
assert molrep.repindex(m, "nonexistent") is None
with pytest.raises(ValueError):
molrep.repindex(m+1, "wrong")
# Query style
assert molrep.get_style(m, r) == "NewCartoon"
with pytest.raises(ValueError):
molrep.get_style(m+1, 0)
with pytest.raises(ValueError):
molrep.get_style(m, r+1)
# Query selection
assert molrep.get_selection(m, r) == "protein"
with pytest.raises(ValueError):
molrep.get_selection(m+1, 0)
with pytest.raises(ValueError):
molrep.get_selection(m, r+1)
# Query color
assert molrep.get_color(m, r) == "ResID"
with pytest.raises(ValueError):
molrep.get_color(m+1, 0)
with pytest.raises(ValueError):
molrep.get_color(m, r+1)
# Query material
assert molrep.get_material(m, r) == "AOShiny"
with pytest.raises(ValueError):
molrep.get_material(m+1, 0)
with pytest.raises(ValueError):
molrep.get_material(m, r+1)
molecule.delete(m)
def test_colors():
mid = molecule.new(name="colortest")
graphics.color(mid, 1)
graphics.color(mid, "blue2")
with pytest.raises(ValueError):
graphics.color(mid, -1)
with pytest.raises(ValueError):
graphics.color(mid, "not a color")
with pytest.raises(TypeError):
graphics.color(mid, 32.0)
molecule.delete(mid)
def test_atomsel_rgyr(file_3frames):
m = molecule.load("pdb", file_3frames)
atomsel(molid=m, frame=0).moveby((4.0, 0.0, 0.0))
atomsel("all", m, 1).moveby((0.0, -4.0, 0.0))
sel = atomsel("resname ALA", m)
assert sel.rgyr() == approx(1.71880459)
# Empty selection
with pytest.raises(ValueError):
atomsel("resname NOPE", m).rgyr()
molecule.delete(m)
with pytest.raises(ValueError):
sel.rgyr()
def test_replace():
mid2 = molecule.load("graphics", "heya")
rc = graphics.point(mid2, (0,0,0))
assert graphics.info(mid2, rc) == "point {0.000000 0.000000 0.000000}"
rc2 = graphics.point(mid2, (1,1,1))
assert graphics.listall(mid2) == [rc, rc2]
graphics.replace(molid=mid2, graphic=rc)
assert graphics.listall(mid2) == [rc2]
rc3 = graphics.point(mid2, (2,2,2))
assert graphics.listall(mid2) == [rc3, rc2]
assert graphics.info(mid2, rc2) == "point {1.000000 1.000000 1.000000}"
molecule.delete(mid2)
