def create_hbonds( lines, name ):
model = cmd.get_model(name)
# Ron Jacak's cool monster regex, borrowed from the Rosetta Pymol Plugin
hb_re = re.compile("(?:PROT|BASE) \s*[A-Z]+ \s*\d+ \s*(\d+) ([ A-Z]) \s*([A-Z0-9]+) \s*[A-Z]+ \s*\d+ \s*(\d+) ([ A-Z]) \s*([A-Z0-9]+)\s* (-?[\d\.]*)")
hbonds = []
for line in lines:
match = hb_re.search(line)
if match == None: continue
(d_resi, d_chain, d_atom, a_resi, a_chain, a_atom, energy) = match.groups()
energy = float(energy)
if energy < -0.05: # ingores very weak "hydrogen bonds"
d_addr = '/%s//%s/%s/%s' % ( name, d_chain, d_resi, d_atom )
a_addr = '/%s//%s/%s/%s' % ( name, a_chain, a_resi, a_atom )
d_atm = model.atom[ cmd.index(d_addr)[0][1] - 1 ]
a_atm = model.atom[ cmd.index(a_addr)[0][1] - 1 ]
if energy <= -0.9: colorscale = 1.0
else: colorscale = -1 * energy + 0.1 # ratio to strong, with offset
hbonds.extend( hbond( d_atm, a_atm, colorscale, colorscale, 0.0 ) )
cmd.load_cgo( hbonds, 'hb_%s' % name )
def draw_axis(x=None, y=None, z=None, i=None, j=None, k=None, length=20.0, r=1.0, g=1.0, b=1.0, width=1.0 ):
if x == None or y == None or z == None or i == None or j == None or k== None :
print 'Usage: draw_axis x,y,z, i,k,j, length, r,g,b, width'
print 'draw a line centered at (x,y,z) with the direction vector (i,j,k)'
print 'length, color (r,g,b), and width arguments are optional'
# print 'For a fun example of the command, run draw_axis_example'
else :
x,y,z = float(x), float(y), float(z)
i,j,k = float(i), float(j), float(k)
r,g,b = float(r), float(g), float(b)
width = float(width)
length = float(length) / 2.0
x1,y1,z1 = (x+i*length,y+j*length,z+k*length)
x2,y2,z2 = (x-i*length,y-j*length,z-k*length)
obj = [
LINEWIDTH, width,
BEGIN, LINES,
COLOR, r, g, b,
VERTEX, x1, y1, z1,
VERTEX, x2, y2, z2,
END
]
cmd.load_cgo(obj,'axis'+str(counter.state))
counter.state += 1
def show_points(points, color = [1.0, 0.0, 0.0], selection='all', name = 'samples', labels=[]):
view = cmd.get_view(quiet=not DEBUG)
# adjust radius to size of bounding box
bb = cmd.get_extent(selection, quiet=not DEBUG)
ll = vec3(bb[0])
tr = vec3(bb[1])
diag = tr - ll
r = diag.length() / 2.0
# origin of rotation in model space
#o = vec3(view[12:15])
c = com.COM(selection)
o = vec3(c)
#spheres = [BEGIN, TRIANGLE_STRIP]
spheres = [COLOR]
spheres.extend(color)
i = 0.0
j = 0
for p in points:
#spheres.extend([COLOR, 1.0, 1 - scaled_value, 1 - scaled_value])
spheres.extend([SPHERE, o[0]+r*p[0], o[1]+r*p[1], o[2]+r*p[2], 1.25])
#drawVector(o, o + r * vec3(p))
#spheres.extend([VERTEX, o[0]+r*p[0], o[1]+r*p[1], o[2]+r*p[2]])
#i += 1.0/len(values)
l = 1.1
if (len(labels) > j):
cmd.pseudoatom(labels[j] + "_label", pos = [o[0]+l * r*p[0], o[1]+l*r*p[1], o[2]+l*r*p[2], 1.25], label = labels[j])
j += 1
#spheres.extend([END])
cmd.load_cgo(spheres, name, 1)
def showcom(sel="all"):
global numcom
c = com(sel)
print "Center of mass: ", c
cgo = [pymol.cgo.COLOR, 1.0, 1.0, 1.0, SPHERE, c.x, c.y, c.z, 1.0] ## white sphere with 3A radius
cmd.load_cgo(cgo, "com%i" % numcom)
numcom += 1
def cartoonize(color, rep):
"""draw a cartoon representation of glycans"""
stored.ResiduesNumber = []
cmd.iterate('name c1', 'stored.ResiduesNumber.append((resi))')
resn_list = [int(i) for i in stored.ResiduesNumber]
bonds = get_glyco_bonds(resn_list[0], resn_list[-1]+1)
con_matrix = writer(bonds)
#con_matrix = writer2(bonds)
rings = find_rings(resn_list)
rings_coords = get_ring_coords(resn_list, rings)
bonds_coords = get_bonds_coords(resn_list, con_matrix)
colors = get_colors_c1(resn_list, color)
bonds_colors = get_bonds_colors(resn_list, con_matrix, color)
cmd.set('suspend_updates', 'on')
for state, coords in enumerate(rings_coords):
obj = []
if rep == 'beads':
radius_s = 1.8
radius_b = 0.18
obj = beads(obj, coords, colors[state], radius_s)
obj = cylinder(obj, bonds_coords[state], bonds_colors[state], radius_b)
else:
if rep == 'cartoon':
radius = 0.075
else:
radius = 0.035
obj = hexagon(obj, coords, colors[state], rep, radius)
obj = cylinder(obj, bonds_coords[state], bonds_colors[state], radius)
cmd.load_cgo(obj,'cgo01', state+1)
cmd.select('glycan', 'byres name C1')
cmd.delete('glycan')
cmd.delete('tmp')
cmd.set('two_sided_lighting', 1)
cmd.set('suspend_updates', 'off')
def axes(name='axes'):
'''
DESCRIPTION
Puts coordinate axes to the lower left corner of the viewport.
'''
from pymol import cgo
auto_zoom = cmd.get('auto_zoom')
cmd.set('auto_zoom', 0)
w = 0.06 # cylinder width
l = 0.75 # cylinder length
h = 0.25 # cone hight
d = w * 1.618 # cone base diameter
obj = [cgo.CYLINDER, 0.0, 0.0, 0.0, l, 0.0, 0.0, w, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0,
cgo.CYLINDER, 0.0, 0.0, 0.0, 0.0, l, 0.0, w, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0,
cgo.CYLINDER, 0.0, 0.0, 0.0, 0.0, 0.0, l, w, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0,
cgo.CONE, l, 0.0, 0.0, h+l, 0.0, 0.0, d, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0,
cgo.CONE, 0.0, l, 0.0, 0.0, h+l, 0.0, d, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0,
cgo.CONE, 0.0, 0.0, l, 0.0, 0.0, h+l, d, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]
PutCenterCallback(name, 1).load()
cmd.load_cgo(obj, name)
cmd.set('auto_zoom',auto_zoom)
def showLine(self, msi0, msi1, name='conn') : from pymol import cmd from pymol.cgo import BEGIN, END, LINES, VERTEX, COLOR, CYLINDER, SPHERE mean0, mean1, mid = [0.,0.,0.], [0., 0., 0.], [0.,0.,0.,] for si in self.master2slave[msi0] : mean0[0] = mean0[0] + self.sites[si][0] mean0[1] = mean0[1] + self.sites[si][1] mean0[2] = mean0[2] + self.sites[si][2] mean0[0] = mean0[0] / len(self.master2slave[msi0]) mean0[1] = mean0[1] / len(self.master2slave[msi0]) mean0[2] = mean0[2] / len(self.master2slave[msi0]) for si in self.master2slave[msi1] : mean1[0] = mean1[0] + self.sites[si][0] mean1[1] = mean1[1] + self.sites[si][1] mean1[2] = mean1[2] + self.sites[si][2] mean1[0] = mean1[0] / len(self.master2slave[msi1]) mean1[1] = mean1[1] / len(self.master2slave[msi1]) mean1[2] = mean1[2] / len(self.master2slave[msi1]) mid[0] = (mean0[0] + mean1[0]) / 2. mid[1] = (mean0[1] + mean1[1]) / 2. mid[2] = (mean0[2] + mean1[2]) / 2. clr0, clr1 = self.chem2clr[self.mschems[msi0]], self.chem2clr[self.mschems[msi1]] lobj = [CYLINDER, ] + list(mean0) + list(mean1) + [self.conwidth,] + list(clr0) + list(clr1) lobj = lobj + [COLOR,] + list(clr0) + [SPHERE,] + list(mean0) + [2*self.conwidth,] + [COLOR,] + list(clr1) + [SPHERE,] + list(mean1) + [2*self.conwidth,] print lobj #lobj = [BEGIN, LINES, COLOR,] + list(clr0) + [VERTEX,] + list(mean0) + [VERTEX,] + list(mid) + [COLOR,] + list(clr1) + [VERTEX,] + list(mid) + [VERTEX,] + list(mean1) + [END,] cmd.load_cgo(lobj, name)
def plot(self, coords, freqs, min, max, min_r, max_r, col_min, col_max, out_obj):
widths = []
cgo = []
nsteps = 200
gradient = []
cols = []
#gradient = self.make_gradient("sbcol", array(cmd.get_color_tuple(self.interpret_color(col_min))), array(cmd.get_color_tuple(self.interpret_color(col_max))), nsteps )
gradient = self.make_gradient("sbcol", array(col_min), array(col_max), nsteps )
for i,freq in enumerate(freqs):
if freq < min:
freqs[i] = min
elif freq > max:
freqs[i] = max
widths.append( (freqs[i] - min)*((max_r - min_r) / (max - min)) + min_r )
cols.append(gradient[int(round(freqs[i]/max*(nsteps-1)))])
for i in range(0, len(coords), 2):
cgo.append(CYLINDER)
cgo.extend(coords[i])
cgo.extend(coords[i+1])
cgo.append(widths[i/2])
cgo.extend(cmd.get_color_tuple(self.interpret_color(cols[i/2])))
cgo.extend(cmd.get_color_tuple(self.interpret_color(cols[i/2])))
cmd.load_cgo(cgo,out_obj)
def rpcSpheres(sphereD, id='cgo', extend=1):
""" create a sphere
Arguments:
sphereD: a series of (pos,rad,color,transparent,transparency) tuples
id: (OPTIONAL) the name of the object to be created
extend: (OPTIONAL) if this is nonzero, the object will be cleared
before adding the new sphere. Otherwise the sphere is appended
to the ojbect
"""
if extend:
obj = cgoDict.get(id, [])
else:
obj = []
for pos, rad, color, transparent, transparency in sphereD:
r, g, b = color
x, y, z = pos
if not transparent:
o = []
else:
o = [cgo.ALPHA, 1 - transparency]
o.extend([cgo.COLOR, r, g, b, cgo.SPHERE, x, y, z, rad])
obj.extend(o)
cgoDict[id] = obj
cmd.load_cgo(obj, id, 1)
return 1
def rpcSphere(pos, rad, color, id='cgo', extend=1, transparent=0, transparency=0.5):
""" create a sphere
Arguments:
pos: a 3 tuple with the position of the sphere
rad: a float with the radius
color: a 3 tuple with the color of the sphere. (1,1,1) is white
id: (OPTIONAL) the name of the object to be created
extend: (OPTIONAL) if this is nonzero, the object will be cleared
before adding the new sphere. Otherwise the sphere is appended
to the ojbect
transparent: (OPTIONAL) sets the object to be transparent
transparency: (OPTIONAL) the percent transparency of the object
"""
r, g, b = color
x, y, z = pos
if extend:
obj = cgoDict.get(id, [])
else:
obj = []
if not transparent:
o = []
else:
o = [cgo.ALPHA, 1 - transparency]
o.extend([cgo.COLOR, r, g, b, cgo.SPHERE, x, y, z, rad])
obj.extend(o)
cgoDict[id] = obj
cmd.load_cgo(obj, id, 1)
return 1
def draw_spheres(coords, model, frame, radius=0.5):
spheres = []
for x in coords.reshape(coords.size / 3, 3):
spheres.extend([cgo.COLOR, 1.0, 0.0, 0.0])
spheres.extend([cgo.SPHERE, x[0], x[1], x[2], radius])
cmd.load_cgo(spheres, model, frame)
def load_cmap():
file_cmap= open_it()
m=cmd.get_model('all')
trans={}
for ii in range(len(m.atom)):
trans[m.atom[ii].id]=ii
ElasticNet = [ BEGIN, LINES, COLOR, 1.0, 0.4, 0.0 ]
for line in open(file_cmap,'r'):
contact=map(float,line.split())
aa=trans[contact[0]]
bb=trans[contact[1]]
ElasticNet.append(VERTEX)
ElasticNet.append(m.atom[aa].coord[0])
ElasticNet.append(m.atom[aa].coord[1])
ElasticNet.append(m.atom[aa].coord[2])
ElasticNet.append(VERTEX)
ElasticNet.append(m.atom[bb].coord[0])
ElasticNet.append(m.atom[bb].coord[1])
ElasticNet.append(m.atom[bb].coord[2])
ElasticNet.append(END)
cmd.load_cgo(ElasticNet,'ElasticNet')
def plot_axis(center_obj=None, length=20, radius=0.1): # create the axes object, draw axes with cylinders coloured red, green, #blue for X, Y and Z com = (0.0, 0.0, 0.0) if center_obj: com = center_of_mass.get_com(center_obj) u_vec = com/np.linalg.norm(com) print 'Origin ', com print 'Unit vector ', u_vec obj = [ CYLINDER, com[0] - length, com[1], com[2], com[0] + length, com[1], com[2], radius, 1, 0, 0, 1, 0, 0, CYLINDER, com[0], com[1] - length, com[2], com[0], com[1] + length, com[2], radius, 0, 1, 0, 0, 1, 0, CYLINDER, com[0], com[1], com[2] - length, com[0], com[1], com[2] + length, radius,0, 0, 1, 0, 0, 1, ] # add labels to axes object (requires pymol version 0.8 or greater, I # believe cyl_text(obj,plain,[com[0] - length, com[1], com[2]],'X',0.20,axes=[[3,0,0],[0,3,0],[0,0,3]]) cyl_text(obj,plain,[com[0], com[1] - length, com[2]],'Y',0.20,axes=[[3,0,0],[0,3,0],[0,0,3]]) cyl_text(obj,plain,[com[0], com[1], com[2] - length],'Z',0.20,axes=[[3,0,0],[0,3,0],[0,0,3]]) # then we load it into PyMOL if center_obj: cmd.load_cgo(obj, center_obj + '_axes') else: cmd.load_cgo(obj, 'axes')
def ellipsoid(name,x,y,z, rx,ry,rz,segs=40,color="red",transformation=None,_self=cmd):
"""Create an ellipsoid
Arguments
=========
x,y,z: center coordinates
rx,ry,rz: length of axes
n: north-south exponent
e: east-west exponent
u1,u2: start and end angles in the east-west direction
v1,v2: start and end angles in the north-south direction
u_segs: Number of segments in the east-west direction
v_segs: Number of segments in the north-south direction
color: Either one (solid color) or six (-x,-y,-z,+x,+y,+z)
colors. Colors may be either a space-separated list of
pymol color names, or a list of tuples with RGB color
for the ellipsoid (0-1.0).
transformation: a 16-element list giving the 4x4 transformation matrix,
in row-major order, as described in get_object_matrix()
{default: identity matrix}
"""
cgo = makeSuperQuadricEllipsoid(x, y, z, rx,ry,rz, 1.0, 1.0,
u_segs=int(segs)/2,v_segs=segs,color=color,transformation=transformation)
cmd.load_cgo(cgo,name)
def visualize_orientation(direction, center=[0, 0, 0], scale=1.0, symmetric=False, color="green", color2="red"):
"""
Draw an arrow. Helper function for "helix_orientation" etc.
"""
from pymol import cgo
color_list = cmd.get_color_tuple(color)
color2_list = cmd.get_color_tuple(color2)
if symmetric:
scale *= 0.5
end = cpv.add(center, cpv.scale(direction, scale))
radius = 0.3
obj = [cgo.SAUSAGE]
obj.extend(center)
obj.extend(end)
obj.extend([radius, 0.8, 0.8, 0.8])
obj.extend(color_list)
if symmetric:
start = cpv.sub(center, cpv.scale(direction, scale))
obj.append(cgo.SAUSAGE)
obj.extend(center)
obj.extend(start)
obj.extend([radius, 0.8, 0.8, 0.8])
obj.extend(color2_list)
coneend = cpv.add(end, cpv.scale(direction, 4.0 * radius))
if cmd.get_version()[1] >= 1.2:
obj.append(cgo.CONE)
obj.extend(end)
obj.extend(coneend)
obj.extend([radius * 1.75, 0.0])
obj.extend(color_list * 2)
obj.extend([1.0, 1.0]) # Caps
cmd.load_cgo(obj, get_unused_name("oriVec"), zoom=0)
def veccgofrompoint(a, c, lbl):
cmd.load_cgo(
[
COLOR,
1.0,
1.0,
1.0,
SPHERE,
c.x,
c.y,
c.z,
0.2,
CYLINDER,
c.x,
c.y,
c.z,
c.x + a.x,
c.y + a.y,
c.z + a.z,
0.1,
1,
1,
1,
1,
1,
1,
],
lbl,
)
def showSurf(self,name,msis) :
from pymol import cmd
assert len(self.chem2clr.items()) > 0
totarea, msobj, FIs, faceclr, lineclr = 0., [], [], [], []
for msi0 in self.msadj.keys() :
if re.compile('HOH').search(self.msnames[msi0]) : continue ## no waters
if len(msis) > 0 and msi0 not in msis : continue
for msi1 in self.msadj[msi0].keys() :
#if len(msis) > 0 and msi1 not in msis : continue
#if msi1 >= msi0 : continue
#print self.msadj[msi0][msi1]
for fi in self.msadj[msi0][msi1] :
if fi in FIs : FIs.remove(fi)
else : FIs.append(fi)
for msi0 in self.msadj.keys() :
if len(msis) > 0 and msi0 not in msis : continue
if re.compile('HOH').search(self.msnames[msi0]) : continue ## no waters
for msi1 in self.msadj[msi0].keys() :
#if msi1 >= msi0 : continue
#if len(msis) > 0 and msi1 not in msis : continue
for fi in self.msadj[msi0][msi1] :
if fi in FIs :
totarea = totarea + self.areas[fi]
faceclr, lineclr = self.chem2clr[self.mschems[msi0]], self.chem2clr[self.mschems[msi1]] ## own clr for surface
msobj = msobj + self.makeFacePymolObj(self.vcen, self.faces[fi], faceclr, lineclr)
cmd.load_cgo(msobj, name)
return totarea
def load_msms_surface(filename, name="", _colors=None):
"""
DESCRIPTION
Load MSMS .vert and .face files as a CGO
"""
from pymol import cgo
from pymol.cgo import NORMAL, VERTEX, COLOR
if _colors:
_colors = [cmd.get_color_tuple(c) for c in _colors]
if filename.endswith(".vert") or filename.endswith(".face"):
filename = filename[:-5]
# vertex file
line_iter = iter(open(filename + ".vert"))
# skip header
for line in line_iter:
if not line.startswith("#"):
break
# read vertices
vertices = [None] # make 1-indexable
for line in line_iter:
data = line.split()
vertex = [float(x) for x in data[0:3]]
normal = [float(x) for x in data[3:6]]
sphere = int(data[7]) - 1
vertices.append((vertex, normal, sphere))
# faces file
line_iter = iter(open(filename + ".face"))
# skip header
for line in line_iter:
if not line.startswith("#"):
break
cgobuf = [cgo.BEGIN, cgo.TRIANGLES]
# read triangles
for line in line_iter:
for index in line.split()[:3]:
data = vertices[int(index)]
if _colors:
cgobuf.append(COLOR)
cgobuf.extend(_colors[data[2]])
cgobuf.append(NORMAL)
cgobuf.extend(data[1])
cgobuf.append(VERTEX)
cgobuf.extend(data[0])
cgobuf.append(cgo.END)
if not name:
name = cmd.get_unused_name("msmssurf")
cmd.load_cgo(cgobuf, name)
def plane_orientation(selection, state=-1, visualize=1, quiet=1):
'''
DESCRIPTION
Fit plane (for example beta-sheet). Can also be used with
angle_between_helices (even though this does not fit helices).
Returns center and normal vector of plane.
'''
try:
import numpy
except ImportError:
print ' Error: numpy not available'
raise CmdException
state, visualize, quiet = int(state), int(visualize), int(quiet)
coords = list()
cmd.iterate_state(state, '(%s) and guide' % (selection),
'coords.append([x,y,z])', space=locals())
if len(coords) < 3:
print 'not enough guide atoms in selection'
raise CmdException
x = numpy.array(coords)
U,s,Vh = numpy.linalg.svd(x - x.mean(0))
# normal vector of plane is 3rd principle component
vec = cpv.normalize(Vh[2])
if cpv.dot_product(vec, x[-1] - x[0]) < 0:
vec = cpv.negate(vec)
center = x.mean(0).tolist()
_common_orientation(selection, center, vec, visualize, 4.0, quiet)
# plane visualize
if visualize:
from pymol import cgo
dir1 = cpv.normalize(Vh[0])
dir2 = cpv.normalize(Vh[1])
sx = [max(i/4.0, 2.0) for i in s]
obj = [ cgo.BEGIN, cgo.TRIANGLES, cgo.COLOR, 0.5, 0.5, 0.5 ]
for vertex in [
cpv.scale(dir1, sx[0]),
cpv.scale(dir2, sx[1]),
cpv.scale(dir2, -sx[1]),
cpv.scale(dir1, -sx[0]),
cpv.scale(dir2, -sx[1]),
cpv.scale(dir2, sx[1]),
]:
obj.append(cgo.VERTEX)
obj.extend(cpv.add(center, vertex))
obj.append(cgo.END)
cmd.load_cgo(obj, cmd.get_unused_name('planeFit'))
return center, vec
def plot3d(ary):
assert ary.shape[1]==3
cmd.delete("plot")
print "plotting",ary.shape[0],"points"
obj = list()
obj.extend( [ cgo.BEGIN, cgo.POINTS , cgo.COLOR, 1.0, 1.0, 1.0 ] )
for i in xrange(ary.shape[0]):
obj.extend([cgo.VERTEX, ary[i,0], ary[i,1], ary[i,2] ])
cmd.load_cgo(obj, "plot")
def selbycomp(trn=0):
cmd.select("TRI1","TRI and chain A+B+C")
cmd.select("TRI2","TRI and chain D+E+F")
cmd.select("TRI3","TRI and chain G+H+I")
cmd.select("TRI4","TRI and chain J+K+L")
cmd.select("TRI5","TRI and chain M+N+O")
cmd.select("TRI6","TRI and chain P+Q+R")
cmd.select("TRI7","TRI and chain S+T+U")
cmd.select("TRI8","TRI and chain V+W+X")
cmd.select("DIM1","DIM and chain A+D")
cmd.select("DIM2","DIM and chain B+G")
cmd.select("DIM3","DIM and chain C+J")
cmd.select("DIM4","DIM and chain E+U")
cmd.select("DIM5","DIM and chain F+R")
cmd.select("DIM6","DIM and chain H+T")
cmd.select("DIM7","DIM and chain I+O")
cmd.select("DIM8","DIM and chain K+Q")
cmd.select("DIM9","DIM and chain L+N")
cmd.select("DIM10","DIM and chain M+V")
cmd.select("DIM11","DIM and chain P+W")
cmd.select("DIM12","DIM and chain X+S")
cmd.delete("LINE*")
cmd.delete("serf*")
cmd.do("""alter all, b=50
alter all, q=1
set gaussian_resolution,8""")
ISO="""map_new map%s, gaussian, 2, %s, 10
isosurface surf%s, map%s"""
for i in range(1, 9):
cmd.do(ISO%(("TRI%i"%i,)*4))
cmd.color(COLORS[i-1],"surfTRI%i"%i)
c = com("TRI%i"%i)
# trans("TRI%i"%i,trn*c.normalized())
obj = [
CYLINDER,
0.0, 0.0, 0.0,
1.6*c.x, 1.6*c.y, 1.6*c.z,
1.5,
0.1,0.1,0.1,0.1,0.1,0.1,
]
cmd.load_cgo(obj,'LINETRI%i'%i)
for i in range(1,13):
cmd.do(ISO%(("DIM%i"%i,)*4))
cmd.color(COLORS[i+7],"surfDIM%i"%i)
c = com("DIM%i"%i)
# trans("DIM%i"%i,trn*com("DIM%i"%i).normalized())
obj = [
CYLINDER,
0.0, 0.0, 0.0,
1.3*c.x, 1.3*c.y, 1.3*c.z,
1.0,
0,0,1,0,0,1
]
cmd.load_cgo(obj,'LINEDIM%i'%i)
def showCycles() :
resnames1, resnames2, intnames = [],[],[]
for i in range(pyncData.resSel1.size()) : resnames1.append(pyncData.resSel1.get(i))
for i in range(pyncData.resSel2.size()) : resnames2.append(pyncData.resSel2.get(i))
for i in pyncData.intlist.curselection() : intnames.append(pyncData.intlist.get(i))
res, pos, edges = [], [], []
curfile = pyncData.curfile.get()
for int in pyncData.files[curfile][0] :
if not int.res1 in resnames1 : continue
if not int.res2 in resnames2 : continue
if len(intnames) > 0 and not int.name in intnames : continue
if not int.res1 in res :
res.append(int.res1)
pos.append(list(int.p1))
if not int.res2 in res :
res.append(int.res2)
pos.append(list(int.p2))
edges.append((res.index(int.res1), res.index(int.res2)))
if posRepeat(pos, res) : assert(0)
fn = mktemp()[1]
print fn
f = open(fn, 'w')
f.write("%d\n" % len(res))
f.write("%d\n" % len(edges))
for i in range(len(edges)) : f.write("%d %d\n" % edges[i])
f.close()
c = popen2.Popen3("/tmp/horton %s" % fn)
edgeCycleBase = []
for l in c.fromchild.readlines() :
if not re.compile('Edges in cycle:').search(l) : continue
cycle = []
flds = string.split( re.sub('Edges in cycle:', '', l) )
for fl in flds : cycle.append(string.atoi(fl))
edgeCycleBase.append(cycle)
if len(edgeCycleBase) == 0 :
print "No cycles found !!"
return
edgeCycles = getAllCycles(edgeCycleBase, edges)
from pymol import cmd
from pymol.cgo import BEGIN,LINES,END,VERTEX,COLOR
objname = pyncData.objname.get()
if not objname or objname == '' : objname = 'cycles'
for c in edgeCycleBase :
obj = [BEGIN,LINES]
for ce in c :
obj = obj + [VERTEX,] + list(pos[edges[ce][0]]) + [VERTEX,] + list(pos[edges[ce][1]])
obj = obj + [END]
cmd.load_cgo(obj, objname)
objname = pyncData.objname.get()
if not objname or objname == '' : objname = 'cycles'
objname = "all_" + objname
for c in edgeCycles :
obj = [BEGIN,LINES]
for ce in c :
obj = obj + [VERTEX,] + list(pos[edges[ce][0]]) + [VERTEX,] + list(pos[edges[ce][1]])
obj = obj + [END]
cmd.load_cgo(obj, objname)
def rpcCylinder(end1, end2, rad, color1, id='cgo', color2=None, extend=1, transparent=0,
transparency=0.5):
""" create a cylinder
Arguments:
end1: a 3 tuple with the position of end1 of the sphere
end2: a 3 tuple with the position of end1 of the sphere
rad: a float with the radius
color1: a 3 tuple with the color of end1 of the sphere. (1,1,1) is white
id: (OPTIONAL) the name of the object to be created
color2: (OPTIONAL) a 3 tuple with the color of end2 of the sphere. (1,1,1)
is white
extend: (OPTIONAL) if this is nonzero, the object will be cleared
before adding the new sphere. Otherwise the sphere is appended
to the ojbect
transparent: (OPTIONAL) sets the object to be transparent
transparency: (OPTIONAL) the percent transparency of the object
NOTE: the reason that color2 follows id is that I think clients are
going to be interested in setting the id more often than they are going
to care about the second color.
"""
global cgoDict
if color2 is None:
color2 = color1
r1, g1, b1 = color1
r2, g2, b2 = color2
x1, y1, z1 = end1
x2, y2, z2 = end2
if extend:
obj = cgoDict.get(id, [])
else:
obj = []
if not transparent:
o = []
else:
o = [cgo.ALPHA, 1 - transparency]
o.extend([cgo.CYLINDER,
x1,
y1,
z1,
x2,
y2,
z2,
rad,
r1,
g1,
b1,
r2,
g2,
b2, ])
obj.extend(o)
cgoDict[id] = obj
cmd.load_cgo(obj, id, 1)
return 1
def showvs(self, msi0, name) : assert len(self.chem2clr.items()) > 0 from pymol import cmd msobj = [] for msi1 in self.msadj[msi0].keys() : faceclr, lineclr, faceobj = self.chem2clr[self.mschems[msi1]], self.chem2clr[self.mschems[msi0]], [] for fi in self.msadj[msi0][msi1] : faceobj = faceobj + self.makeFacePymolObj(self.vcen, self.faces[fi], faceclr, lineclr) msobj = msobj + faceobj cmd.load_cgo(msobj, name)
def view(self, name="external graphics"):
"""
Load the scene into PyMOL
@param name: the name of the PyMOL object corresponding to the scene
"""
pymol_objects = []
for o in self.objects:
pymol_objects.extend(o.getPymolObjects())
cmd.load_cgo(pymol_objects, name)
def draw_axis(chA, chB, scale_factor=20, w=0.6, r1=1, g1=1, b1=1, r2=1, g2=0, b2=0):
T = transf_matrix(chA, chB)
angle=angle_axis(chA, chB)
angle_degrees=(angle*180)/math.pi
axis1=[direction_cosines(chA, chB)[0], direction_cosines(chA, chB)[1], direction_cosines(chA, chB)[2]]
p = nearest_point_to_axis(chA, chB)
x1, y1, z1 = p[0] + (3*scale_factor*axis1[0]), p[1] + (3*scale_factor*axis1[1]), p[2] + (3*scale_factor*axis1[2])
x2, y2, z2 = p[0] - (3*scale_factor*axis1[0]), p[1] - (3*scale_factor*axis1[1]), p[2] - (3*scale_factor*axis1[2])
obj = [cgo.CYLINDER, x1, y1, z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2, 0.0]
cmd.load_cgo(obj, angle_degrees)
cmA=center_of_Mass(chA)
cmB=cmW
cmAver=(cmB+cmA)/2
vector=numpy.array([(cmB[0]-cmA[0]), (cmB[1]-cmA[1]), (cmB[2]-cmA[2])])
moduli_vector=numpy.linalg.norm(vector)
vector_director=numpy.array([(cmB[0]-cmA[0])/moduli_vector, (cmB[1]-cmA[1])/moduli_vector, (cmB[2]-cmA[2])/moduli_vector])
pC_A = proyeccion_centroide(chA, chA, chB)
pC_B = proyeccion_centroide_working(chA, chB)
trans_vector = numpy.array([(pC_B[0]-pC_A[0]), (pC_B[1]-pC_A[1]), (pC_B[2]-pC_A[2])])
modu_tr = numpy.linalg.norm(trans_vector)
rota_centroid_rad=numpy.dot(vector_director, axis1)
rota_centroid = (rota_centroid_rad*180)/math.pi
rota_centroid_absol_0= numpy.absolute(rota_centroid)
rota_centroid_absol=round(rota_centroid_absol_0,2)
if rota_centroid_absol == 0.00:
p1 = '_1'
p2 = '_2'
p3 = '_3'
cmd.pseudoatom (pos=[cmA[0], cmA[1], cmA[2]], object=p1)
cmd.pseudoatom (pos=[pC_A[0], pC_A[1], pC_A[2]], object=p2)
cmd.pseudoatom (pos=[cmB[0], cmB[1], cmB[2]], object=p3)
cmd.angle(None, p1, p2, p3)
print_information(T, axis1, angle_degrees, moduli_vector, obj, x1, y1, z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2)
if rota_centroid_absol != 0:
p1 = '_1'
p2 = '_2'
p3 = '_3'
p4 = '_4'
cmd.pseudoatom (pos=[cmA[0], cmA[1], cmA[2]], object=p1)
cmd.pseudoatom (pos=[pC_A[0], pC_A[1], pC_A[2]], object=p2)
cmd.pseudoatom (pos=[pC_B[0], pC_B[1], pC_B[2]], object=p3)
cmd.pseudoatom (pos=[cmB[0], cmB[1], cmB[2]], object=p4)
cmd.dihedral(None, p1, p2, p3, p4)
cmd.distance(None, p2, p3)
print_information(T, axis1, angle_degrees, moduli_vector, obj, x1, y1, z1, x2, y2, z2, w, r1, g1, b1, r2, g2, b2, modu_tr)
cmd.create('working', chA)
cmd.super('working', chB)
def show_peaks(unit_cell, clusters, radius=2.0):
go = []
go.extend([cgo.COLOR, 1, 0, 0,])
height0 = None
for site,height in zip(clusters.sites(), clusters.heights()):
print "%8.5f %8.5f %8.5f" % site, height
if (height0 == None): height0 = height
go.extend( [cgo.SPHERE]
+ list(unit_cell.orthogonalize(site))
+ [radius*height/height0])
cmd.load_cgo(go, "peaks")
def ie_build(sele, name='iellipsoid', col='[0.5, 0.5, 0.5]', scale='1'):
# data = cmd.get_coords(sele) # only for 1.7.4 and higher
data = np.array(cmd.get_model(sele, 1).get_coord_list())
col = eval(col, {'__builtins__': None}, {})
scale = float(scale) * 0.0001
r0 = data.mean(axis=0)
x, y, z = (data - r0).transpose()
Jxx = sum(y ** 2 + z ** 2)
Jyy = sum(x ** 2 + z ** 2)
Jzz = sum(x ** 2 + y ** 2)
Jxy, Jxz, Jyz = sum(x * y), sum(x * z), sum(y * z)
ws, vs = linalg.eig(np.array([
[Jxx, -Jxy, -Jxz],
[-Jxy, Jyy, -Jyz],
[-Jxz, -Jyz, Jzz]
]))
M = linalg.inv(vs)
a1, a2, a3 = ws * scale
u_segs = 12
v_segs = 12
mesh = [BEGIN, TRIANGLES, COLOR]
mesh.extend(col)
dU = math.pi / u_segs
dV = 2 * math.pi / v_segs
U = -math.pi / 2
for Y in range(0, u_segs):
V = math.pi
for X in range(0, v_segs):
(x1, y1, z1), (n1x, n1y, n1z) = vertex(a1, a2, a3,
U, V, M, r0)
(x2, y2, z2), (n2x, n2y, n2z) = vertex(a1, a2, a3,
U + dU, V, M, r0)
(x3, y3, z3), (n3x, n3y, n3z) = vertex(a1, a2, a3,
U + dU, V + dV,
M, r0)
(x4, y4, z4), (n4x, n4y, n4z) = vertex(a1, a2, a3,
U, V + dV, M, r0)
mesh.extend([NORMAL, n1x, n1y, n1z, VERTEX, x1, y1, z1])
mesh.extend([NORMAL, n2x, n2y, n2z, VERTEX, x2, y2, z2])
mesh.extend([NORMAL, n4x, n4y, n4z, VERTEX, x4, y4, z4])
mesh.extend([NORMAL, n2x, n2y, n2z, VERTEX, x2, y2, z2])
mesh.extend([NORMAL, n3x, n3y, n3z, VERTEX, x3, y3, z3])
mesh.extend([NORMAL, n4x, n4y, n4z, VERTEX, x4, y4, z4])
V += dV
U += dU
mesh.append(END)
cmd.load_cgo(mesh, name)
def buried_unsats_from_logfile( fname ) :
obj = []
white = [ COLOR, 1.0, 1.0, 1.0 ]
#blue = [ COLOR, 0.0, 0.0, 1.0 ]
#red = [ COLOR, 1.0, 0.0, 0.0 ]
#obj.extend( red )
#obj.extend( blue )
obj.extend( white )
atoms = read_buried_unsats_from_logfile( fname )
append_sphere_objs_from_atoms( atoms, obj )
cmd.load_cgo(obj,'test',1)
def orb_cyl(lab=""):
cmd.delete(lab + "o1")
cmd.delete(lab + "o2")
p1 = com("pk1")
p2 = com("pk2")
p3 = com("pk3")
dr = (p1 - p2).normalized()
ax = (p3 - p2).cross(p1 - p2).normalized()
o1 = rotation_matrix(ax, 60.0) * dr
o2 = rotation_matrix(ax, -60.0) * dr
cmd.load_cgo(o1.cgofrompoint(p1), lab + "o1")
cmd.load_cgo(o2.cgofrompoint(p1), lab + "o2")
9.58,
17.53,
36.01,
33.58,
0.2,
1.0,
1.0,
1.0,
0.,
1.0,
0.,
CYLINDER,
-21.37,
28.14,
49.26,
1.30,
46.86,
-8.07,
0.2,
1.0,
1.0,
1.0,
0.,
0.0,
1.0,
]
# then we load it into PyMOL
cmd.load_cgo(obj, 'out_ani')
float(64.0), float(79.5),
float(1.0)
]
cluster_dict["17.763999939"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(2.5),
float(72.5), float(80.0),
float(1.0)
]
cluster_dict["17.763999939_arrows"] += cgo_arrow([2.5, 72.5, 80.0],
[2.986, 72.519, 77.302],
color="red blue",
name="Arrows_17.763999939_8")
cmd.load_cgo(cluster_dict["17.763999939"], "Features_17.763999939", 1)
cmd.load_cgo(cluster_dict["17.763999939_arrows"], "Arrows_17.763999939")
cmd.set("transparency", 0.2, "Features_17.763999939")
cmd.group("Pharmacophore_17.763999939", members="Features_17.763999939")
cmd.group("Pharmacophore_17.763999939", members="Arrows_17.763999939")
if dirpath:
f = join(dirpath, "label_threshold_17.763999939.mol2")
else:
f = "label_threshold_17.763999939.mol2"
cmd.load(f, 'label_threshold_17.763999939')
cmd.hide('everything', 'label_threshold_17.763999939')
cmd.label("label_threshold_17.763999939", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
[-11.0, 50.5, 47.5], [-12.461, 48.729, 47.247],
color="red blue",
name="Arrows_15.4800000191_8")
cluster_dict["15.4800000191"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(-9.0),
float(55.5), float(48.0),
float(1.0)
]
cluster_dict["15.4800000191_arrows"] += cgo_arrow(
[-9.0, 55.5, 48.0], [-10.076, 57.643, 49.827],
color="red blue",
name="Arrows_15.4800000191_9")
cmd.load_cgo(cluster_dict["15.4800000191"], "Features_15.4800000191", 1)
cmd.load_cgo(cluster_dict["15.4800000191_arrows"], "Arrows_15.4800000191")
cmd.set("transparency", 0.2, "Features_15.4800000191")
cmd.group("Pharmacophore_15.4800000191", members="Features_15.4800000191")
cmd.group("Pharmacophore_15.4800000191", members="Arrows_15.4800000191")
if dirpath:
f = join(dirpath, "label_threshold_15.4800000191.mol2")
else:
f = "label_threshold_15.4800000191.mol2"
cmd.load(f, 'label_threshold_15.4800000191')
cmd.hide('everything', 'label_threshold_15.4800000191')
cmd.label("label_threshold_15.4800000191", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
[30.5, -36.5, 38.0], [27.542, -36.538, 38.091],
color="red blue",
name="Arrows_17.7140007019_5")
cluster_dict["17.7140007019"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(34.0),
float(-39.5), float(34.5),
float(1.0)
]
cluster_dict["17.7140007019_arrows"] += cgo_arrow(
[34.0, -39.5, 34.5], [33.968, -36.953, 33.337],
color="red blue",
name="Arrows_17.7140007019_6")
cmd.load_cgo(cluster_dict["17.7140007019"], "Features_17.7140007019", 1)
cmd.load_cgo(cluster_dict["17.7140007019_arrows"], "Arrows_17.7140007019")
cmd.set("transparency", 0.2, "Features_17.7140007019")
cmd.group("Pharmacophore_17.7140007019", members="Features_17.7140007019")
cmd.group("Pharmacophore_17.7140007019", members="Arrows_17.7140007019")
if dirpath:
f = join(dirpath, "label_threshold_17.7140007019.mol2")
else:
f = "label_threshold_17.7140007019.mol2"
cmd.load(f, 'label_threshold_17.7140007019')
cmd.hide('everything', 'label_threshold_17.7140007019')
cmd.label("label_threshold_17.7140007019", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
[13.5, -29.5, 22.5], [13.553, -32.357, 23.289],
color="red blue",
name="Arrows_13.5200004578_3")
cluster_dict["13.5200004578"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(16.0),
float(-23.5), float(20.0),
float(1.0)
]
cluster_dict["13.5200004578_arrows"] += cgo_arrow(
[16.0, -23.5, 20.0], [16.178, -24.525, 22.851],
color="red blue",
name="Arrows_13.5200004578_4")
cmd.load_cgo(cluster_dict["13.5200004578"], "Features_13.5200004578", 1)
cmd.load_cgo(cluster_dict["13.5200004578_arrows"], "Arrows_13.5200004578")
cmd.set("transparency", 0.2, "Features_13.5200004578")
cmd.group("Pharmacophore_13.5200004578", members="Features_13.5200004578")
cmd.group("Pharmacophore_13.5200004578", members="Arrows_13.5200004578")
if dirpath:
f = join(dirpath, "label_threshold_13.5200004578.mol2")
else:
f = "label_threshold_13.5200004578.mol2"
cmd.load(f, 'label_threshold_13.5200004578')
cmd.hide('everything', 'label_threshold_13.5200004578')
cmd.label("label_threshold_13.5200004578", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
for g in grids:
cmd.group('hotspot_%s' % (num), members='%s_%s' % (g, num))
cluster_dict = {"17.3369998932": [], "17.3369998932_arrows": []}
cluster_dict["17.3369998932"] += [COLOR, 1.00, 1.000, 0.000] + [ALPHA, 0.6] + [
SPHERE,
float(51.4998059097),
float(14.0001940903),
float(81.0001940903),
float(1.0)
]
cmd.load_cgo(cluster_dict["17.3369998932"], "Features_17.3369998932", 1)
cmd.load_cgo(cluster_dict["17.3369998932_arrows"], "Arrows_17.3369998932")
cmd.set("transparency", 0.2, "Features_17.3369998932")
cmd.group("Pharmacophore_17.3369998932", members="Features_17.3369998932")
cmd.group("Pharmacophore_17.3369998932", members="Arrows_17.3369998932")
if dirpath:
f = join(dirpath, "label_threshold_17.3369998932.mol2")
else:
f = "label_threshold_17.3369998932.mol2"
cmd.load(f, 'label_threshold_17.3369998932')
cmd.hide('everything', 'label_threshold_17.3369998932')
cmd.label("label_threshold_17.3369998932", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
cluster_dict["16.4349994659"] += [COLOR, 1.00, 1.000, 0.000] + [ALPHA, 0.6] + [SPHERE, float(2.9371830582), float(-0.593975542519), float(20.9172922631), float(1.0)]
cluster_dict["16.4349994659"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(2.5), float(-3.0), float(16.5), float(1.0)]
cluster_dict["16.4349994659_arrows"] += cgo_arrow([2.5,-3.0,16.5], [3.933,-5.403,17.063], color="red blue", name="Arrows_16.4349994659_5")
cluster_dict["16.4349994659"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(2.5), float(-3.0), float(16.5), float(1.0)]
cluster_dict["16.4349994659_arrows"] += cgo_arrow([2.5,-3.0,16.5], [3.933,-5.403,17.063], color="red blue", name="Arrows_16.4349994659_6")
cluster_dict["16.4349994659"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(4.0), float(3.0), float(22.5), float(1.0)]
cluster_dict["16.4349994659_arrows"] += cgo_arrow([4.0,3.0,22.5], [2.892,6.029,22.446], color="red blue", name="Arrows_16.4349994659_7")
cmd.load_cgo(cluster_dict["16.4349994659"], "Features_16.4349994659", 1)
cmd.load_cgo(cluster_dict["16.4349994659_arrows"], "Arrows_16.4349994659")
cmd.set("transparency", 0.2,"Features_16.4349994659")
cmd.group("Pharmacophore_16.4349994659", members="Features_16.4349994659")
cmd.group("Pharmacophore_16.4349994659", members="Arrows_16.4349994659")
if dirpath:
f = join(dirpath, "label_threshold_16.4349994659.mol2")
else:
f = "label_threshold_16.4349994659.mol2"
cmd.load(f, 'label_threshold_16.4349994659')
cmd.hide('everything', 'label_threshold_16.4349994659')
cmd.label("label_threshold_16.4349994659", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
def drawBoundingBox(selection="(all)", padding=0.0, linewidth=2.0, r=1.0, g=1.0, b=1.0):
"""
DESCRIPTION
Given selection, draw the bounding box around it.
USAGE:
drawBoundingBox [selection, [padding, [linewidth, [r, [g, b]]]]]
PARAMETERS:
selection, the selection to enboxen. :-)
defaults to (all)
padding, defaults to 0
linewidth, width of box lines
defaults to 2.0
r, red color component, valid range is [0.0, 1.0]
defaults to 1.0
g, green color component, valid range is [0.0, 1.0]
defaults to 1.0
b, blue color component, valid range is [0.0, 1.0]
defaults to 1.0
RETURNS
string, the name of the CGO box
NOTES
* This function creates a randomly named CGO box that minimally spans the protein. The
user can specify the width of the lines, the padding and also the color.
"""
([minX, minY, minZ],[maxX, maxY, maxZ]) = cmd.get_extent(selection)
print "Box dimensions (%.2f, %.2f, %.2f)" % (maxX-minX, maxY-minY, maxZ-minZ)
minX = minX - float(padding)-float(2.0)
minY = minY - float(padding)+float(1.5)
minZ = minZ - 0 #- float(padding)
maxX = maxX + float(padding)
maxY = maxY + float(padding)
maxZ = maxZ + 0 #float(padding)
if padding != 0:
print "Box dimensions + padding (%.2f, %.2f, %.2f)" % (maxX-minX, maxY-minY, maxZ-minZ)
boundingBox = [
LINEWIDTH, float(linewidth),
BEGIN, LINES,
COLOR, float(r), float(g), float(b),
VERTEX, minX, minY, minZ, #1
VERTEX, minX, minY, maxZ, #2
VERTEX, minX, maxY, minZ, #3
VERTEX, minX, maxY, maxZ, #4
VERTEX, maxX, minY, minZ, #5
VERTEX, maxX, minY, maxZ, #6
VERTEX, maxX, maxY, minZ, #7
VERTEX, maxX, maxY, maxZ, #8
VERTEX, minX, minY, minZ, #1
VERTEX, maxX, minY, minZ, #5
VERTEX, minX, maxY, minZ, #3
VERTEX, maxX, maxY, minZ, #7
VERTEX, minX, maxY, maxZ, #4
VERTEX, maxX, maxY, maxZ, #8
VERTEX, minX, minY, maxZ, #2
VERTEX, maxX, minY, maxZ, #6
VERTEX, minX, minY, minZ, #1
VERTEX, minX, maxY, minZ, #3
VERTEX, maxX, minY, minZ, #5
VERTEX, maxX, maxY, minZ, #7
VERTEX, minX, minY, maxZ, #2
VERTEX, minX, maxY, maxZ, #4
VERTEX, maxX, minY, maxZ, #6
VERTEX, maxX, maxY, maxZ, #8
END
]
boxName = "box_" + str(randint(0,10000))
while boxName in cmd.get_names():
boxName = "box_" + str(randint(0,10000))
cmd.load_cgo(boundingBox,boxName)
return boxName
[7.987, 30.477, 1.443],
color="red blue",
name="Arrows_18.422000885_7")
cluster_dict["18.422000885"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(10.0),
float(26.5), float(-5.0),
float(1.0)
]
cluster_dict["18.422000885_arrows"] += cgo_arrow([10.0, 26.5, -5.0],
[10.481, 25.868, -7.946],
color="red blue",
name="Arrows_18.422000885_8")
cmd.load_cgo(cluster_dict["18.422000885"], "Features_18.422000885", 1)
cmd.load_cgo(cluster_dict["18.422000885_arrows"], "Arrows_18.422000885")
cmd.set("transparency", 0.2, "Features_18.422000885")
cmd.group("Pharmacophore_18.422000885", members="Features_18.422000885")
cmd.group("Pharmacophore_18.422000885", members="Arrows_18.422000885")
if dirpath:
f = join(dirpath, "label_threshold_18.422000885.mol2")
else:
f = "label_threshold_18.422000885.mol2"
cmd.load(f, 'label_threshold_18.422000885')
cmd.hide('everything', 'label_threshold_18.422000885')
cmd.label("label_threshold_18.422000885", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
def main():
# create the axes object, draw axes with cylinders coloured red, green,
#blue for X, Y and Z
obj = [
CYLINDER,
0.,
0.,
0.,
10.,
0.,
0.,
0.2,
1.0,
1.0,
1.0,
1.0,
0.0,
0.,
CYLINDER,
0.,
0.,
0.,
0.,
10.,
0.,
0.2,
1.0,
1.0,
1.0,
0.,
1.0,
0.,
CYLINDER,
0.,
0.,
0.,
0.,
0.,
10.,
0.2,
1.0,
1.0,
1.0,
0.,
0.0,
1.0,
]
# add labels to axes object
cyl_text(obj,
plain, [-5., -5., -1],
'O',
0.20,
axes=[[3.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 3.0]])
cyl_text(obj,
plain, [10., 0., 0.],
'X',
0.20,
axes=[[3.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 3.0]])
cyl_text(obj,
plain, [0., 10., 0.],
'Y',
0.20,
axes=[[3.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 3.0]])
cyl_text(obj,
plain, [0., 0., 10.],
'Z',
0.20,
axes=[[3.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 3.0]])
# then we load it into PyMOL
cmd.load_cgo(obj, 'axes')
[5.0, 3.0, -21.0], [6.712, 1.082, -23.059],
color="red blue",
name="Arrows_10.4160003662_4")
cluster_dict["10.4160003662"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(5.0),
float(6.5), float(-22.5),
float(1.0)
]
cluster_dict["10.4160003662_arrows"] += cgo_arrow(
[5.0, 6.5, -22.5], [7.18, 6.139, -21.718],
color="red blue",
name="Arrows_10.4160003662_5")
cmd.load_cgo(cluster_dict["10.4160003662"], "Features_10.4160003662", 1)
cmd.load_cgo(cluster_dict["10.4160003662_arrows"], "Arrows_10.4160003662")
cmd.set("transparency", 0.2, "Features_10.4160003662")
cmd.group("Pharmacophore_10.4160003662", members="Features_10.4160003662")
cmd.group("Pharmacophore_10.4160003662", members="Arrows_10.4160003662")
if dirpath:
f = join(dirpath, "label_threshold_10.4160003662.mol2")
else:
f = "label_threshold_10.4160003662.mol2"
cmd.load(f, 'label_threshold_10.4160003662')
cmd.hide('everything', 'label_threshold_10.4160003662')
cmd.label("label_threshold_10.4160003662", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
cluster_dict["17.2399997711"] += [COLOR, 1.00, 1.000, 0.000] + [ALPHA, 0.6] + [SPHERE, float(51.8420978291), float(5.12592766064), float(-15.6567064325), float(1.0)]
cluster_dict["17.2399997711"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(44.0), float(0.0), float(-6.0), float(1.0)]
cluster_dict["17.2399997711_arrows"] += cgo_arrow([44.0,0.0,-6.0], [40.435,-0.517,-3.997], color="red blue", name="Arrows_17.2399997711_7")
cluster_dict["17.2399997711"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(49.5), float(4.0), float(-9.0), float(1.0)]
cluster_dict["17.2399997711_arrows"] += cgo_arrow([49.5,4.0,-9.0], [49.051,8.384,-6.905], color="red blue", name="Arrows_17.2399997711_8")
cluster_dict["17.2399997711"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(50.0), float(1.5), float(-15.0), float(1.0)]
cluster_dict["17.2399997711_arrows"] += cgo_arrow([50.0,1.5,-15.0], [52.853,-1.315,-14.363], color="red blue", name="Arrows_17.2399997711_9")
cmd.load_cgo(cluster_dict["17.2399997711"], "Features_17.2399997711", 1)
cmd.load_cgo(cluster_dict["17.2399997711_arrows"], "Arrows_17.2399997711")
cmd.set("transparency", 0.2,"Features_17.2399997711")
cmd.group("Pharmacophore_17.2399997711", members="Features_17.2399997711")
cmd.group("Pharmacophore_17.2399997711", members="Arrows_17.2399997711")
if dirpath:
f = join(dirpath, "label_threshold_17.2399997711.mol2")
else:
f = "label_threshold_17.2399997711.mol2"
cmd.load(f, 'label_threshold_17.2399997711')
cmd.hide('everything', 'label_threshold_17.2399997711')
cmd.label("label_threshold_17.2399997711", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
[20.0, 25.5, -9.5], [19.938, 27.001, -4.768],
color="red blue",
name="Arrows_15.7650003433_6")
cluster_dict["15.7650003433"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(22.0),
float(25.5), float(-7.0),
float(1.0)
]
cluster_dict["15.7650003433_arrows"] += cgo_arrow(
[22.0, 25.5, -7.0], [23.663, 26.711, -5.343],
color="red blue",
name="Arrows_15.7650003433_7")
cmd.load_cgo(cluster_dict["15.7650003433"], "Features_15.7650003433", 1)
cmd.load_cgo(cluster_dict["15.7650003433_arrows"], "Arrows_15.7650003433")
cmd.set("transparency", 0.2, "Features_15.7650003433")
cmd.group("Pharmacophore_15.7650003433", members="Features_15.7650003433")
cmd.group("Pharmacophore_15.7650003433", members="Arrows_15.7650003433")
if dirpath:
f = join(dirpath, "label_threshold_15.7650003433.mol2")
else:
f = "label_threshold_15.7650003433.mol2"
cmd.load(f, 'label_threshold_15.7650003433')
cmd.hide('everything', 'label_threshold_15.7650003433')
cmd.label("label_threshold_15.7650003433", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
[17.0, 8.5, 23.0], [16.349, 5.538, 22.439],
color="red blue",
name="Arrows_12.0889997482_5")
cluster_dict["12.0889997482"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(24.5),
float(6.5), float(25.5),
float(1.0)
]
cluster_dict["12.0889997482_arrows"] += cgo_arrow(
[24.5, 6.5, 25.5], [23.127, 3.857, 24.382],
color="red blue",
name="Arrows_12.0889997482_6")
cmd.load_cgo(cluster_dict["12.0889997482"], "Features_12.0889997482", 1)
cmd.load_cgo(cluster_dict["12.0889997482_arrows"], "Arrows_12.0889997482")
cmd.set("transparency", 0.2, "Features_12.0889997482")
cmd.group("Pharmacophore_12.0889997482", members="Features_12.0889997482")
cmd.group("Pharmacophore_12.0889997482", members="Arrows_12.0889997482")
if dirpath:
f = join(dirpath, "label_threshold_12.0889997482.mol2")
else:
f = "label_threshold_12.0889997482.mol2"
cmd.load(f, 'label_threshold_12.0889997482')
cmd.hide('everything', 'label_threshold_12.0889997482')
cmd.label("label_threshold_12.0889997482", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
float(3.78619756877),
float(1.0)
]
cluster_dict["7.11199998856"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(13.0),
float(7.5), float(6.5),
float(1.0)
]
cluster_dict["7.11199998856_arrows"] += cgo_arrow(
[13.0, 7.5, 6.5], [13.45, 5.144, 8.134],
color="red blue",
name="Arrows_7.11199998856_1")
cmd.load_cgo(cluster_dict["7.11199998856"], "Features_7.11199998856", 1)
cmd.load_cgo(cluster_dict["7.11199998856_arrows"], "Arrows_7.11199998856")
cmd.set("transparency", 0.2, "Features_7.11199998856")
cmd.group("Pharmacophore_7.11199998856", members="Features_7.11199998856")
cmd.group("Pharmacophore_7.11199998856", members="Arrows_7.11199998856")
if dirpath:
f = join(dirpath, "label_threshold_7.11199998856.mol2")
else:
f = "label_threshold_7.11199998856.mol2"
cmd.load(f, 'label_threshold_7.11199998856')
cmd.hide('everything', 'label_threshold_7.11199998856')
cmd.label("label_threshold_7.11199998856", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
[15.5, 0.0, 8.5], [16.741, 2.845, 7.975],
color="red blue",
name="Arrows_16.0149993896_8")
cluster_dict["16.0149993896"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(21.0),
float(-2.0), float(6.0),
float(1.0)
]
cluster_dict["16.0149993896_arrows"] += cgo_arrow(
[21.0, -2.0, 6.0], [20.52, 0.236, 4.302],
color="red blue",
name="Arrows_16.0149993896_9")
cmd.load_cgo(cluster_dict["16.0149993896"], "Features_16.0149993896", 1)
cmd.load_cgo(cluster_dict["16.0149993896_arrows"], "Arrows_16.0149993896")
cmd.set("transparency", 0.2, "Features_16.0149993896")
cmd.group("Pharmacophore_16.0149993896", members="Features_16.0149993896")
cmd.group("Pharmacophore_16.0149993896", members="Arrows_16.0149993896")
if dirpath:
f = join(dirpath, "label_threshold_16.0149993896.mol2")
else:
f = "label_threshold_16.0149993896.mol2"
cmd.load(f, 'label_threshold_16.0149993896')
cmd.hide('everything', 'label_threshold_16.0149993896')
cmd.label("label_threshold_16.0149993896", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
cluster_dict["16.8199996948"] += [COLOR, 1.00, 1.000, 0.000] + [ALPHA, 0.6] + [SPHERE, float(15.8594807538), float(-3.42854177321), float(11.2465827684), float(1.0)]
cluster_dict["16.8199996948"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(11.5), float(-0.5), float(12.5), float(1.0)]
cluster_dict["16.8199996948_arrows"] += cgo_arrow([11.5,-0.5,12.5], [10.671,-0.831,16.543], color="red blue", name="Arrows_16.8199996948_4")
cluster_dict["16.8199996948"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(14.0), float(-3.0), float(14.5), float(1.0)]
cluster_dict["16.8199996948_arrows"] += cgo_arrow([14.0,-3.0,14.5], [14.05,-0.469,16.069], color="red blue", name="Arrows_16.8199996948_5")
cluster_dict["16.8199996948"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(15.5), float(0.0), float(8.5), float(1.0)]
cluster_dict["16.8199996948_arrows"] += cgo_arrow([15.5,0.0,8.5], [16.741,2.845,7.975], color="red blue", name="Arrows_16.8199996948_6")
cmd.load_cgo(cluster_dict["16.8199996948"], "Features_16.8199996948", 1)
cmd.load_cgo(cluster_dict["16.8199996948_arrows"], "Arrows_16.8199996948")
cmd.set("transparency", 0.2,"Features_16.8199996948")
cmd.group("Pharmacophore_16.8199996948", members="Features_16.8199996948")
cmd.group("Pharmacophore_16.8199996948", members="Arrows_16.8199996948")
if dirpath:
f = join(dirpath, "label_threshold_16.8199996948.mol2")
else:
f = "label_threshold_16.8199996948.mol2"
cmd.load(f, 'label_threshold_16.8199996948')
cmd.hide('everything', 'label_threshold_16.8199996948')
cmd.label("label_threshold_16.8199996948", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
float(69.7399321544),
float(1.0)
]
cluster_dict["17.9330005646"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(-23.5),
float(-4.5), float(69.5),
float(1.0)
]
cluster_dict["17.9330005646_arrows"] += cgo_arrow(
[-23.5, -4.5, 69.5], [-25.168, -7.109, 69.248],
color="red blue",
name="Arrows_17.9330005646_1")
cmd.load_cgo(cluster_dict["17.9330005646"], "Features_17.9330005646", 1)
cmd.load_cgo(cluster_dict["17.9330005646_arrows"], "Arrows_17.9330005646")
cmd.set("transparency", 0.2, "Features_17.9330005646")
cmd.group("Pharmacophore_17.9330005646", members="Features_17.9330005646")
cmd.group("Pharmacophore_17.9330005646", members="Arrows_17.9330005646")
if dirpath:
f = join(dirpath, "label_threshold_17.9330005646.mol2")
else:
f = "label_threshold_17.9330005646.mol2"
cmd.load(f, 'label_threshold_17.9330005646')
cmd.hide('everything', 'label_threshold_17.9330005646')
cmd.label("label_threshold_17.9330005646", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
def draw(xparmfile, end, offset="0"):
"""
DESCRIPTION
Visualize XPARM.XDS
USAGE
load_xparm XPARM.XDS, framenumber [,frame offset]
end is the end number of frames
AUTHORS
Keitaro Yamashita, 2011
"""
end = int(end)
offset = int(offset)
if not hasattr(stored, "__xparm_internal__"):
stored.__xparm_internal__ = 1
else:
stored.__xparm_internal__ += 1
suffix = str(stored.__xparm_internal__)
param = XPARM(xparmfile)
origin = numpy.zeros(3)
gonio = obj_phigonio(origin, param.rotation_axis, scale=6)
beam = obj_beam(origin, param.incident_beam, param.wavelength, scale=10)
cmd.load_cgo(gonio, "gonio_" + suffix)
cmd.load_cgo(beam, "beam_" + suffix)
load_ewald(origin,
param.incident_beam,
param.wavelength,
scale=10,
name="Ewald_" + suffix)
# Rotate space by phi axis
for i, d in enumerate([
param.starting_angle + (i + 0.5 + offset) * param.osc_range
for i in xrange(end)
]):
print i, d
R = rot_matrix(param.rotation_axis, numpy.radians(d))
A = numpy.array(numpy.dot(R, param.a_axis))[0]
B = numpy.array(numpy.dot(R, param.b_axis))[0]
C = numpy.array(numpy.dot(R, param.c_axis))[0]
rA, rB, rC = reciprocal(A, B, C)
#print "real vectors:", A, B, C
#print "reciprocal vectors:", rA, rB, rC
scale = .5 * .2 * min(
[numpy.linalg.norm(A),
numpy.linalg.norm(B),
numpy.linalg.norm(C)]) / max([
numpy.linalg.norm(rA),
numpy.linalg.norm(rB),
numpy.linalg.norm(rC)
])
# Unit vectors
a_axis = obj_axis(origin, A * .2, "a")
b_axis = obj_axis(origin, B * .2, "b")
c_axis = obj_axis(origin, C * .2, "c")
# Reciprocal unit vectors
as_axis = obj_axis(origin, rA * scale, "a")
bs_axis = obj_axis(origin, rB * scale, "b")
cs_axis = obj_axis(origin, rC * scale, "c")
cmd.load_cgo(a_axis + b_axis + c_axis, "axes_" + suffix, i + 1)
cmd.load_cgo(as_axis + bs_axis + cs_axis, "reciprocal_axes_" + suffix,
i + 1)
3.23,
-7.05,
-19.82,
18.34,
0.2,
1.0,
1.0,
1.0,
0.,
1.0,
0.,
CYLINDER,
13.79,
-7.71,
-1.24,
-21.45,
4.87,
21.32,
0.2,
1.0,
1.0,
1.0,
0.,
0.0,
1.0,
]
# then we load it into PyMOL
cmd.load_cgo(obj, 'out_B_4')
def supercell(a=1, b=1, c=1, object=None, color='blue', name='supercell', withmates=1):
"""
DESCRIPTION
Draw a supercell, as requested by Nicolas Bock on the pymol-users
mailing list (Subject: [PyMOL] feature request: supercell construction
Date: 04/12/2010 10:12:17 PM (Mon, 12 Apr 2010 14:12:17 -0600))
USAGE
supercell a, b, c [, object [, color [, name [, withmates]]]]
ARGUMENTS
a, b, c = integer: repeat cell in x,y,z direction a,b,c times
{default: 1,1,1}
object = string: name of object to take cell definition from
color = string: color of cell {default: blue}
name = string: name of the cgo object to create {default: supercell}
withmates = bool: also create symmetry mates in displayed cells
{default: 1}
SEE ALSO
show cell
"""
if object is None:
object = cmd.get_object_list()[0]
withmates = int(withmates)
sym = cmd.get_symmetry(object)
cell_edges = sym[0:3]
cell_angles = sym[3:6]
basis = cellbasis(cell_angles, cell_edges)
assert isinstance(basis, np.ndarray)
ts = list()
for i in range(int(a)):
for j in range(int(b)):
for k in range(int(c)):
ts.append([i,j,k])
obj = [
cgo.BEGIN,
cgo.LINES,
cgo.COLOR,
]
obj.extend(cmd.get_color_tuple(color))
for t in ts:
shift = basis[0:3,0:3] * t
shift = shift[:,0] + shift[:,1] + shift[:,2]
for i in range(3):
vi = basis[0:3,i]
vj = [
np.array([0.,0.,0.]),
basis[0:3,(i+1)%3],
basis[0:3,(i+2)%3],
basis[0:3,(i+1)%3] + basis[0:3,(i+2)%3]
]
for j in range(4):
obj.append(cgo.VERTEX)
obj.extend((shift + vj[j]).tolist())
obj.append(cgo.VERTEX)
obj.extend((shift + vj[j] + vi).tolist())
if withmates:
symexpcell('m%d%d%d_' % tuple(t), object, *t)
obj.append(cgo.END)
cmd.delete(name)
cmd.load_cgo(obj, name)
cluster_dict["12.9040002823"] += [COLOR, 0.00, 0.00, 1.00] + [ALPHA, 0.6] + [SPHERE, float(68.0), float(53.0), float(65.0), float(1.0)]
cluster_dict["12.9040002823_arrows"] += cgo_arrow([68.0,53.0,65.0], [65.785,54.765,65.83], color="blue red", name="Arrows_12.9040002823_3")
cluster_dict["12.9040002823"] += [COLOR, 1.00, 1.000, 0.000] + [ALPHA, 0.6] + [SPHERE, float(68.0885970834), float(51.0922228063), float(60.2126804208), float(1.0)]
cluster_dict["12.9040002823"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(69.0), float(54.5), float(60.5), float(1.0)]
cluster_dict["12.9040002823_arrows"] += cgo_arrow([69.0,54.5,60.5], [68.789,56.273,57.186], color="red blue", name="Arrows_12.9040002823_4")
cluster_dict["12.9040002823"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(69.0), float(54.5), float(60.5), float(1.0)]
cluster_dict["12.9040002823_arrows"] += cgo_arrow([69.0,54.5,60.5], [68.789,56.273,57.186], color="red blue", name="Arrows_12.9040002823_5")
cmd.load_cgo(cluster_dict["12.9040002823"], "Features_12.9040002823", 1)
cmd.load_cgo(cluster_dict["12.9040002823_arrows"], "Arrows_12.9040002823")
cmd.set("transparency", 0.2,"Features_12.9040002823")
cmd.group("Pharmacophore_12.9040002823", members="Features_12.9040002823")
cmd.group("Pharmacophore_12.9040002823", members="Arrows_12.9040002823")
if dirpath:
f = join(dirpath, "label_threshold_12.9040002823.mol2")
else:
f = "label_threshold_12.9040002823.mol2"
cmd.load(f, 'label_threshold_12.9040002823')
cmd.hide('everything', 'label_threshold_12.9040002823')
cmd.label("label_threshold_12.9040002823", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
CYLINDER,
0,
0,
0,
8.135000,
1.827500,
0.779500,
0.25,
1,
1,
1,
1.000000,
0.400000,
0.400000,
]
cmd.load_cgo(obj, 'Ex2_929_1.67')
obj = [
CYLINDER,
0,
0,
0,
4.734000,
7.747500,
-1.031500,
0.25,
1,
1,
1,
1.000000,
0.400000,
0.400000,
[41.0, 11.0, 64.0], [37.79, 10.544, 67.284],
color="red blue",
name="Arrows_13.9219999313_8")
cluster_dict["13.9219999313"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(41.5),
float(18.0), float(62.5),
float(1.0)
]
cluster_dict["13.9219999313_arrows"] += cgo_arrow(
[41.5, 18.0, 62.5], [45.018, 17.321, 62.219],
color="red blue",
name="Arrows_13.9219999313_9")
cmd.load_cgo(cluster_dict["13.9219999313"], "Features_13.9219999313", 1)
cmd.load_cgo(cluster_dict["13.9219999313_arrows"], "Arrows_13.9219999313")
cmd.set("transparency", 0.2, "Features_13.9219999313")
cmd.group("Pharmacophore_13.9219999313", members="Features_13.9219999313")
cmd.group("Pharmacophore_13.9219999313", members="Arrows_13.9219999313")
if dirpath:
f = join(dirpath, "label_threshold_13.9219999313.mol2")
else:
f = "label_threshold_13.9219999313.mol2"
cmd.load(f, 'label_threshold_13.9219999313')
cmd.hide('everything', 'label_threshold_13.9219999313')
cmd.label("label_threshold_13.9219999313", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
[-21.0, 10.5, -40.0], [-22.802, 10.056, -41.995],
color="red blue",
name="Arrows_9.60299968719_1")
cluster_dict["9.60299968719"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(-13.0),
float(10.5), float(-43.0),
float(1.0)
]
cluster_dict["9.60299968719_arrows"] += cgo_arrow(
[-13.0, 10.5, -43.0], [-12.975, 10.853, -46.004],
color="red blue",
name="Arrows_9.60299968719_2")
cmd.load_cgo(cluster_dict["9.60299968719"], "Features_9.60299968719", 1)
cmd.load_cgo(cluster_dict["9.60299968719_arrows"], "Arrows_9.60299968719")
cmd.set("transparency", 0.2, "Features_9.60299968719")
cmd.group("Pharmacophore_9.60299968719", members="Features_9.60299968719")
cmd.group("Pharmacophore_9.60299968719", members="Arrows_9.60299968719")
if dirpath:
f = join(dirpath, "label_threshold_9.60299968719.mol2")
else:
f = "label_threshold_9.60299968719.mol2"
cmd.load(f, 'label_threshold_9.60299968719')
cmd.hide('everything', 'label_threshold_9.60299968719')
cmd.label("label_threshold_9.60299968719", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
float(74.0), float(16.5),
float(1.0)
]
cluster_dict["32.7789993286_arrows"] += cgo_arrow(
[19.0, 74.0, 16.5], [20.035, 77.898, 13.86],
color="red blue",
name="Arrows_32.7789993286_8")
cluster_dict["32.7789993286"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(19.5),
float(72.5), float(17.0),
float(1.0)
]
cmd.load_cgo(cluster_dict["32.7789993286"], "Features_32.7789993286", 1)
cmd.load_cgo(cluster_dict["32.7789993286_arrows"], "Arrows_32.7789993286")
cmd.set("transparency", 0.2, "Features_32.7789993286")
cmd.group("Pharmacophore_32.7789993286", members="Features_32.7789993286")
cmd.group("Pharmacophore_32.7789993286", members="Arrows_32.7789993286")
if dirpath:
f = join(dirpath, "label_threshold_32.7789993286.mol2")
else:
f = "label_threshold_32.7789993286.mol2"
cmd.load(f, 'label_threshold_32.7789993286')
cmd.hide('everything', 'label_threshold_32.7789993286')
cmd.label("label_threshold_32.7789993286", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
cluster_dict["12.625_arrows"] += cgo_arrow([14.0,55.0,22.5], [14.391,54.985,20.064], color="red blue", name="Arrows_12.625_5")
cluster_dict["12.625"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(14.5), float(52.0), float(19.0), float(1.0)]
cluster_dict["12.625_arrows"] += cgo_arrow([14.5,52.0,19.0], [12.54,51.945,16.891], color="red blue", name="Arrows_12.625_6")
cluster_dict["12.625"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(15.5), float(53.5), float(21.5), float(1.0)]
cluster_dict["12.625_arrows"] += cgo_arrow([15.5,53.5,21.5], [14.391,54.985,20.064], color="red blue", name="Arrows_12.625_7")
cluster_dict["12.625"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [SPHERE, float(17.0), float(45.5), float(27.5), float(1.0)]
cluster_dict["12.625_arrows"] += cgo_arrow([17.0,45.5,27.5], [19.435,44.038,28.278], color="red blue", name="Arrows_12.625_8")
cmd.load_cgo(cluster_dict["12.625"], "Features_12.625", 1)
cmd.load_cgo(cluster_dict["12.625_arrows"], "Arrows_12.625")
cmd.set("transparency", 0.2,"Features_12.625")
cmd.group("Pharmacophore_12.625", members="Features_12.625")
cmd.group("Pharmacophore_12.625", members="Arrows_12.625")
if dirpath:
f = join(dirpath, "label_threshold_12.625.mol2")
else:
f = "label_threshold_12.625.mol2"
cmd.load(f, 'label_threshold_12.625')
cmd.hide('everything', 'label_threshold_12.625')
cmd.label("label_threshold_12.625", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
-0.76,
3.11,
20.55,
1.09,
0.2,
1.0,
1.0,
1.0,
0.,
1.0,
0.,
CYLINDER,
-33.26,
-2.11,
-0.35,
32.08,
1.02,
0.73,
0.2,
1.0,
1.0,
1.0,
0.,
0.0,
1.0,
]
# then we load it into PyMOL
cmd.load_cgo(obj, 'out_predicted')
[-21.5, 9.5, -12.0], [-20.258, 10.438, -14.847],
color="red blue",
name="Arrows_16.5540008545_8")
cluster_dict["16.5540008545"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(-22.0),
float(2.5), float(-11.5),
float(1.0)
]
cluster_dict["16.5540008545_arrows"] += cgo_arrow(
[-22.0, 2.5, -11.5], [-25.126, 3.115, -12.834],
color="red blue",
name="Arrows_16.5540008545_9")
cmd.load_cgo(cluster_dict["16.5540008545"], "Features_16.5540008545", 1)
cmd.load_cgo(cluster_dict["16.5540008545_arrows"], "Arrows_16.5540008545")
cmd.set("transparency", 0.2, "Features_16.5540008545")
cmd.group("Pharmacophore_16.5540008545", members="Features_16.5540008545")
cmd.group("Pharmacophore_16.5540008545", members="Arrows_16.5540008545")
if dirpath:
f = join(dirpath, "label_threshold_16.5540008545.mol2")
else:
f = "label_threshold_16.5540008545.mol2"
cmd.load(f, 'label_threshold_16.5540008545')
cmd.hide('everything', 'label_threshold_16.5540008545')
cmd.label("label_threshold_16.5540008545", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
float(0.5), float(-22.0),
float(1.0)
]
cluster_dict["16.767999649"] += [COLOR, 1.00, 0.00, 0.00] + [ALPHA, 0.6] + [
SPHERE, float(46.5),
float(6.5), float(-26.0),
float(1.0)
]
cluster_dict["16.767999649_arrows"] += cgo_arrow([46.5, 6.5, -26.0],
[47.586, 4.444, -27.546],
color="red blue",
name="Arrows_16.767999649_8")
cmd.load_cgo(cluster_dict["16.767999649"], "Features_16.767999649", 1)
cmd.load_cgo(cluster_dict["16.767999649_arrows"], "Arrows_16.767999649")
cmd.set("transparency", 0.2, "Features_16.767999649")
cmd.group("Pharmacophore_16.767999649", members="Features_16.767999649")
cmd.group("Pharmacophore_16.767999649", members="Arrows_16.767999649")
if dirpath:
f = join(dirpath, "label_threshold_16.767999649.mol2")
else:
f = "label_threshold_16.767999649.mol2"
cmd.load(f, 'label_threshold_16.767999649')
cmd.hide('everything', 'label_threshold_16.767999649')
cmd.label("label_threshold_16.767999649", "name")
cmd.set("label_font_id", 7)
cmd.set("label_size", -0.4)
