def run_tm_bond(self, *args):
color = self.tm_bond_color.get_color()
self.settings.tm_bond_color = tuple([c / 255. for c in color])
radius = self.tm_bond_radius.value()
self.settings.tm_bond_radius = radius
dashes = self.tm_bond_dashes.value()
self.settings.tm_bond_dashes = dashes
models = self.session.models.list(type=AtomicStructure)
for model in models:
rescol = ResidueCollection(model, bonds_matter=False)
try:
tm_list = rescol.find([
AnyTransitionMetal(), "Na", "K", "Rb", "Cs", "Fr", "Mg",
"Ca", "Sr", "Ba", "Ra"
])
for tm in tm_list:
for atom in rescol.atoms:
if atom is tm:
continue
if atom.is_connected(tm):
pbg = model.pseudobond_group(
model.PBG_METAL_COORDINATION,
create_type="normal")
pbg.new_pseudobond(tm.chix_atom, atom.chix_atom)
pbg.dashes = dashes
pbg.color = color
pbg.radius = radius
except LookupError:
pass
def libadd_ring(self):
"""add ring to library or open it in a new model"""
selection = self.session.seqcrow_ordered_selection_manager.selection
if not selection.single_structure:
raise RuntimeError("selected atoms must be on the same model")
rescol = ResidueCollection(selection[0].structure)
walk_atoms = rescol.find(
[AtomSpec(atom.atomspec) for atom in selection])
if len(walk_atoms) < 1:
raise RuntimeError("no walk direction could be determined")
ring_name = self.ring_name.text()
ring = Ring(rescol, name=ring_name, end=walk_atoms)
ring.comment = "E:%s" % ",".join(
[str(rescol.atoms.index(atom) + 1) for atom in walk_atoms])
if len(ring_name) == 0:
chimerax_ring = ResidueCollection(ring).get_chimera(self.session)
chimerax_ring.name = "ring preview"
self.session.models.add([chimerax_ring])
bild_obj = show_walk_highlight(ring, chimerax_ring,
[0.9, 0.4, 0.3, 0.9], self.session)
self.session.models.add(bild_obj, parent=chimerax_ring)
else:
check_aaronlib_dir()
filename = os.path.join(AARONLIB, "Rings", ring_name + ".xyz")
if os.path.exists(filename):
exists_warning = QMessageBox()
exists_warning.setIcon(QMessageBox.Warning)
exists_warning.setText(
"%s already exists.\nWould you like to overwrite?" %
filename)
exists_warning.setStandardButtons(QMessageBox.Yes
| QMessageBox.No)
rv = exists_warning.exec_()
if rv == QMessageBox.Yes:
ring.write(outfile=filename)
self.tool_window.status("%s added to ring library" %
ring_name)
else:
self.tool_window.status(
"%s has not been added to ring library" % ring_name)
else:
ring.write(outfile=filename)
self.tool_window.status("%s added to ring library" % ring_name)
def calc_cone(self, *args):
self.settings.cone_option = self.cone_option.currentText()
self.settings.radii = self.radii_option.currentText()
self.settings.display_radii = self.display_radii.checkState(
) == Qt.Checked
self.settings.display_cone = self.display_cone.checkState(
) == Qt.Checked
if self.cone_option.currentText() == "Tolman (Unsymmetrical)":
method = "tolman"
else:
method = self.cone_option.currentText()
radii = self.radii_option.currentText()
return_cones = self.display_cone.checkState() == Qt.Checked
display_radii = self.display_radii.checkState() == Qt.Checked
# self.table.setRowCount(0)
for center_atom in selected_atoms(self.session):
rescol = ResidueCollection(center_atom.structure)
at_center = rescol.find_exact(AtomSpec(center_atom.atomspec))[0]
if center_atom.structure in self.ligands:
comp = Component(
rescol.find([
AtomSpec(atom.atomspec)
for atom in self.ligands[center_atom.structure]
]),
to_center=rescol.find_exact(AtomSpec(
center_atom.atomspec)),
key_atoms=rescol.find(BondedTo(at_center)),
)
else:
comp = Component(
rescol.find(NotAny(at_center)),
to_center=rescol.find_exact(AtomSpec(
center_atom.atomspec)),
key_atoms=rescol.find(BondedTo(at_center)),
)
cone_angle = comp.cone_angle(
center=rescol.find(AtomSpec(center_atom.atomspec)),
method=method,
radii=radii,
return_cones=return_cones,
)
if return_cones:
cone_angle, cones = cone_angle
s = ".transparency 0.5\n"
for cone in cones:
apex, base, radius = cone
s += ".cone %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %.3f open\n" % (
*apex, *base, radius)
stream = BytesIO(bytes(s, "utf-8"))
bild_obj, status = read_bild(self.session, stream,
"Cone angle %s" % center_atom)
self.session.models.add(bild_obj, parent=center_atom.structure)
if display_radii:
s = ".note radii\n"
s += ".transparency 75\n"
color = None
for atom in comp.atoms:
chix_atom = atom.chix_atom
if radii.lower() == "umn":
r = VDW_RADII[chix_atom.element.name]
elif radii.lower() == "bondi":
r = BONDI_RADII[chix_atom.element.name]
if color is None or chix_atom.color != color:
color = chix_atom.color
rgb = [x / 255. for x in chix_atom.color]
rgb.pop(-1)
s += ".color %f %f %f\n" % tuple(rgb)
s += ".sphere %f %f %f %f\n" % (*chix_atom.coord, r)
stream = BytesIO(bytes(s, "utf-8"))
bild_obj, status = read_bild(self.session, stream,
"Cone angle radii")
self.session.models.add(bild_obj, parent=center_atom.structure)
row = self.table.rowCount()
self.table.insertRow(row)
name = QTableWidgetItem()
name.setData(Qt.DisplayRole, center_atom.structure.name)
self.table.setItem(row, 0, name)
center = QTableWidgetItem()
center.setData(Qt.DisplayRole, center_atom.atomspec)
self.table.setItem(row, 1, center)
ca = QTableWidgetItem()
ca.setData(Qt.DisplayRole, "%.2f" % cone_angle)
self.table.setItem(row, 2, ca)
self.table.resizeColumnToContents(0)
self.table.resizeColumnToContents(1)
self.table.resizeColumnToContents(2)
def fuseRing(session,
selection=None,
rings=None,
newName=None,
modify=True,
minimize=False,
available=False):
if available:
fuseRing_list(session)
return
if not selection:
selection = selected_atoms(session)
if not rings:
session.logger.error("missing required \"rings\" argument")
return
if newName is None:
pass
elif any(len(name.strip()) > 4 for name in newName):
raise RuntimeError("residue names must be 4 characters or less")
elif not all(name.isalnum() for name in newName):
raise RuntimeError("invalid residue name: %s" % newName)
elif len(rings) != len(newName):
raise RuntimeError(
"number of substituents is not the same as the number of new names"
)
if len(selection) < 2:
raise RuntimeWarning("two atoms must be selected per molecule")
models = {}
for atom in selection:
if atom.structure not in models:
models[atom.structure] = [atom]
else:
models[atom.structure].append(atom)
if len(models[atom.structure]) > 2:
raise RuntimeError("only two atoms can be selected on any model")
first_pass = True
new_structures = []
for i, ringname in enumerate(rings):
ringname = ringname.strip()
for model in models:
atom1 = models[model][0]
atom2 = models[model][1]
if modify and first_pass:
convert = minimal_ring_convert(model, *models[model])
if newName is not None:
for res in convert:
res.name = newName[i]
rescol = ResidueCollection(model, convert_residues=convert)
target = rescol.find(
[AtomSpec(atom1.atomspec),
AtomSpec(atom2.atomspec)])
elif modify and not first_pass:
raise RuntimeError("only the first model can be replaced")
else:
model_copy = model.copy()
a1 = model_copy.atoms[model.atoms.index(models[model][0])]
a2 = model_copy.atoms[model.atoms.index(models[model][1])]
convert = minimal_ring_convert(model_copy, a1, a2)
if newName is not None:
for res in convert:
res.name = newName[i]
rescol = ResidueCollection(model_copy,
convert_residues=convert)
target = rescol.find(
[AtomSpec(a1.atomspec),
AtomSpec(a2.atomspec)])
rescol.ring_substitute(target, ringname, minimize=minimize)
if modify:
rescol.update_chix(model)
else:
rescol.update_chix(model_copy)
new_structures.append(model_copy)
first_pass = False
if not modify:
session.models.add(new_structures)
def percent_vbur(
session,
selection,
radii="UMN",
radius=3.5,
scale=1.17,
method="Lebedev",
radialPoints=20,
angularPoints=1454,
minimumIterations=25,
onlyAtoms=None,
center=None,
useCentroid=True,
displaySphere=None,
pointSpacing=0.1,
intersectionScale=6,
palette="rainbow",
return_values=False,
steric_map=False,
useScene=False,
num_pts=100,
shape="circle",
labels="none",
reportComponent="total",
):
out = []
models = {
model: [
atom for atom in model.atoms
if onlyAtoms is not None and atom in onlyAtoms
]
for model in selection if isinstance(model, AtomicStructure)
}
s = "<pre>model\tcenter\t%Vbur\n"
for model in models:
if len(models[model]) == 0:
targets = None
else:
targets = [AtomSpec(atom.atomspec) for atom in models[model]]
if center is not None:
if isinstance(center, tuple):
mdl_center = np.array(center)
else:
mdl_center = [
AtomSpec(atom.atomspec) for atom in model.atoms
if atom in center
]
else:
mdl_center = []
rescol = ResidueCollection(model)
if useScene:
oop_vector = session.view.camera.get_position().axes()[2]
ip_vector = session.view.camera.get_position().axes()[1]
x_vec = session.view.camera.get_position().axes()[0]
basis = np.array([x_vec, ip_vector, oop_vector]).T
else:
oop_vector = None
ip_vector = None
basis = None
if len(mdl_center) == 0:
rescol.detect_components()
mdl_center = rescol.center
elif not isinstance(center, np.ndarray):
mdl_center = rescol.find([AtomSpec(c.atomspec) for c in center])
key_atoms = None
if not useCentroid and not isinstance(center, np.ndarray):
for c in mdl_center:
if targets is not None:
key_atoms = []
targets = rescol.find(targets)
for atom in targets:
if c in atom.connected or atom in c.connected:
key_atoms.append(atom)
else:
key_atoms = None
if (labels != "none"
or reportComponent != "total") and not useScene:
if not key_atoms:
session.logger.warning(
"bonds between center and coordinating atoms is required to"
" properly orient octants")
oop_vector = np.zeros(3)
for atom in key_atoms:
oop_vector += c.coords - atom.coords
if len(key_atoms) == 1:
ip_vector = perp_vector(oop_vector)
x_vec = np.cross(ip_vector, oop_vector)
else:
coords = [atom.coords for atom in key_atoms]
coords.append(c.coords)
coords = np.array(coords)
ip_vector = perp_vector(coords)
x_vec = np.cross(ip_vector, oop_vector)
x_vec /= np.linalg.norm(x_vec)
ip_vector = -np.cross(x_vec, oop_vector)
ip_vector /= np.linalg.norm(ip_vector)
basis = np.array([x_vec, ip_vector, oop_vector]).T
if steric_map:
x, y, z, min_alt, max_alt, basis, _ = rescol.steric_map(
center=c,
key_atoms=key_atoms,
radii=radii,
oop_vector=oop_vector,
ip_vector=ip_vector,
radius=radius,
return_basis=True,
num_pts=num_pts,
shape=shape,
)
vbur = rescol.percent_buried_volume(
targets=targets,
basis=basis,
center=c,
radius=radius,
radii=radii,
scale=scale,
method=method,
rpoints=int(radialPoints),
apoints=int(angularPoints),
min_iter=minimumIterations,
)
if steric_map:
out.append(
(model, c.atomspec, vbur, (x, y, z, min_alt, max_alt)))
else:
out.append((model, c.atomspec, vbur))
s += "%s\t%s\t" % (model.name, c.atomspec)
if hasattr(vbur, "__iter__"):
if reportComponent == "octants":
s += "%s\n" % ",".join(["%.1f%%" % v for v in vbur])
elif reportComponent == "quadrants":
s += "%s\n" % ",".join([
"%.1f%%" % v for v in [
vbur[0] + vbur[7],
vbur[1] + vbur[6],
vbur[2] + vbur[5],
vbur[3] + vbur[4],
]
])
else:
s += "%.1f%%\n" % sum(vbur)
else:
s += "%.1f%%\n" % vbur
if displaySphere is not None:
mdl = vbur_vis(
session,
rescol,
targets,
radii,
scale,
radius,
c,
pointSpacing,
intersectionScale,
displaySphere,
vbur,
labels,
basis=basis,
)
model.add(mdl)
atomspec = mdl[0].atomspec
center_coords = rescol.COM(c)
args = [
"color",
"radial",
atomspec,
"center",
",".join(["%.4f" % x for x in center_coords]),
"palette",
palette,
"range",
"0,%.2f" % radius,
"coordinateSystem",
model.atomspec,
";",
"transparency",
atomspec,
"30",
]
run(session, " ".join(args))
else:
if targets is not None:
key_atoms = []
targets = rescol.find(targets)
for atom in targets:
if any(c in atom.connected for c in mdl_center):
key_atoms.append(atom)
else:
key_atoms = None
if (labels != "none"
or reportComponent != "total") and not useScene:
if not key_atoms:
session.logger.warning(
"bonds between center and coordinating atoms is required to"
" properly orient octants")
oop_vector = np.zeros(3)
for atom in key_atoms:
if isinstance(mdl_center, np.ndarray):
oop_vector += mdl_center - atom.coords
else:
for c in mdl_center:
oop_vector += c.coords - atom.coords
if len(key_atoms) == 1:
ip_vector = perp_vector(oop_vector)
x_vec = np.cross(ip_vector, oop_vector)
else:
coords = [atom.coords for atom in key_atoms]
if isinstance(mdl_center, np.ndarray):
coords.append(mdl_center)
else:
coords.extend([c.coords for c in mdl_center])
coords = np.array(coords)
ip_vector = perp_vector(coords)
x_vec = np.cross(ip_vector, oop_vector)
x_vec /= np.linalg.norm(x_vec)
ip_vector = -np.cross(x_vec, oop_vector)
ip_vector /= np.linalg.norm(ip_vector)
basis = np.array([x_vec, ip_vector, oop_vector]).T
if steric_map:
x, y, z, min_alt, max_alt, basis, _ = rescol.steric_map(
center=mdl_center,
key_atoms=key_atoms,
radius=radius,
radii=radii,
oop_vector=oop_vector,
ip_vector=ip_vector,
return_basis=True,
num_pts=num_pts,
shape=shape,
)
vbur = rescol.percent_buried_volume(
targets=targets,
basis=basis,
center=mdl_center,
radius=radius,
radii=radii,
scale=scale,
method=method,
rpoints=int(radialPoints),
apoints=int(angularPoints),
min_iter=minimumIterations,
)
if steric_map:
if not isinstance(mdl_center, np.ndarray):
out.append(
(model, ",".join([c.atomspec for c in mdl_center]),
vbur, (x, y, z, min_alt, max_alt)))
else:
out.append(
(model, ",".join(["%.3f" % c for c in mdl_center]),
vbur, (x, y, z, min_alt, max_alt)))
else:
if not isinstance(mdl_center, np.ndarray):
s += "%s\t%s\t" % (model.name, ", ".join(
[c.atomspec for c in mdl_center]))
out.append(
(model, ", ".join([c.atomspec
for c in mdl_center]), vbur))
else:
s += "%s\t%s\t" % (model.name, ",".join(
["%.3f" % c for c in mdl_center]))
out.append(
(model, ",".join(["%.3f" % c
for c in mdl_center]), vbur))
if hasattr(vbur, "__iter__"):
if reportComponent == "octants":
s += "%s\n" % ",".join(["%.1f%%" % v for v in vbur])
elif reportComponent == "quadrants":
s += "%s\n" % ",".join([
"%.1f%%" % v for v in [
vbur[0] + vbur[7],
vbur[1] + vbur[6],
vbur[2] + vbur[5],
vbur[3] + vbur[4],
]
])
else:
s += "%.1f%%\n" % sum(vbur)
else:
s += "%.1f%%\n" % vbur
if displaySphere is not None:
mdl = vbur_vis(
session,
rescol,
targets,
radii,
scale,
radius,
mdl_center,
pointSpacing,
intersectionScale,
displaySphere,
vbur,
labels,
basis=basis,
)
model.add(mdl)
atomspec = mdl[0].atomspec
if not isinstance(mdl_center, np.ndarray):
center_coords = rescol.COM(mdl_center)
else:
center_coords = mdl_center
#XXX: the center will be wrong if the models are tiled
args = [
"color",
"radial",
atomspec,
"center",
",".join(["%.4f" % x for x in center_coords]),
"palette",
palette,
"range",
"0,%.2f" % radius,
"coordinateSystem",
model.atomspec,
";",
"transparency",
atomspec,
"30",
]
run(session, " ".join(args))
s = s.strip()
s += "</pre>"
if not return_values:
session.logger.info(s, is_html=True)
else:
return out
def ligandSterimol(session,
selection,
radii="UMN",
showVectors=True,
showRadii=True,
at_L=None,
bisect_L=False,
return_values=False):
models, center, key_atoms = avoidTargets(session.logger, selection)
radii = radii.lower()
targets = []
coord_atoms = []
datas = []
info = "<pre>model\tcoord. atoms\tB1\tB2\tB3\tB4\tB5\tL\n"
# if return_values:
# if len(models.keys()) > 1:
# raise RuntimeError("only one substituent may be selected")
# if any(len(models[key]) > 1 for key in models.keys()):
# raise RuntimeError("only one substituent may be selected")
for model in models:
rescol = ResidueCollection(model)
comp_atoms = [AtomSpec(at.atomspec) for at in models[model]]
key_atomspec = [AtomSpec(at.atomspec) for at in key_atoms[model]]
center_atomspec = [AtomSpec(at.atomspec) for at in center[model]]
if len(center_atomspec) != 1:
session.logger.error(
"ligand sterimol requires one central atom to which " + \
"the ligand is coordinated\n" + \
"%i were found on model %s:\n" % (len(center_atomspec), model.atomspec) + \
"\n".join([at.atomspec for at in center[model]])
)
continue
comp = Component(
rescol.find(comp_atoms),
to_center=rescol.find(center_atomspec),
key_atoms=rescol.find(key_atomspec),
)
data = comp.sterimol(
return_vector=True,
radii=radii,
at_L=at_L,
to_center=rescol.find(center_atomspec),
bisect_L=bisect_L,
)
l = np.linalg.norm(data["L"][1] - data["L"][0])
b1 = np.linalg.norm(data["B1"][1] - data["B1"][0])
b2 = np.linalg.norm(data["B2"][1] - data["B2"][0])
b3 = np.linalg.norm(data["B3"][1] - data["B3"][0])
b4 = np.linalg.norm(data["B4"][1] - data["B4"][0])
b5 = np.linalg.norm(data["B5"][1] - data["B5"][0])
if showVectors:
for key, color in zip(
["B1", "B2", "B3", "B4", "B5", "L"],
["black", "green", "purple", "orange", "red", "blue"]):
start, end = data[key]
s = ".color %s\n" % color
s += ".note Sterimol %s\n" % key
s += ".arrow %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f\n" % (
*start, *end)
stream = BytesIO(bytes(s, "utf-8"))
bild_obj, status = read_bild(session, stream,
"Sterimol %s" % key)
session.models.add(bild_obj, parent=model)
if showRadii:
s = ".note radii\n"
s += ".transparency 75\n"
color = None
for atom in comp.atoms:
chix_atom = atom.chix_atom
if radii == "umn":
r = VDW_RADII[chix_atom.element.name]
elif radii == "bondi":
r = BONDI_RADII[chix_atom.element.name]
if color is None or chix_atom.color != color:
color = chix_atom.color
rgb = [x / 255. for x in chix_atom.color]
rgb.pop(-1)
s += ".color %f %f %f\n" % tuple(rgb)
s += ".sphere %f %f %f %f\n" % (*chix_atom.coord, r)
stream = BytesIO(bytes(s, "utf-8"))
bild_obj, status = read_bild(session, stream, "Sterimol radii")
session.models.add(bild_obj, parent=model)
name = get_filename(model.name, include_parent_dir=False)
info += "%-16s\t%-11s\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n" % (
name, ", ".join(at.atomspec
for at in key_atoms[model]), b1, b2, b3, b4, b5, l)
targets.append(name)
coord_atoms.append([at.atomspec for at in key_atoms[model]])
datas.append(data)
info = info.strip()
info += "</pre>"
if not return_values:
session.logger.info(info, is_html=True)
if return_values:
return targets, coord_atoms, datas
def percent_vbur(
session,
selection,
radii="UMN",
radius=3.5,
scale=1.17,
method="Lebedev",
radialPoints=20,
angularPoints=1454,
minimumIterations=25,
onlyAtoms=None,
center=None,
useCentroid=True,
displaySphere=None,
pointSpacing=0.075,
intersectionScale=2,
palette="rainbow",
return_values=False,
steric_map=False,
use_scene=False,
num_pts=100,
shape="circle",
):
out = []
models = {
model: [
atom for atom in model.atoms
if onlyAtoms is not None and atom in onlyAtoms
]
for model in selection if isinstance(model, AtomicStructure)
}
s = "<pre>model\tcenter\t%Vbur\n"
for model in models:
if len(models[model]) == 0:
targets = None
else:
targets = [AtomSpec(atom.atomspec) for atom in models[model]]
if center is not None:
if isinstance(center, tuple):
mdl_center = np.array(center)
else:
mdl_center = [
AtomSpec(atom.atomspec) for atom in model.atoms
if atom in center
]
else:
mdl_center = []
rescol = ResidueCollection(model)
if use_scene:
oop_vector = session.view.camera.get_position().axes()[2]
ip_vector = session.view.camera.get_position().axes()[1]
else:
oop_vector = None
ip_vector = None
if len(mdl_center) == 0:
rescol.detect_components()
mdl_center = rescol.center
elif not isinstance(center, np.ndarray):
mdl_center = rescol.find([AtomSpec(c.atomspec) for c in center])
if not useCentroid and not isinstance(center, np.ndarray):
for c in mdl_center:
if steric_map:
if targets is not None:
key_atoms = []
targets = rescol.find(targets)
for atom in targets:
if c in atom.connected or atom in c.connected:
key_atoms.append(atom)
else:
key_atoms = None
x, y, z, min_alt, max_alt, basis, targets = rescol.steric_map(
center=c,
key_atoms=key_atoms,
radii=radii,
oop_vector=oop_vector,
ip_vector=ip_vector,
radius=radius,
return_basis=True,
num_pts=num_pts,
shape=shape,
)
vbur = rescol.percent_buried_volume(
targets=targets,
basis=basis,
center=c,
radius=radius,
radii=radii,
scale=scale,
method=method,
rpoints=int(radialPoints),
apoints=int(angularPoints),
min_iter=minimumIterations,
)
out.append((model.name, c.atomspec, vbur,
(x, y, z, min_alt, max_alt)))
else:
vbur = rescol.percent_buried_volume(
targets=targets,
center=c,
radius=radius,
radii=radii,
scale=scale,
method=method,
rpoints=int(radialPoints),
apoints=int(angularPoints),
min_iter=minimumIterations,
)
s += "%s\t%s\t%4.1f%%\n" % (model.name, c.atomspec, vbur)
out.append((model.name, c.atomspec, vbur))
if displaySphere is not None:
mdl = vbur_vis(
session,
rescol,
targets,
radii,
scale,
radius,
c,
pointSpacing,
intersectionScale,
displaySphere,
)
model.add([mdl])
atomspec = mdl.atomspec
center_coords = rescol.COM(c)
#XXX: the center will be wrong if the models are tiled
args = [
"color",
"radial",
atomspec,
"center",
",".join(["%.4f" % x for x in center_coords]),
"palette",
palette,
";",
"transparency",
atomspec,
"30",
]
run(session, " ".join(args))
else:
if steric_map:
if targets is not None:
key_atoms = []
targets = rescol.find(targets)
for atom in targets:
if any(c in atom.connected for c in mdl_center):
key_atoms.append(atom)
else:
key_atoms = None
x, y, z, min_alt, max_alt, basis, targets = rescol.steric_map(
center=mdl_center,
key_atoms=key_atoms,
radius=radius,
radii=radii,
oop_vector=oop_vector,
ip_vector=ip_vector,
return_basis=True,
num_pts=num_pts,
shape=shape,
)
vbur = rescol.percent_buried_volume(
targets=targets,
basis=basis,
center=mdl_center,
radius=radius,
radii=radii,
scale=scale,
method=method,
rpoints=int(radialPoints),
apoints=int(angularPoints),
min_iter=minimumIterations,
)
if not isinstance(mdl_center, np.ndarray):
out.append(
(model.name, ",".join([c.atomspec
for c in mdl_center]), vbur,
(x, y, z, min_alt, max_alt)))
else:
out.append(
(model.name, ",".join(["%.3f" % c
for c in mdl_center]), vbur,
(x, y, z, min_alt, max_alt)))
else:
vbur = rescol.percent_buried_volume(
targets=targets,
center=mdl_center,
radius=radius,
radii=radii,
scale=scale,
method=method,
rpoints=int(radialPoints),
apoints=int(angularPoints),
min_iter=minimumIterations,
)
if not isinstance(mdl_center, np.ndarray):
s += "%s\t%s\t%4.1f%%\n" % (model.name, ", ".join(
[c.atomspec for c in mdl_center]), vbur)
out.append(
(model.name,
", ".join([c.atomspec for c in mdl_center]), vbur))
else:
s += "%s\t%s\t%4.1f%%\n" % (model.name, ",".join(
["%.3f" % c for c in mdl_center]), vbur)
out.append(
(model.name, ",".join(["%.3f" % c
for c in mdl_center]), vbur))
if displaySphere is not None:
mdl = vbur_vis(
session,
rescol,
targets,
radii,
scale,
radius,
mdl_center,
pointSpacing,
intersectionScale,
displaySphere,
)
model.add([mdl])
atomspec = mdl.atomspec
if not isinstance(mdl_center, np.ndarray):
center_coords = rescol.COM(mdl_center)
else:
center_coords = mdl_center
#XXX: the center will be wrong if the models are tiled
args = [
"color",
"radial",
atomspec,
"center",
",".join(["%.4f" % x for x in center_coords]),
"palette",
palette,
";",
"transparency",
atomspec,
"30",
]
run(session, " ".join(args))
s = s.strip()
s += "</pre>"
if not return_values:
session.logger.info(s, is_html=True)
else:
return out
def libadd_ligand(self):
"""add ligand to library or open it in a new model"""
selection = selected_atoms(self.session)
if not selection.single_structure:
raise RuntimeError("selected atoms must be on the same model")
rescol = ResidueCollection(selection[0].structure)
ligand_atoms = [
atom for atom in rescol.atoms if atom.chix_atom in selection
]
key_chix_atoms = [
atom for atom in self.key_atomspec if not atom.deleted
]
if len(key_chix_atoms) < 1:
key_atoms = set([])
for atom in ligand_atoms:
for atom2 in atom.connected:
if atom2 not in ligand_atoms:
key_atoms.add(atom)
else:
key_atoms = rescol.find(
[AtomSpec(atom.atomspec) for atom in key_chix_atoms])
if len(key_atoms) < 1:
raise RuntimeError("no key atoms could be determined")
lig_name = self.ligand_name.text()
ligand = Component(ligand_atoms, name=lig_name, key_atoms=key_atoms)
ligand.comment = "K:%s" % ",".join(
[str(ligand.atoms.index(atom) + 1) for atom in key_atoms])
if len(lig_name) == 0:
chimerax_ligand = ResidueCollection(ligand).get_chimera(
self.session)
chimerax_ligand.name = "ligand preview"
self.session.models.add([chimerax_ligand])
bild_obj = key_atom_highlight(ligand, [0.2, 0.5, 0.8, 0.5],
self.session)
self.session.models.add(bild_obj, parent=chimerax_ligand)
else:
check_aaronlib_dir()
filename = os.path.join(AARONLIB, "Ligands", lig_name + ".xyz")
if os.path.exists(filename):
exists_warning = QMessageBox()
exists_warning.setIcon(QMessageBox.Warning)
exists_warning.setText(
"%s already exists.\nWould you like to overwrite?" %
filename)
exists_warning.setStandardButtons(QMessageBox.Yes
| QMessageBox.No)
rv = exists_warning.exec_()
if rv == QMessageBox.Yes:
ligand.write(outfile=filename)
self.tool_window.status("%s added to ligand library" %
lig_name)
else:
self.tool_window.status(
"%s has not been added to ligand library" % lig_name)
else:
ligand.write(outfile=filename)
self.tool_window.status("%s added to ligand library" %
lig_name)
def do_maplig(self):
lignames = self.ligname.text()
selection = selected_atoms(self.session)
if len(selection) < 1:
raise RuntimeWarning("nothing selected")
models = {}
for atom in selection:
if atom.structure not in models:
models[atom.structure] = [AtomSpec(atom.atomspec)]
else:
models[atom.structure].append(AtomSpec(atom.atomspec))
first_pass = True
new_structures = []
for ligname in lignames.split(','):
ligname = ligname.strip()
lig = Component(ligname)
for model in models:
if self.close_previous_bool and first_pass:
rescol = ResidueCollection(model)
elif self.close_previous_bool and not first_pass:
raise RuntimeError("only the first model can be replaced")
else:
model_copy = model.copy()
rescol = ResidueCollection(model_copy)
for i, atom in enumerate(model.atoms):
rescol.atoms[i].atomspec = atom.atomspec
rescol.atoms[i].add_tag(atom.atomspec)
rescol.atoms[i].chix_atom = atom
target = rescol.find(models[model])
if len(target) % len(lig.key_atoms) == 0:
k = 0
ligands = []
while k != len(target):
res_lig = ResidueCollection(lig.copy(), comment=lig.comment)
res_lig.parse_comment()
res_lig = Component(res_lig, key_atoms = ",".join([str(k + 1) for k in res_lig.other["key_atoms"]]))
ligands.append(res_lig)
k += len(lig.key_atoms)
else:
raise RuntimeError("number of key atoms no not match: %i now, new ligand has %i" % (len(target), len(lig.key_atoms)))
rescol.map_ligand(ligands, target)
for center_atom in rescol.center:
center_atom.connected = set([])
for atom in rescol.atoms:
if atom not in rescol.center:
if center_atom.is_connected(atom):
atom.connected.add(center_atom)
center_atom.connected.add(atom)
if self.close_previous_bool:
rescol.update_chix(model)
else:
struc = rescol.get_chimera(self.session)
new_structures.append(struc)
first_pass = False
if not self.close_previous_bool:
self.session.models.add(new_structures)
